修：draw-ui / oil-motion 原被当子模块指针收录 ⇒ 改为正常文件入库（两份内容原先对别人是空的）

一、问题（本轮实测）
`draw-ui` 与 `oil-motion` 目录里**各自带一个内嵌 `.git`** ⇒ 上一次提交把它们记成了 **gitlink（子模块指针）**
⇒ 仓库里只存了一个不属于任何远端的 commit id，**别人克隆下来这两份是空的** ✗（`git status` 显示 ` m draw-ui` / ` m oil-motion` ＝ 子模块内容有改动）。

二、处置（可回退）
· 把两处的 `.git` **挪走**（⛔ 不是删除）⇒ `归档/内嵌git-20261008/{draw-ui,oil-motion}.git`；
· `git rm --cached` 掉那两个 gitlink，再 `git add` 两个目录 ⇒ **按正常文件入库**（内容才真的进仓库）。

三、副作用（如实记）
挪走 `.git` 后，这两个技能**不能再原地 `git pull` 取上游更新**（要更新得重新拉一份覆盖）；
如需恢复其本地仓库，把 `归档/内嵌git-20261008/` 里的 `.git` 挪回原处即可。

draw-ui/tests/test_ask_draw.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+test_tmp="$(mktemp -d)"
+trap 'rm -rf "$test_tmp"' EXIT
+
+assert_codex_does_not_create_venv() {
+  local name="$1"
+  shift
+  local venv_path="$test_tmp/$name"
+  DRAW_VENV="$venv_path" bash "$repo_dir/scripts/ask_draw.sh" "$@" --help >/dev/null
+  [[ ! -e "$venv_path" ]] || {
+    printf 'Codex bootstrap unexpectedly created %s\n' "$venv_path" >&2
+    exit 1
+  }
+}
+
+assert_codex_does_not_create_venv separated --provider codex
+assert_codex_does_not_create_venv equals --provider=codex
+assert_codex_does_not_create_venv repeated --provider zenmux --provider=codex
+
+env_venv="$test_tmp/env-default"
+DRAW_PROVIDER=codex DRAW_VENV="$env_venv" bash "$repo_dir/scripts/ask_draw.sh" --help >/dev/null
+[[ ! -e "$env_venv" ]] || {
+  printf 'Codex environment default unexpectedly created %s\n' "$env_venv" >&2
+  exit 1
+}
+
+for bad_args in "--provider" "--provider=" "--provider unknown"; do
+  bad_venv="$test_tmp/bad-${bad_args//[^a-zA-Z0-9]/-}"
+  set +e
+  # shellcheck disable=SC2086
+  DRAW_VENV="$bad_venv" bash "$repo_dir/scripts/ask_draw.sh" $bad_args >/dev/null 2>&1
+  status=$?
+  set -e
+  [[ "$status" -eq 2 ]] || {
+    printf 'Expected exit 2 for %s, got %s\n' "$bad_args" "$status" >&2
+    exit 1
+  }
+  [[ ! -e "$bad_venv" ]] || {
+    printf 'Invalid provider unexpectedly created %s\n' "$bad_venv" >&2
+    exit 1
+  }
+done
+
+printf 'ask_draw.sh bootstrap tests passed\n'

draw-ui/tests/test_assemble_page.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from PIL import Image
+
+SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "assemble_page.py"
+
+
+class AssemblePageTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        Image.new("RGBA", (8, 5), (255, 0, 0, 255)).save(self.root / "a.png")
+        Image.new("RGBA", (8, 3), (0, 0, 255, 128)).save(self.root / "b.png")
+        self.data = {"expected_sections": ["a", "b"], "sections": [{"id": "a", "image": "a.png"}, {"id": "b", "image": "b.png"}]}
+        self.output = self.root / "page.png"
+
+    def run_cli(self, *extra):
+        manifest = self.root / "page.json"
+        manifest.write_text(json.dumps(self.data))
+        return subprocess.run([sys.executable, str(SCRIPT), "--manifest", str(manifest), "--output", str(self.output), *extra], capture_output=True, text=True, cwd=self.root.parent)
+
+    def test_cli_preserves_order_dimensions_pixels_and_relative_paths(self):
+        result = self.run_cli()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        with Image.open(self.output) as im:
+            self.assertEqual(im.size, (8, 8))
+            self.assertEqual(im.getpixel((0, 4)), (255, 0, 0, 255))
+            self.assertEqual(im.getpixel((0, 5)), (0, 0, 255, 128))
+
+    def test_rejects_wrong_width_without_writing_output(self):
+        Image.new("RGB", (7, 3)).save(self.root / "b.png")
+        self.assertNotEqual(self.run_cli().returncode, 0)
+        self.assertFalse(self.output.exists())
+
+    def test_rejects_missing_reordered_and_duplicate_sections(self):
+        for sections in ([self.data["sections"][0]], list(reversed(self.data["sections"])), [self.data["sections"][0]] * 2):
+            with self.subTest(sections=sections):
+                original = self.data["sections"]
+                self.data["sections"] = sections
+                self.assertNotEqual(self.run_cli().returncode, 0)
+                self.assertFalse(self.output.exists())
+                self.data["sections"] = original
+
+    def test_rejects_corrupt_source_and_preserves_existing_output(self):
+        self.output.write_bytes(b"existing")
+        self.assertNotEqual(self.run_cli().returncode, 0)
+        self.assertEqual(self.output.read_bytes(), b"existing")
+        (self.root / "b.png").write_bytes(b"broken")
+        self.assertNotEqual(self.run_cli("--force").returncode, 0)
+        self.assertEqual(self.output.read_bytes(), b"existing")
+
+    def test_force_replaces_output_after_validation(self):
+        self.output.write_bytes(b"existing")
+        self.assertEqual(self.run_cli("--force").returncode, 0)
+        with Image.open(self.output) as im:
+            self.assertEqual(im.size, (8, 8))
+
+    def test_rejects_duplicate_image_and_overwriting_source(self):
+        self.data["sections"][1]["image"] = "a.png"
+        self.assertNotEqual(self.run_cli().returncode, 0)
+        self.data["sections"][1]["image"] = "b.png"
+        self.output = self.root / "a.png"
+        before = self.output.read_bytes()
+        self.assertNotEqual(self.run_cli("--force").returncode, 0)
+        self.assertEqual(self.output.read_bytes(), before)
+
+
+if __name__ == "__main__":
+    unittest.main()

draw-ui/tests/test_asset_alpha.py

@@ -0,0 +1,42 @@
+"""从命令行入口验证透明素材检查，使用合成文件，不调用生图服务。"""
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from PIL import Image
+
+
+class AlphaCheckTest(unittest.TestCase):
+    def test_file_formats_and_alpha(self):
+        rgb = Image.new("RGB", (2, 2), "white")
+        rgb.putpixel((0, 0), (128, 128, 128))
+        rgba = Image.new("RGBA", (2, 2), (0, 0, 0, 255))
+        valid = rgba.copy()
+        valid.putpixel((0, 0), (0, 0, 0, 0))
+        partial = rgba.copy()
+        partial.putpixel((0, 0), (0, 0, 0, 128))
+        palette = Image.new("P", (2, 2), 1)
+        palette.putpalette([0, 0, 0, 255, 255, 255] + [0] * 762)
+        palette.putpixel((0, 0), 0)
+        palette.info["transparency"] = 0
+        cases = [("checker-rgb", rgb, False), ("opaque-rgba", rgba, False),
+                 ("transparent-rgba", valid, True), ("partial-alpha", partial, True),
+                 ("palette-transparency", palette, True),
+                 ("empty", Image.new("RGBA", (2, 2), (0, 0, 0, 0)), False)]
+        script = Path(__file__).resolve().parents[1] / "scripts/check_asset_alpha.py"
+        with tempfile.TemporaryDirectory() as directory:
+            for name, im, expected in cases:
+                with self.subTest(name=name):
+                    path = Path(directory) / (name + ".png")
+                    im.save(path)
+                    result = subprocess.run([sys.executable, str(script), str(path),
+                                             "--require-transparency"], capture_output=True, text=True)
+                    self.assertEqual(result.returncode, 0 if expected else 2, result.stderr)
+                    self.assertEqual(json.loads(result.stdout)["transparency_check_passed"], expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

draw-ui/tests/test_calibration.py

@@ -0,0 +1,87 @@
+"""从真实CLI入口验证尺寸与截图前提，不启动浏览器。"""
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from threading import Thread
+from PIL import Image
+
+SCRIPTS = Path(__file__).resolve().parents[1] / 'scripts'
+
+class CalibrationTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+        for name in ('reference', 'candidate'):
+            Image.new('RGB', (32, 64), 'white').save(self.root / (name+'.png'))
+    def tearDown(self):
+        self.temp.cleanup()
+    def compare(self, *extra):
+        return subprocess.run([sys.executable, str(SCRIPTS/'compare_mockup.py'), '--reference', str(self.root/'reference.png'), '--candidate', str(self.root/'candidate.png'), '--out-dir', str(self.root/'comparison'), *extra], capture_output=True, text=True)
+    def test_equal_and_invalid_clip(self):
+        self.assertEqual(self.compare().returncode, 0)
+        metrics=json.loads((self.root/'comparison/comparison-metrics.json').read_text())
+        self.assertFalse(metrics['resized'])
+        self.assertEqual(metrics['regions'][0]['mean_abs_diff'], 0)
+        for clip in ['bad:0,0,33,2', '../escape:0,0,1,1', 'full:0,0,1,1', 'bad:0,0,-1,1']:
+            with self.subTest(clip=clip):
+                self.assertNotEqual(self.compare('--clip', clip).returncode, 0)
+    def test_width_mismatch(self):
+        Image.new('RGB', (33,64), 'white').save(self.root/'candidate.png')
+        self.assertNotEqual(self.compare('--allow-height-difference').returncode, 0)
+        self.assertFalse((self.root/'comparison').exists())
+    def test_short_page_preserves_missing_tail(self):
+        Image.new('RGB', (32,50), 'white').save(self.root/'candidate.png')
+        self.assertNotEqual(self.compare().returncode, 0)
+        self.assertEqual(self.compare('--allow-height-difference','--clip','tail:0,50,32,14').returncode, 0)
+        metrics=json.loads((self.root/'comparison/comparison-metrics.json').read_text())
+        self.assertEqual(metrics['height_delta'], -14)
+        self.assertFalse(metrics['geometry_match'])
+        with Image.open(metrics['unmatched_tails']['reference']) as tail:
+            self.assertEqual(tail.size, (32,14))
+        self.assertIn('status',metrics['regions'][-1])
+    def test_capture_contract(self):
+        expected={'url':'http://127.0.0.1:4187/','title':'测试页','viewport':{'width':32,'height':64},'dpr':1,'full_page':False,'screenshot_scale':'css'}
+        capture={**expected,'fonts_ready':True,'images_ready':True,'document_height':64,'sections':[{'name':'hero','y':2}]}
+        asset={'src':'http://127.0.0.1:4187/logo-v2.png','natural_width':2048}
+        capture['assets']={'logo':asset}
+        manifest={'expected':expected,'capture_metadata':'capture.json','reference':'reference.png','candidate':'candidate.png','section_positions':{'hero':1},'expected_assets':{'logo':asset}}
+        (self.root/'run.json').write_text(json.dumps(manifest))
+        variants=[({},True),({'title':'其他项目'},False),({'url':'http://127.0.0.1:9999/'},False),({'fonts_ready':False},False),({'images_ready':False},False),({'dpr':2},False),({'viewport':{'width':31,'height':64}},False),({'screenshot_scale':'device'},False),({'assets':{}},False),({'assets':{'logo':{**asset,'src':'http://127.0.0.1:4187/old.png'}}},False),({'assets':{'logo':{**asset,'natural_width':100}}},False)]
+        for index,(changes,valid) in enumerate(variants):
+            with self.subTest(changes=changes):
+                (self.root/'capture.json').write_text(json.dumps({**capture,**changes}))
+                out=self.root/f'verify-{index}'
+                result=subprocess.run([sys.executable,str(SCRIPTS/'verify_capture.py'),'--manifest',str(self.root/'run.json'),'--out-dir',str(out)],capture_output=True,text=True)
+                self.assertEqual(result.returncode==0,valid,result.stderr)
+                if valid:
+                    self.assertEqual(json.loads((out/'verification.json').read_text())['section_positions'][0]['delta_y'],1)
+                else:
+                    self.assertFalse(out.exists())
+
+    def test_preflight_identity(self):
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write('<title>测试页</title>'.encode())
+            def log_message(self,*args):
+                pass
+        server=HTTPServer(('127.0.0.1',0),Handler)
+        thread=Thread(target=server.serve_forever,daemon=True)
+        thread.start()
+        try:
+            for title,valid in [('测试页',True),('其他项目',False)]:
+                (self.root/'run.json').write_text(json.dumps({'expected':{'url':f'http://127.0.0.1:{server.server_port}/','title':title}}))
+                result=subprocess.run([sys.executable,str(SCRIPTS/'verify_capture.py'),'--manifest',str(self.root/'run.json'),'--preflight'],capture_output=True,text=True)
+                self.assertEqual(result.returncode==0,valid,result.stderr)
+        finally:
+            server.shutdown()
+            server.server_close()
+            thread.join()
+
+if __name__=='__main__':
+    unittest.main()

draw-ui/tests/test_capture_pipeline.py

@@ -0,0 +1,119 @@
+"""通过真实 CLI 验证冻结基线与采集契约；捕获对象为明确的合成夹具。"""
+from concurrent.futures import ThreadPoolExecutor
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from PIL import Image
+SCRIPTS=Path(__file__).resolve().parents[1]/'scripts'
+
+class CapturePipelineTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp=tempfile.TemporaryDirectory(prefix='capture pipeline ')
+        self.root=Path(self.tmp.name)
+        Image.new('RGB',(32,64),'white').save(self.root/'reference.png')
+        self.expected={'url':'http://127.0.0.1:4187/','title':'合成夹具','viewport':{'width':32,'height':64},'dpr':1,'full_page':True,'screenshot_scale':'css'}
+        self.manifest={'reference':'reference.png','css_viewport_width':32,'expected':self.expected,'regions':[
+            {'name':'card','box':[0,2,10,10],'selector':'.card'},
+            {'name':'ink','box':[0,20,12,12],'box_type':'ink','selector':'h1'},
+            {'name':'paper','kind':'color','box':[20,0,10,10]}]}
+    def tearDown(self):self.tmp.cleanup()
+    def cli(self,name,*args):return subprocess.run([sys.executable,str(SCRIPTS/name),*map(str,args)],capture_output=True,text=True)
+    def write(self,path,data):path.write_text(json.dumps(data),encoding='utf-8')
+    def measure(self):
+        self.write(self.root/'regions.json',self.manifest)
+        result=self.cli('measure_reference.py','--manifest',self.root/'regions.json','--out-dir',self.root/'measured')
+        self.assertEqual(result.returncode,0,result.stderr)
+    def prepare(self,name='round-01'):
+        result=self.cli('prepare_capture.py','--measurements',self.root/'measured/measurements.json','--out-dir',self.root/name)
+        self.assertEqual(result.returncode,0,result.stderr)
+        return self.root/name
+    def capture(self,round_dir,shift=0):
+        plan=json.loads((round_dir/'capture-plan.json').read_text())
+        capture={**self.expected,'measurement_sha256':plan['measurement_sha256'],'document_height':64,'fonts_ready':True,'images_ready':True,'elements':[
+            {'name':'card','selector':'.card','count':1,'status':'measured','box':[shift,2,10,10]},
+            {'name':'ink','selector':'h1','count':1,'status':'measured','box':[0,20,32,20]}]}
+        self.write(round_dir/'capture.json',capture)
+        Image.new('RGB',(32,64),'white').save(round_dir/'candidate.png')
+        return capture
+    def verify(self,round_dir,previous=None,out='report'):
+        args=['--manifest',round_dir/'run.json','--out-dir',round_dir/out]
+        if previous:args+=['--previous',previous]
+        return self.cli('verify_capture.py',*args)
+    def test_full_pipeline_excludes_ink(self):
+        self.measure();r=self.prepare();self.capture(r)
+        result=self.verify(r);self.assertEqual(result.returncode,0,result.stderr)
+        data=json.loads((r/'report/verification.json').read_text())['geometry']
+        self.assertTrue(data['complete']);self.assertEqual(data['regions'][0]['delta_css'],[0,0,0,0])
+        self.assertEqual(data['regions'][1]['status'],'visual_only');self.assertNotIn('delta_css',data['regions'][1])
+        self.assertEqual(data['regions'][2]['status'],'reference_only')
+        self.assertTrue((r/'report/geometry.md').exists())
+    def test_prepare_requires_expected_and_mapping(self):
+        for i,change in enumerate([{'expected':None},{'css_viewport_width':16}]):
+            with self.subTest(change=change):
+                altered={**self.manifest,**change};self.write(self.root/'regions.json',altered)
+                m=self.root/f'm{i}';self.assertEqual(self.cli('measure_reference.py','--manifest',self.root/'regions.json','--out-dir',m).returncode,0)
+                out=self.root/f'r{i}';result=self.cli('prepare_capture.py','--measurements',m/'measurements.json','--out-dir',out)
+                self.assertEqual(result.returncode,2);self.assertFalse(out.exists())
+    def test_reference_mutation_rejected(self):
+        self.measure();Image.new('RGB',(32,64),'black').save(self.root/'reference.png')
+        result=self.cli('prepare_capture.py','--measurements',self.root/'measured/measurements.json','--out-dir',self.root/'r')
+        self.assertEqual(result.returncode,2);self.assertIn('参考图已改动',result.stderr)
+    def test_measurement_mutation_rejected(self):
+        self.measure();r=self.prepare();self.capture(r)
+        p=self.root/'measured/measurements.json';d=json.loads(p.read_text());d['regions'][0]['box'][0]=3;self.write(p,d)
+        result=self.verify(r);self.assertEqual(result.returncode,2);self.assertIn('基线已改动',result.stderr);self.assertFalse((r/'report').exists())
+    def test_old_collector_and_duplicate_rows_rejected(self):
+        self.measure();r=self.prepare();good=self.capture(r)
+        for i,c in enumerate([{**good,'measurement_sha256':'bad'},{**good,'elements':good['elements']+[good['elements'][0]]},{**good,'elements':good['elements'][1:]}]):
+            with self.subTest(index=i):
+                self.write(r/'capture.json',c);self.assertEqual(self.verify(r,out=f'bad-{i}').returncode,2);self.assertFalse((r/f'bad-{i}').exists())
+    def test_missing_hidden_and_ambiguous_are_not_success(self):
+        self.measure();r=self.prepare();good=self.capture(r)
+        for status in ['missing','hidden','ambiguous','unmeasurable','invalid_selector']:
+            with self.subTest(status=status):
+                rows=[{**good['elements'][0],'status':status,'count':2 if status=='ambiguous' else 0},good['elements'][1]]
+                self.write(r/'capture.json',{**good,'elements':rows})
+                result=self.verify(r,out=status);self.assertEqual(result.returncode,2)
+                geometry=json.loads((r/status/'verification.json').read_text())['geometry']
+                self.assertFalse(geometry['complete']);self.assertEqual(geometry['unavailable_regions'],['card'])
+                self.assertNotIn('delta_css',geometry['regions'][0])
+    def test_invalid_geometry_rejected(self):
+        self.measure();r=self.prepare();good=self.capture(r)
+        for i,row in enumerate([{**good['elements'][0],'count':2},{**good['elements'][0],'box':[0,0,-1,10]},{**good['elements'][0],'box':[float('nan'),0,10,10]}]):
+            self.write(r/'capture.json',{**good,'elements':[row,good['elements'][1]]})
+            self.assertEqual(self.verify(r,out=f'invalid-{i}').returncode,2)
+    def test_previous_reports_reduction_and_regression(self):
+        self.measure();r1=self.prepare();self.capture(r1,shift=3);self.assertEqual(self.verify(r1).returncode,0)
+        previous=r1/'report/verification.json'
+        for name,shift,change in [('better',1,'reduced'),('worse',6,'increased')]:
+            r=self.prepare(name);self.capture(r,shift=shift);result=self.verify(r,previous);self.assertEqual(result.returncode,0,result.stderr)
+            changes=json.loads((r/'report/verification.json').read_text())['geometry']['changes']
+            self.assertEqual(changes[0]['change'],change);self.assertEqual(changes[1]['change'],'unavailable')
+    def test_unrelated_previous_rejected(self):
+        self.measure();r=self.prepare();self.capture(r);self.assertEqual(self.verify(r).returncode,0)
+        p=r/'report/verification.json';d=json.loads(p.read_text());d['geometry']['measurement_sha256']='other';self.write(self.root/'unrelated.json',d)
+        result=self.verify(r,self.root/'unrelated.json',out='new');self.assertEqual(result.returncode,2);self.assertFalse((r/'new').exists())
+    def test_run_conditions_cannot_override_baseline(self):
+        self.measure();r=self.prepare();c=self.capture(r)
+        p=r/'run.json';d=json.loads(p.read_text());d['expected']['title']='后改标题';self.write(p,d)
+        c['title']='后改标题';self.write(r/'capture.json',c)
+        result=self.verify(r);self.assertEqual(result.returncode,2);self.assertIn('配置与测量基线',result.stderr)
+    def test_prepare_and_verify_refuse_overwrite(self):
+        self.measure();r=self.prepare();self.capture(r)
+        result=self.cli('prepare_capture.py','--measurements',self.root/'measured/measurements.json','--out-dir',r)
+        self.assertEqual(result.returncode,2)
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            codes=sorted(pool.map(lambda _:self.verify(r).returncode,range(2)))
+        self.assertEqual(codes,[0,2]);self.assertTrue((r/'report/verification.json').exists())
+    def test_device_pixel_mapping(self):
+        self.manifest['css_viewport_width']=16;self.manifest['expected']={**self.expected,'viewport':{'width':16,'height':32},'dpr':2,'screenshot_scale':'device'}
+        self.measure();r=self.prepare();c=self.capture(r)
+        c.update(self.manifest['expected']);c['document_height']=32;c['elements'][0]['box']=[0,1,5,5]
+        self.write(r/'capture.json',c)
+        result=self.verify(r);self.assertEqual(result.returncode,0,result.stderr)
+        geometry=json.loads((r/'report/verification.json').read_text())['geometry'];self.assertEqual(geometry['regions'][0]['delta_css'],[0,0,0,0])
+
+if __name__=='__main__':unittest.main()

draw-ui/tests/test_generate_image.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import base64
+import importlib.util
+import json
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+
+SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "generate_image.py"
+SPEC = importlib.util.spec_from_file_location("generate_image", SCRIPT_PATH)
+assert SPEC and SPEC.loader
+generate_image = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(generate_image)
+
+
+class FakeResponse:
+    def __init__(self, payload: dict):
+        self._body = json.dumps(payload).encode("utf-8")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, traceback):
+        return False
+
+    def read(self) -> bytes:
+        return self._body
+
+
+class GenerateImageTests(unittest.TestCase):
+    def test_provider_specific_model_resolution(self):
+        self.assertEqual(generate_image.resolve_codex_model("gpt-5.6-sol"), "gpt-5.6-sol")
+        self.assertEqual(generate_image.resolve_codex_model(), generate_image.DEFAULT_CODEX_MODEL)
+
+    def test_openai_base_url_is_explicit_and_normalized(self):
+        with mock.patch.dict(os.environ, {"OPENAI_IMAGE_BASE_URL": "https://example.com"}, clear=False):
+            self.assertEqual(generate_image.resolve_codex_base_url(), "https://example.com/v1")
+        with mock.patch.dict(
+            os.environ, {"OPENAI_IMAGE_BASE_URL": "https://example.com/custom/v1/"}, clear=False
+        ):
+            self.assertEqual(generate_image.resolve_codex_base_url(), "https://example.com/custom/v1")
+
+    def test_codex_request_uses_selected_model_and_forces_image_tool(self):
+        captured = {}
+        png = b"\x89PNG\r\n\x1a\nfixture"
+        response_payload = {
+            "output": [
+                {
+                    "type": "image_generation_call",
+                    "result": base64.b64encode(png).decode("ascii"),
+                }
+            ]
+        }
+
+        def fake_urlopen(request, timeout):
+            captured["request"] = request
+            captured["timeout"] = timeout
+            return FakeResponse(response_payload)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output = Path(temp_dir) / "result.png"
+            with (
+                mock.patch.dict(os.environ, {"OPENAI_IMAGE_API_KEY": "test-key"}, clear=False),
+                mock.patch.object(generate_image.urllib.request, "urlopen", side_effect=fake_urlopen),
+            ):
+                final_path = generate_image.request_codex_image(
+                    prompt="draw a test",
+                    refs=[],
+                    image_type="wide",
+                    model="gpt-5.6-sol",
+                    output_path=output,
+                )
+
+            request_payload = json.loads(captured["request"].data)
+            self.assertEqual(request_payload["model"], "gpt-5.6-sol")
+            self.assertEqual(request_payload["tool_choice"], "required")
+            self.assertIs(request_payload["store"], False)
+            self.assertEqual(request_payload["tools"][0]["size"], "1536x864")
+            self.assertEqual(final_path.read_bytes(), png)
+            self.assertEqual(captured["request"].headers["Authorization"], "Bearer test-key")
+
+    def test_main_rejects_existing_output_before_resolving_refs_or_calling_provider(self):
+        image_bytes = b"keep-image"
+        metadata_bytes = b"keep-metadata"
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output = Path(temp_dir) / "result.png"
+            metadata = generate_image.metadata_path_for(output)
+            output.write_bytes(image_bytes)
+            metadata.write_bytes(metadata_bytes)
+            argv = [
+                "generate_image.py",
+                "--provider",
+                "codex",
+                "--prompt",
+                "draw a test",
+                "--ref",
+                "https://example.test/reference.png",
+                "--output",
+                str(output),
+            ]
+            with (
+                mock.patch.object(sys, "argv", argv),
+                mock.patch.object(generate_image, "resolve_ref", side_effect=AssertionError("reference resolved")),
+                mock.patch.object(generate_image, "request_codex_image", side_effect=AssertionError("provider called")),
+            ):
+                with self.assertRaises(FileExistsError):
+                    generate_image.main()
+
+            self.assertEqual(output.read_bytes(), image_bytes)
+            self.assertEqual(metadata.read_bytes(), metadata_bytes)
+
+    def test_main_writes_new_image_and_metadata(self):
+        image_bytes = b"new-image"
+
+        def fake_request_codex_image(**kwargs):
+            output = kwargs["output_path"]
+            output.parent.mkdir(parents=True, exist_ok=True)
+            output.write_bytes(image_bytes)
+            return output
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output = Path(temp_dir) / "result.png"
+            argv = [
+                "generate_image.py",
+                "--provider",
+                "codex",
+                "--prompt",
+                "draw a test",
+                "--output",
+                str(output),
+            ]
+            with (
+                mock.patch.object(sys, "argv", argv),
+                mock.patch.object(generate_image, "request_codex_image", side_effect=fake_request_codex_image),
+            ):
+                self.assertEqual(generate_image.main(), 0)
+
+            self.assertEqual(output.read_bytes(), image_bytes)
+            metadata = generate_image.metadata_path_for(output)
+            self.assertTrue(metadata.exists())
+            self.assertEqual(json.loads(metadata.read_text(encoding="utf-8"))["output_path"], str(output.resolve()))
+
+    def test_render_response_rejects_existing_mime_inferred_suffix(self):
+        original = b"keep-jpeg"
+        generated = b"new-jpeg"
+        inline_data = mock.Mock(
+            data=base64.b64encode(generated).decode("ascii"),
+            mime_type="image/jpeg",
+        )
+        response = mock.Mock(parts=[mock.Mock(text=None, inline_data=inline_data)])
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            output_base = Path(temp_dir) / "result"
+            inferred_output = output_base.with_suffix(".jpg")
+            inferred_output.write_bytes(original)
+
+            with self.assertRaises(FileExistsError):
+                generate_image.render_response(response=response, output_path=output_base)
+
+            self.assertEqual(inferred_output.read_bytes(), original)
+
+
+if __name__ == "__main__":
+    unittest.main()

draw-ui/tests/test_measure_reference.py

@@ -0,0 +1,69 @@
+"""通过 CLI 验证测量边界；只使用临时合成图，不声称为真实页面效果评估。"""
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from PIL import Image
+SCRIPT=Path(__file__).resolve().parents[1]/'scripts'/'measure_reference.py'
+class MeasureReferenceTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp=tempfile.TemporaryDirectory(prefix='reference measurement ')
+        self.root=Path(self.tmp.name)
+        self.image=Image.new('RGBA',(40,40),(12,16,17,255))
+        self.image.save(self.root/'source.png')
+    def tearDown(self):self.tmp.cleanup()
+    def run_cli(self,data,out='result'):
+        p=self.root/'manifest.json';p.write_text(json.dumps({'reference':'source.png',**data}))
+        result=subprocess.run([sys.executable,str(SCRIPT),'--manifest',str(p),'--out-dir',str(self.root/out)],capture_output=True,text=True)
+        return result
+    def region(self,**kw):return {'name':'sample','kind':'color','box':[0,0,40,40],**kw}
+    def read(self,out='result'):return json.loads((self.root/out/'measurements.json').read_text())
+    def test_color_and_width_mapping(self):
+        r=self.run_cli({'css_viewport_width':20,'regions':[self.region()]})
+        self.assertEqual(r.returncode,0,r.stderr)
+        d=self.read();self.assertEqual(d['regions'][0]['color']['median_hex'],'#0C1011')
+        self.assertEqual(d['regions'][0]['css_box'],[0,0,20,20]);self.assertFalse(d['regions'][0]['dom_comparable'])
+    def test_transparent_pixels_excluded(self):
+        self.image.paste((255,0,0,0),(0,0,20,40));self.image.save(self.root/'source.png')
+        r=self.run_cli({'regions':[self.region()]});self.assertEqual(r.returncode,0,r.stderr)
+        c=self.read()['regions'][0]['color'];self.assertEqual(c['median_hex'],'#0C1011');self.assertEqual(c['excluded_nonopaque'],800)
+    def test_no_opaque_samples_rejected(self):
+        self.image.putalpha(0);self.image.save(self.root/'source.png')
+        r=self.run_cli({'regions':[self.region()]});self.assertEqual(r.returncode,2);self.assertFalse((self.root/'result').exists())
+    def test_boundary_and_invalid_types_rejected(self):
+        for box in [[-1,0,20,20],[0,0,41,40],[0,0,0,20],[0.5,0,20,20],[True,0,20,20]]:
+            with self.subTest(box=box):
+                r=self.run_cli({'regions':[self.region(box=box)]});self.assertEqual(r.returncode,2);self.assertFalse((self.root/'result').exists())
+    def test_inset(self):
+        r=self.run_cli({'regions':[self.region(inset=2)]});self.assertEqual(r.returncode,0)
+        self.assertEqual(self.read()['regions'][0]['color']['opaque_samples'],36*36)
+        r=self.run_cli({'regions':[self.region(inset=20)]},out='invalid');self.assertEqual(r.returncode,2)
+    def test_existing_output_refused(self):
+        data={'regions':[self.region()]};self.assertEqual(self.run_cli(data).returncode,0)
+        before=(self.root/'result/measurements.json').read_bytes()
+        self.assertEqual(self.run_cli(data).returncode,2);self.assertEqual(before,(self.root/'result/measurements.json').read_bytes())
+    def test_duplicate_names_refused(self):
+        self.assertEqual(self.run_cli({'regions':[self.region(),self.region()]}).returncode,2)
+    def test_grid_reports_unequal_widths(self):
+        regions=[{'name':'a','box':[0,2,10,10],'group':'cards'},{'name':'b','box':[13,2,15,10],'group':'cards'}]
+        self.assertEqual(self.run_cli({'regions':regions}).returncode,0)
+        g=self.read()['groups'][0];self.assertEqual(g['x_gaps'],[3]);self.assertEqual(g['width_spread'],5)
+    def test_ink_not_dom_comparable_or_grid(self):
+        region={'name':'title','box':[0,0,20,20],'box_type':'ink','selector':'h1'}
+        self.assertEqual(self.run_cli({'regions':[region]}).returncode,0)
+        self.assertFalse(self.read()['regions'][0]['dom_comparable'])
+        self.assertEqual(self.run_cli({'regions':[{**region,'group':'bad'}]},out='invalid').returncode,2)
+    def test_scan_includes_final_run(self):
+        self.image.paste((230,225,215,255),(0,30,40,40));self.image.save(self.root/'source.png')
+        scan={'name':'band','x':1,'y':0,'height':40,'min_channel':175,'max_channel_spread':45,'min_run':5}
+        self.assertEqual(self.run_cli({'vertical_scans':[scan]}).returncode,0)
+        self.assertEqual(self.read()['vertical_scans'][0]['runs'],[{'y_start':30,'y_end_exclusive':40,'height':10}])
+    def test_no_mapping_when_not_known(self):
+        self.assertEqual(self.run_cli({'regions':[self.region()]}).returncode,0)
+        self.assertNotIn('css_box',self.read()['regions'][0]);self.assertIsNone(self.read()['css_mapping']['css_per_image_pixel'])
+    def test_svg_escapes_labels(self):
+        self.assertEqual(self.run_cli({'regions':[self.region(name='<script>bad</script>')]}).returncode,0)
+        svg=(self.root/'result/annotations.svg').read_text();self.assertNotIn('<script>',svg);self.assertIn('&lt;script&gt;',svg)
+if __name__=='__main__':unittest.main()

draw-ui/tests/test_profile_business.py

@@ -0,0 +1,26 @@
+import importlib.util
+import importlib.machinery
+import os
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+from types import SimpleNamespace
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / 'scripts/generate_image.py'
+sys.path.insert(0, str(SCRIPT.parent))
+loader=importlib.machinery.SourceFileLoader('business_credentials_test',str(SCRIPT))
+spec=importlib.util.spec_from_loader(loader.name,loader)
+module=importlib.util.module_from_spec(spec)
+sys.modules[spec.name]=module
+with tempfile.TemporaryDirectory() as directory:
+    config=Path(directory)/'config.json'; config.write_text('{}')
+    with patch.dict(os.environ, {'OIL_COVER_CONFIG':str(config),'OIL_COVER_SKILL_DIR':str(ROOT)}):
+        loader.exec_module(module)
+class BusinessCredentialTests(unittest.TestCase):
+    def test_profile_environment_reaches_business_reader(self):
+        with patch.dict(os.environ, {'ZENMUX_API_KEY': 'TEST_KEY', 'OPENAI_API_KEY': 'TEST_OPENAI'}, clear=True), patch.object(Path,'read_text',side_effect=AssertionError('不应读取旧凭据文件')):
+            self.assertEqual(module.resolve_api_key(), 'TEST_KEY')
+            self.assertEqual(module.resolve_codex_api_key(), 'TEST_OPENAI')
+if __name__ == '__main__': unittest.main()