Fix CSS injection with disabled page scripting and browser workspace setup

Use synchronous style DOM insertion; add runtime computed-style preflight; report exact setup stage; use writable private HOME/XDG/temp paths and subprocess UID/GID rather than Python preexec hooks. Separate read-only requests from writable Docker workspaces. Fixed 350-task dataset unchanged. Live Modal verification remains outstanding.

README.md

@@ -135,3 +135,10 @@ The `phase-watchdog-v1` evaluator supervises the browser worker in a separate pr
 A candidate-phase timeout preserves successful syntax parsing and completed observations, fails the unfinished assertions, and lets later tasks continue. Setup failures remain infrastructure errors and do not receive an invented score. The supervisor kills the worker process group during cleanup. Docker/Modal outer deadlines provide additional containment; an outer infrastructure timeout remains a failed evaluation. Modal evaluators run without credentials, and worker environments are explicitly filtered.
 
 Rebuild the Docker image after updating these files. The Modal launcher automatically submits the updated supervisor and worker image. Full browser runtime validation remains unverified in the local authoring environment; watchdog regression tests use trusted synthetic worker fixtures.
+
+
+### CSS fixture setup correction
+
+CSS styles are inserted synchronously with a DOM style element; the evaluator does not use Playwright 1.56 `add_style_tag`, whose inline-style path waits for a `load` callback. This avoids waiting for that callback on the HTML/CSS pages with scripting disabled. Trusted fixture and baseline errors remain infrastructure failures, separate from candidate execution. Timeout diagnostics now name the precise phase, operation, scenario and language and include bounded worker stderr.
+
+The Modal path first checks runtime availability and a trusted CSS computed-style/distractor probe, before model generation. Worker processes use explicit subprocess UID/GID settings and private writable HOME/XDG/TMP directories; no Python pre-exec callback is used in the threaded launcher. These changes preserve the fixed 350-example dataset and scoring definition. End-to-end Modal browser verification is still required; local tests cover the injection protocol, diagnostic fields, preflight failure and watchdog behavior.

SHA256SUMS

@@ -1,6 +1,6 @@
 ff73ee904edc9381bd1ea24847e41c6176aec22ba4b63321e8354562f24ba5ce  .gitignore
 8719af4397a8387b8f04140613943545f8ecd90f06529dcab9e68a94927d13fe  LICENSE
-79bde23371c74e742d81b9eedcb41c3bbc1f6a22a89a7d4fe29578e43f662353  README.md
+f1025bcd6a338e93766ddeacb39f2aaf9edb743b9f418968f46bcd13aa14b862  README.md
 2447d09ae445094c1ae59df644b46e3ca2f4cc64de630966b94bd5db8b8bf0ac  archive/v0.1.0/hidden.jsonl
 1926bca1b0c6b2244554577135a9c3c305b18fd834c654803b4e8480fff0d3d9  archive/v0.1.0/smolscript.jsonl
 7bf25948750648aa036bdf277cfd7c38597c98aa06131e805628b9055a7938d9  archive/v0.1.0/smolscript.parquet
@@ -12,7 +12,7 @@ ff73ee904edc9381bd1ea24847e41c6176aec22ba4b63321e8354562f24ba5ce  .gitignore
 9f9798909d3ab3631a457de1bc7e573c546ed3f3b0f78e6bcb82780e280b37b3  data/smolscript.jsonl
 ad56c7186df28d84a23912a7fa2ec28b6762240a33b7b2a49412ce5b47319862  data/smolscript.parquet
 96bc6e69d752e9fee97389dd15d921173f603c9ce972b1defa49549e977032b1  evaluate.py
-3999b70595e7a873bb2b3de2877de69da280043a91351d33e26872aaa9dcb416  examples/local-test-report.json
+9395164c1296d2d71c6c61a9ed367564c6a06d5933f0aeb2ed62d652561c857d  examples/local-test-report.json
 713855348ffc53f49b03a0df47b67294fe2d3593054636eec12b9f184fb3534e  examples/result-format.json
 b0871e1f323ac493a0e413d1ac085b1cda3c94e496a1bfecac11aa58773d3144  generation_settings.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  generators/__init__.py
@@ -42,10 +42,10 @@ efabd7a4b829eb917116a2f51358a8fa8056370dbb57f6b6a9646c1cd342ffc5  runners/python
 63514e35b2687742ea6453e15d089da5a6cb4ab57ca0100da6189b187511ecf7  runners/rust_runner.py
 d9ebf5141e3c1928879865050bf3ad7773613084fe62a0ff7eac8d1ea69f8cc4  runners/sandbox.py
 53098a63b7d2053a4d8494c340e63d924646255c297d31e78c0025ef552c6cd6  sandbox/Dockerfile
-64e26d439e80819fac084f21b3831543d7b3b9ef7cd7afdaa5d9767a033777e1  sandbox/supervisor.py
-13628f680958644d71c5ba74216bbb06f3fe8928f8b727e02d99944ccfe2f904  sandbox/worker.py
+013cc442aa61d4b85f1986b111ea9adea5f9749bf0cef5176faa67963c900e7c  sandbox/supervisor.py
+538b3c7176b678e6a2b2a55a52aaa2e4a03accc20b2d7d850ee67695f5ecdc9f  sandbox/worker.py
 c155b14ce8fa94dd4a179c22e6ab13accadffcf3571f384d27985ba916cbf864  tests/test_core.py
-5a408508d1548d7530bd20af0c3c14fa06b43dbf7e8582868b417265d207e906  tests/test_watchdog.py
+14f40a4b954c81dcf6cb8a2bdf361023e8cea36b54b31e40657f92f39433c124  tests/test_watchdog.py
 ffba2ed9eabec6186a7568ff0535c9733841b661f7c1e420770dbeb47d87dbae  validate.py
 845d1ef1d45133e04908e1ff187281b9af9f4e48c2bec1994f91b1b191d5d563  validation_report.json
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  validators/__init__.py

examples/local-test-report.json

@@ -1,6 +1,6 @@
 {
   "unit_tests": {
-    "passed": 17,
+    "passed": 21,
     "command": "python -m unittest discover -s tests -q"
   },
   "python_reference_ast_parse": 44,
@@ -24,5 +24,6 @@
   "model_baselines": "not run",
   "gpu_throughput_benchmark": "not run",
   "watchdog_policy": "phase-watchdog-v1",
-  "watchdog_test_execution": "trusted synthetic workers; candidate generations not executed on host"
+  "watchdog_test_execution": "trusted synthetic workers; candidate generations not executed on host",
+  "browser_setup_patch": "synchronous-css-private-home-v1"
 }

sandbox/supervisor.py

@@ -9,28 +9,35 @@ import tempfile
 import time
 
 
-def supervise(request, worker='/opt/smolscript/worker.py', demote=None,
-              startup_seconds=45, candidate_seconds=None, total_seconds=240):
-    payload=json.loads(Path(request).read_text())
+def supervise(request, worker='/opt/smolscript/worker.py', worker_uid=None, worker_gid=None,
+              startup_seconds=45, candidate_seconds=None, total_seconds=240, workspace=None):
+    request=Path(request).resolve()
+    workspace=Path(workspace).resolve() if workspace is not None else request.parent
+    payload=json.loads(request.read_text())
     if candidate_seconds is None:candidate_seconds=max(6,3*payload.get('timeout_seconds',3))
-    with tempfile.TemporaryDirectory(dir=Path(request).parent,prefix='watchdog-') as directory:
+    with tempfile.TemporaryDirectory(dir=workspace,prefix='watchdog-') as directory:
         os.chmod(directory,0o777)
         state_path=Path(directory)/'state.json'
         env={k:v for k,v in os.environ.items() if k in ('PATH','HOME','LANG','LC_ALL','TZ','PYTHONHASHSEED','PYTHONPATH','PLAYWRIGHT_BROWSERS_PATH')}
         env['SMOLSCRIPT_WORKER_STATE']=str(state_path)
+        env['HOME']=str(workspace)
+        for key,name in (('XDG_CACHE_HOME','cache'),('XDG_CONFIG_HOME','config'),('TMPDIR','tmp')):
+            target=Path(directory)/name;target.mkdir(mode=0o777);target.chmod(0o777);env[key]=str(target)
+        credentials={}
+        if worker_uid is not None:credentials.update(user=worker_uid,group=worker_gid,extra_groups=[])
         with tempfile.TemporaryFile() as stdout,tempfile.TemporaryFile() as stderr:
-            process=subprocess.Popen([sys.executable,str(worker),str(request)],cwd=Path(request).parent,
-                stdout=stdout,stderr=stderr,env=env,start_new_session=True,preexec_fn=demote)
+            process=subprocess.Popen([sys.executable,str(worker),str(request)],cwd=workspace,
+                stdout=stdout,stderr=stderr,env=env,start_new_session=True,**credentials)
             started=time.monotonic();phase_started=started;previous=None;state={}
             try:
                 while process.poll() is None:
                     try:state=json.loads(state_path.read_text())
                     except (FileNotFoundError,json.JSONDecodeError):pass
-                    phase=(state.get('phase'),state.get('scenario'))
+                    phase=(state.get('phase'),state.get('scenario'),state.get('operation'))
                     if phase!=previous:previous=phase;phase_started=time.monotonic()
                     now=time.monotonic()
-                    candidate=state.get('phase')=='candidate'
-                    browser=payload.get('kind') in ('html','css','dom')
+                    candidate=state.get('phase')=='candidate' and not payload.get('diagnostic')
+                    browser=payload.get('diagnostic') or payload.get('kind') in ('html','css','dom')
                     limit=(candidate_seconds if candidate else startup_seconds) if browser else total_seconds
                     if now-phase_started>limit or now-started>total_seconds:
                         if candidate and state.get('syntax_success') is True:
@@ -39,7 +46,11 @@ def supervise(request, worker='/opt/smolscript/worker.py', demote=None,
                                 observations.append({'actual':[],'baseline':[],
                                     'error':'CandidateTimeout: browser execution exceeded its wall-time limit'})
                             return {'syntax_success':True,'observations':observations,'candidate_timeout':True}
-                        raise RuntimeError('SmolScript worker timed out during browser/runtime setup; evaluation incomplete')
+                        stderr.seek(0)
+                        detail=stderr.read(2000).decode('utf8','replace')
+                        raise RuntimeError('SmolScript worker timed out during browser/runtime setup; evaluation incomplete; '
+                            f"phase={state.get('phase','worker_start')} operation={state.get('operation')} "
+                            f"scenario={state.get('scenario')} language={payload.get('language',payload.get('kind'))}; stderr={detail}")
                     try:process.wait(timeout=.1)
                     except subprocess.TimeoutExpired:pass
                 stdout.seek(0);stderr.seek(0)
@@ -55,6 +66,6 @@ def supervise(request, worker='/opt/smolscript/worker.py', demote=None,
                 process.wait(timeout=5)
 
 if __name__=='__main__':
-    try:response=supervise(sys.argv[1])
+    try:response=supervise(sys.argv[1],workspace=Path.cwd())
     except Exception as exc:response={'infrastructure_error':type(exc).__name__+': '+str(exc)[:2000]}
     print(json.dumps(response,allow_nan=False))

sandbox/worker.py

@@ -10,12 +10,12 @@ import tempfile
 from protocol import COMMANDS,wrap_source
 
 
-def publish_state(phase,observations=None,scenario=None):
+def publish_state(phase,observations=None,scenario=None,operation=None):
     path=os.environ.get('SMOLSCRIPT_WORKER_STATE')
     if not path:return
     target=Path(path);tmp=target.with_suffix('.tmp')
     tmp.write_text(json.dumps({'phase':phase,'syntax_success':True,
-                              'scenario':scenario,'observations':observations or []}))
+                              'scenario':scenario,'operation':operation,'observations':observations or []}))
     tmp.replace(target)
 
 
@@ -75,6 +75,16 @@ def observe(page,check):
     raise ValueError(kind)
 
 
+def inject_css(page,css):
+    # Playwright 1.56 add_style_tag awaits a stylesheet load callback, which can
+    # stall with page scripting disabled. CSSOM insertion needs no event callback.
+    page.evaluate("""css => {
+        const style=document.createElement('style');
+        style.textContent=css;
+        document.head.appendChild(style);
+    }""",css)
+
+
 def browser(request):
     from playwright.sync_api import sync_playwright,TimeoutError as BrowserTimeout
     kind=request['kind'];code=request['code']
@@ -99,25 +109,30 @@ def browser(request):
         syntax=execute(['node','--check','candidate.js'],'',5)['exit_code']==0
     if not syntax:return {'syntax_success':False,'observations':[]}
     observations=[]
-    publish_state('browser_startup')
+    publish_state('browser_startup',operation='playwright_driver')
     with sync_playwright() as p:
         # Container namespace, seccomp, uid, cgroups and disabled networking are
         # the mandatory boundary; no browser flag substitutes for that boundary.
+        publish_state('browser_startup',operation='chromium_launch')
         b=p.chromium.launch(headless=True,timeout=20000,args=['--disable-dev-shm-usage'])
         try:
             for index,scenario in enumerate(request['scenarios']):
-                publish_state('fixture_setup',observations,index)
+                publish_state('fixture_setup',observations,index,'new_page')
                 page=b.new_page(viewport={'width':scenario.get('viewport',800),'height':600},java_script_enabled=kind=='dom')
                 page.set_default_timeout(request['timeout_seconds']*1000)
                 page.route('**/*',lambda route:route.abort())
                 actual=[];baseline=[];error=None
+                publish_state('fixture_setup',observations,index,'fixture_document')
+                page.set_content(request['fixture'],wait_until='domcontentloaded')
+                if request.get('base_css'):
+                    publish_state('fixture_setup',observations,index,'base_css')
+                    inject_css(page,request['base_css'])
+                publish_state('fixture_setup',observations,index,'baseline_observations')
+                baseline=[observe(page,c) if c['kind']=='unchanged' else None for c in scenario['checks']]
+                publish_state('candidate',observations,index,'candidate_execution')
                 try:
-                    page.set_content(request['fixture'],wait_until='domcontentloaded')
-                    if request.get('base_css'):page.add_style_tag(content=request['base_css'])
-                    baseline=[observe(page,c) if c['kind']=='unchanged' else None for c in scenario['checks']]
-                    publish_state('candidate',observations,index)
                     if kind=='html':page.set_content(code,wait_until='domcontentloaded')
-                    elif kind=='css':page.add_style_tag(content=code)
+                    elif kind=='css':inject_css(page,code)
                     else:
                         page.add_script_tag(content=code)
                         page.evaluate('() => setup()')
@@ -131,6 +146,7 @@ def browser(request):
                     actual=[observe(page,c) for c in scenario['checks']]
                 except Exception as e:error=type(e).__name__+': '+str(e)[:500]
                 observations.append({'actual':actual,'baseline':baseline,'error':error})
+                publish_state('candidate',observations[:-1],index,'page_close')
                 page.close()
                 publish_state('fixture_setup',observations,index)
         finally:
@@ -146,11 +162,18 @@ def main():
         for lang,(_,cmd,run) in COMMANDS.items():
             import shutil
             result[lang]=bool(shutil.which(cmd[0]) and (run[0].startswith('./') or shutil.which(run[0])))
-        from playwright.sync_api import sync_playwright
-        with sync_playwright() as p:
-            b=p.chromium.launch();b.close()
+        probe=browser({'kind':'css','code':'#probe { color: rgb(10, 20, 30); }',
+            'fixture':'<p id="probe">Probe</p><p id="other">Other</p>',
+            'base_css':'p { color: rgb(0, 0, 0); }','timeout_seconds':3,
+            'scenarios':[{'checks':[{'kind':'style','selector':'#probe','property':'color'},
+                                     {'kind':'unchanged','selector':'#other','property':'color'}]}]})
+        if not probe['syntax_success'] or len(probe['observations'])!=1:
+            raise RuntimeError('CSS preflight produced incomplete observations')
+        observed=probe['observations'][0]
+        if observed['error'] or observed['actual']!=['rgb(10, 20, 30)','rgb(0, 0, 0)']:
+            raise RuntimeError('CSS preflight failed computed-style checks: '+json.dumps(observed))
         result.update(html=True,css=True)
-        return {'runtimes':result}
+        return {'runtimes':result,'browser_preflight':'passed'}
     return browser(r) if r['kind'] in ('html','css','dom') else program(r)
 
 if __name__=='__main__':

tests/test_watchdog.py

@@ -62,6 +62,52 @@ while True: time.sleep(1)
             from unittest.mock import patch
             with patch.dict(os.environ,SMOLSCRIPT_TEST_SECRET='never-pass-to-worker'):
                 self.assertIsNone(watchdog.supervise(request,worker)['secret'])
+    def test_css_injection_is_synchronous_and_does_not_wait_for_load(self):
+        from unittest.mock import Mock
+        sys.path.insert(0,str(ROOT/'runners'))
+        spec=importlib.util.spec_from_file_location('worker_injection_test',ROOT/'sandbox/worker.py')
+        worker=importlib.util.module_from_spec(spec);spec.loader.exec_module(worker)
+        page=Mock()
+        worker.inject_css(page,'p { color: red; }')
+        page.add_style_tag.assert_not_called()
+        source,css=page.evaluate.call_args.args
+        self.assertEqual(css,'p { color: red; }')
+        self.assertIn('style.textContent=css',source)
+        self.assertNotIn('Promise',source);self.assertNotIn('onload',source)
+    def test_setup_timeout_identifies_exact_operation(self):
+        with tempfile.TemporaryDirectory() as d:
+            request,worker=self.fixture(d,'''import json,os,time
+from pathlib import Path
+Path(os.environ['SMOLSCRIPT_WORKER_STATE']).write_text(json.dumps({'phase':'fixture_setup','scenario':0,'operation':'base_css'}))
+time.sleep(60)
+''')
+            with self.assertRaisesRegex(RuntimeError,'operation=base_css'):
+                watchdog.supervise(request,worker,startup_seconds=.15,total_seconds=3)
+    def test_worker_has_writable_private_home_and_xdg_paths(self):
+        with tempfile.TemporaryDirectory() as d:
+            request,worker=self.fixture(d,'''import json,os
+from pathlib import Path
+for key in ('HOME','XDG_CACHE_HOME','XDG_CONFIG_HOME','TMPDIR'):
+    (Path(os.environ[key])/('probe-'+key)).write_text('ok')
+print(json.dumps({'home':os.environ['HOME']}))
+''')
+            self.assertEqual(watchdog.supervise(request,worker)['home'],str(Path(d).resolve()))
+
+    def test_readonly_request_is_separate_from_writable_workspace(self):
+        with tempfile.TemporaryDirectory() as d:
+            inputs=Path(d)/'input';inputs.mkdir()
+            work=Path(d)/'work';work.mkdir()
+            request,worker=self.fixture(inputs,'''import json,os
+from pathlib import Path
+Path('artifact').write_text('ok')
+print(json.dumps({'cwd':os.getcwd(),'home':os.environ['HOME']}))
+''')
+            request.chmod(0o444);inputs.chmod(0o555)
+            try:result=watchdog.supervise(request,worker,workspace=work)
+            finally:inputs.chmod(0o755)
+            self.assertEqual(result['cwd'],str(work.resolve()));self.assertEqual(result['home'],str(work.resolve()))
+            self.assertTrue((work/'artifact').exists());self.assertFalse((inputs/'artifact').exists())
+
     def test_missing_layout_target_does_not_wait_on_locator_evaluate(self):
         sys.path.insert(0,str(ROOT/'runners'))
         spec=importlib.util.spec_from_file_location('worker_layout_test',ROOT/'sandbox/worker.py')