Default fresh normal ACE sessions to the 100 W event operating point

roadscore/prototype/normal_onroad.py

@@ -6,7 +6,7 @@ No RoadScore event annotations, route allowlist, custom camera drawing, or model
 import argparse,os,subprocess,time,signal,shlex,json
 from pathlib import Path
 from clock_sync import measure
-from receiver_environment import assignments as receiver_assignments
+from receiver_environment import assignments as receiver_assignments,resolve_compute
 from presentation_policy import select_launch
 from hook_launch import enabled as hook_enabled, start_planner
 from session_seed import select_session, seed_argument, seed_environment, remote_assignments
@@ -39,6 +39,9 @@ if session:
  env.update(seed_environment(session));(out/'session_seed.json').write_text(json.dumps(session,indent=2));print('RoadScore session seed:',session['generation_seed'],'('+session['seed_origin']+')',flush=True)
 else:
  env.pop('ROADSCORE_GENERATION_SEED',None);env.pop('ROADSCORE_SEED_ORIGIN',None)
+compute=resolve_compute(env,composer=a.composer,replay=a.replay,judging=bool(session and session['seed_origin']=='judging-route'),transport_only=a.transport_only)
+(out/'compute_settings.json').write_text(json.dumps(compute,indent=2))
+if session:print('Requested Chestnut cap:',compute['requested_power_limit_watts'],'W; TC_OPT:',compute['tc_opt'],'(actual readback recorded separately)',flush=True)
 (out/'settings.json').write_text(json.dumps({**settings.snapshot(a.headless),'composer':a.composer,'profile':a.profile,'render_mode':a.render_mode,'presentation_policy':presentation['policy'],'composition_policy':composition_policy,**(session or {})},indent=2))
 env['ROADSCORE_RENDER_MODE']=a.render_mode
 env['ROADSCORE_PRESENTATION_POLICY']=presentation['policy']

roadscore/prototype/receiver_environment.py

@@ -6,3 +6,14 @@ KEYS = ('ROADSCORE_PRESENTATION_POLICY', 'ROADSCORE_COMPOSITION_POLICY',
 
 def assignments(env):
     return ''.join(key + '=' + shlex.quote(env[key]) + ' ' for key in KEYS if key in env)
+
+def resolve_compute(env, *, composer, replay=False, judging=False, transport_only=False):
+    """Normal event defaults; frozen cohorts and explicit mitigation settings stay intact."""
+    normal = composer == 'ace' and not (replay or judging or transport_only)
+    if normal:
+        env.setdefault('AM_POWER_LIMIT', '100')
+        env.setdefault('TC_OPT', '2')
+    return {'policy': 'normal-event-100w-v1' if normal else 'preserved-environment',
+            'requested_power_limit_watts': env.get('AM_POWER_LIMIT'),
+            'tc_opt': env.get('TC_OPT'),
+            'actual_power_limit_watts': None}

roadscore/prototype/test_receiver_environment.py

@@ -1,5 +1,5 @@
 import shlex,unittest
-from receiver_environment import assignments
+from receiver_environment import assignments,resolve_compute
 class ReceiverEnvironmentTests(unittest.TestCase):
  def test_power_graph_and_policy_cross_receiver_boundary(self):
   env={'AM_POWER_LIMIT':'100','TC_OPT':'2','ROADSCORE_COMPOSITION_POLICY':'hook-v2','ROADSCORE_PLANNER_TOKEN':'private value; $(no)','UNRELATED_SECRET':'omit'}
@@ -7,4 +7,17 @@ class ReceiverEnvironmentTests(unittest.TestCase):
   self.assertEqual(actual,{k:v for k,v in env.items() if k!='UNRELATED_SECRET'})
  def test_absent_power_does_not_rewrite_frozen_policy(self):
   self.assertEqual(assignments({}),'')
+ def test_plain_fresh_ace_resolves_event_settings(self):
+  env={};record=resolve_compute(env,composer='ace')
+  self.assertEqual(env,{'AM_POWER_LIMIT':'100','TC_OPT':'2'})
+  self.assertIsNone(record['actual_power_limit_watts'])
+  self.assertEqual(dict(item.split('=',1) for item in shlex.split(assignments(env))),env)
+ def test_explicit_mitigation_and_graph_settings_survive(self):
+  env={'AM_POWER_LIMIT':'75','TC_OPT':'1'};resolve_compute(env,composer='ace')
+  self.assertEqual(env,{'AM_POWER_LIMIT':'75','TC_OPT':'1'})
+ def test_frozen_stored_other_and_transport_get_no_defaults(self):
+  for options in [{'judging':True},{'replay':True},{'transport_only':True},{'composer':'sa3'}]:
+   env={};resolve_compute(env,**{'composer':'ace',**options});self.assertEqual(env,{})
+  env={'AM_POWER_LIMIT':'45'};resolve_compute(env,composer='ace',judging=True)
+  self.assertEqual(env,{'AM_POWER_LIMIT':'45'})
 if __name__=='__main__':unittest.main()