@givolt/i3-composer-agent 2.3.1 → 2.3.2

package/skills/i3-ui-prototype/scripts/native-build.cjs

@@ -0,0 +1,91 @@
+'use strict';
+const {spawnSync}=require('node:child_process');
+const http=require('node:http');
+const F=require('./native-files.cjs');
+const {fs,path,crypto,assert,hash,json,id,inside,walk,write,entries}=F;
+function verifyBuild(directory,buildId,{manifest}) {
+  id(buildId); const root=inside(directory,`builds/${buildId}`); const data=json(path.join(root,'manifest.json'));
+  assert.equal(data.buildId,buildId,'Build ID mismatch');
+  for(const step of ['typecheck','test','build'])assert.ok(Object.hasOwn(data.checks||{},step)&&typeof data.checks[step]==='string',`Required build check missing: ${step}`);
+  assert.deepEqual(entries(path.join(root,'site'),walk(path.join(root,'site'))),data.files,'Build bytes changed');
+  assert.equal(hash(JSON.stringify(data.files)),data.buildDigest,'Build digest mismatch');
+  assert.equal(data.candidateDigest,manifest(directory).digest,'Build is for an old candidate / 旧构建');
+  const scripts=Object.keys(data.files).filter(file=>/\.[cm]?js$/.test(file));
+  assert.ok(data.files['index.html'] && data.files['prototype-config.json'] && scripts.length,'Native build entry, config and JavaScript required');
+  assert.ok(scripts.some(file=>fs.readFileSync(inside(path.join(root,'site'),file),'utf8').includes(data.candidateDigest)),'Built JavaScript must embed its candidate identity / 构建标识');
+  return {...data,directory:root};
+}
+
+function verifyBrowserReport(directory,report,build) {
+  const start=Date.parse(report.startedAt),end=Date.parse(report.completedAt);
+  assert.ok(Number.isFinite(start)&&Number.isFinite(end)&&end>=start,'Browser run timestamps must be valid and ordered');
+  const base=new URL(report.previewBaseURL);
+  assert.ok(['http:','https:'].includes(base.protocol)&&!base.username&&!base.password&&!base.search&&!base.hash&&base.pathname.endsWith('/'),'Invalid preview base URL');
+  assert.ok(Array.isArray(report.observedResources)&&report.observedResources.length,'Observed browser resources required');
+  const observations=new Map();
+  for(const resource of report.observedResources) {
+    assert.ok(Object.hasOwn(build.files,resource.path),`Observed resource is outside the fixed build: ${resource.path}`);
+    const actual=new URL(resource.url),expected=new URL(resource.path==='index.html'?'':resource.path,base);
+    const entryAlias=resource.path==='index.html'&&actual.pathname===new URL('index.html',base).pathname;
+    assert.ok(actual.origin===base.origin&&(actual.pathname===expected.pathname||entryAlias)&&!actual.username&&!actual.password,`Observed resource has a different preview URL: ${resource.path}`);
+    assert.equal(resource.status,200,`Observed resource did not return 200: ${resource.path}`);
+    assert.equal(resource.sha256,build.files[resource.path],`Observed resource bytes differ: ${resource.path}`);
+    assert.ok(typeof resource.resourceType==='string'&&resource.resourceType,'Observed resource type required');
+    const type=resource.path==='index.html'?'document':/\.[cm]?js$/.test(resource.path)?'script':resource.path.endsWith('.css')?'stylesheet':resource.path==='prototype-config.json'?'fetch':null;
+    if(type)assert.equal(resource.resourceType,type,`Observed resource request type differs: ${resource.path}`);
+    observations.set(resource.path,resource);
+  }
+  const required=Object.keys(build.files).filter(file=>['index.html','prototype-config.json'].includes(file)||/\.(?:[cm]?js|css)$/.test(file));
+  for(const file of required)assert.ok(observations.has(file),`Browser did not observe required build resource: ${file}`);
+  assert.ok(Array.isArray(report.screenshots)&&report.screenshots.length>=2&&Array.isArray(report.viewports)&&report.viewports.length>=2,'Responsive screenshots required');
+  const png=Buffer.from([0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a]);
+  for(const file of report.screenshots) {
+    const bytes=fs.readFileSync(inside(directory,file));
+    assert.ok(bytes.length>24&&bytes.subarray(0,8).equals(png),`Screenshot must be PNG: ${file}`);
+  }
+  const trace=fs.readFileSync(inside(directory,report.trace));
+  assert.ok(trace.length>=22&&trace[0]===0x50&&trace[1]===0x4b&&[[3,4],[5,6],[7,8]].some(pair=>trace[2]===pair[0]&&trace[3]===pair[1]),'Browser trace must be a ZIP artifact');
+}
+function build(directory,options,{manifest,inspect}) {
+  const checked=inspect(directory); assert.equal(checked.status,'passed',checked.errors?.join('; '));
+  const before=manifest(directory); const app=inside(directory,'app');
+  function run(args,env={}) {
+    const result=spawnSync(process.platform==='win32'?'npm.cmd':'npm',args,{cwd:app,env:{...process.env,...env},encoding:'utf8',timeout:180000,maxBuffer:5*1024*1024});
+    assert.equal(result.status,0,`npm ${args.join(' ')} failed: ${result.error?.message||result.stderr||result.stdout}`);
+    return result.stdout;
+  }
+  if(options.install) run(['ci','--ignore-scripts','--no-audit','--no-fund']);
+  assert.ok(fs.existsSync(path.join(app,'node_modules','vite')),'Local dependencies missing; explicitly build --install');
+  const typecheck=run(['run','typecheck']);
+  const test=run(['test']);
+  fs.mkdirSync(inside(directory,'builds'),{recursive:true}); const stage=fs.mkdtempSync(path.join(directory,'builds','.build-'));
+  try {
+    const output=run(['run','build','--','--outDir',path.join(stage,'site'),'--emptyOutDir'],{VITE_CANDIDATE_ID:before.digest});
+    assert.equal(manifest(directory).digest,before.digest,'Source changed during build');
+    const files=entries(path.join(stage,'site'),walk(path.join(stage,'site'))); const buildDigest=hash(JSON.stringify(files)); const buildId=`b-${buildDigest.slice(0,20)}`;
+    const data={schemaVersion:1,buildId,buildDigest,candidateDigest:before.digest,inputDigest:before.inputDigest,revision:before.revision,files,toolchain:{node:process.version},checks:{typecheck,test,build:output}};
+    write(stage,'manifest.json',data);
+    const destination=inside(directory,`builds/${buildId}`);
+    if(fs.existsSync(destination)) verifyBuild(directory,buildId,{manifest}); else fs.renameSync(stage,destination);
+    write(directory,'last-build.json',{buildId,buildDigest,candidateDigest:before.digest});
+    return {status:'built',...data,directory:destination};
+  } finally { if(fs.existsSync(stage)) fs.rmSync(stage,{recursive:true,force:true}); }
+}
+async function preview(directory,options,{manifest}) {
+  const buildId=options.buildId||json(inside(directory,'last-build.json')).buildId;
+  const checked=verifyBuild(directory,buildId,{manifest}); const site=path.join(checked.directory,'site');
+  const mime={'.html':'text/html; charset=utf-8','.js':'text/javascript; charset=utf-8','.css':'text/css; charset=utf-8','.json':'application/json','.svg':'image/svg+xml','.png':'image/png','.woff2':'font/woff2'};
+  const server=http.createServer((req,res)=>{
+    try {
+      const pathname=decodeURIComponent(new URL(req.url,'http://127.0.0.1').pathname);
+      res.setHeader('Cache-Control','no-store');
+      if(pathname==='/__prototype-build.json') { const current=verifyBuild(directory,buildId,{manifest}); res.setHeader('Content-Type','application/json'); res.end(JSON.stringify({buildId,currentCandidate:current.candidateDigest,buildDigest:current.buildDigest,files:current.files})); return; }
+      const relative=pathname==='/'?'index.html':pathname.replace(/^\//,''); const file=inside(site,relative);
+      if(!fs.existsSync(file)||!fs.statSync(file).isFile()) { res.writeHead(404); res.end('Not found'); return; }
+      res.setHeader('Content-Type',mime[path.extname(file)]||'application/octet-stream'); res.end(fs.readFileSync(file));
+    } catch(error) { res.writeHead(409); res.end(error.message); }
+  });
+  await new Promise((resolve,reject)=>{server.once('error',reject);server.listen(options.port||0,'127.0.0.1',resolve);});
+  return {server,url:`http://127.0.0.1:${server.address().port}/`,build:checked};
+}
+module.exports={build,verifyBuild,preview,verifyBrowserReport};

package/skills/i3-ui-prototype/scripts/native-delivery.cjs

@@ -0,0 +1,91 @@
+'use strict';
+const F=require('./native-files.cjs');
+const {fs,path,crypto,assert,json,inside,write}=F;
+const read=(root,file)=>fs.existsSync(inside(root,file))?json(inside(root,file)):null;
+const quote=value=>`'${String(value).replace(/'/g,"'\\''")}'`;
+
+function state(directory,options,lib) {
+  directory=path.resolve(directory);
+  const current=lib.manifest(directory),meta=json(inside(directory,'prototype.json'));
+  const review=lib.effectiveReview(meta,current);
+  const structure=lib.inspect(directory),advice=read(directory,'qa/design-advice.json'),decisions=read(directory,'design-system/decisions.json');
+  let design;
+  try { const reviewed=lib.inspectDesignReview(directory,current); design={status:reviewed.status,queries:reviewed.queries,records:reviewed.records,adopted:reviewed.adoptedAdvice.length}; }
+  catch(error) { design={status:advice?.status==='pending'||decisions?.reviewStatus==='pending'?'pending':'failed',queries:advice?.queries?.length||0,records:advice?.records?.length||0,errors:[error.message]}; }
+  let build={status:'not-run'};
+  const pointer=read(directory,'last-build.json');
+  if(pointer) {
+    try { const checked=lib.verifyBuild(directory,pointer.buildId); build={status:'current',buildId:checked.buildId,buildDigest:checked.buildDigest,checks:Object.keys(checked.checks)}; }
+    catch(error) { build={status:pointer.candidateDigest!==current.digest?'stale':'failed',buildId:pointer.buildId,errors:[error.message]}; }
+  }
+  let browser={status:'not-run'};
+  const latest=read(directory,'qa/latest.json');
+  if(latest) {
+    try {
+      const report=json(inside(directory,latest.report)),checked=lib.inspect(directory,{acceptance:true});
+      browser={status:report.candidateDigest!==current.digest||report.revision!==current.revision?'stale':checked.status==='passed'?'current':'failed',report:latest.report,reportDigest:F.hash(fs.readFileSync(inside(directory,latest.report))),runId:report.id,executor:report.executor,...(checked.errors?{errors:checked.errors}:{})};
+    } catch(error) { browser={status:'failed',errors:[error.message]}; }
+  }
+  const devtoolsReview=require('./native-devtools.cjs').check(directory,lib);
+  const ownership=read(directory,'.prototype-write.lock');
+  const savedDelivery=read(directory,'qa/delivery.json');
+  const deliveryCurrent=savedDelivery?.schemaVersion===1&&savedDelivery.status==='complete'&&savedDelivery.id===meta.id&&savedDelivery.revision===current.revision&&savedDelivery.candidateDigest===current.digest&&savedDelivery.inputDigest===current.inputDigest&&savedDelivery.buildId===build.buildId&&savedDelivery.buildDigest===build.buildDigest&&savedDelivery.report===browser.report&&savedDelivery.review===review.status&&savedDelivery.humanConfirmationRequired===(review.status!=='approved')&&browser.status==='current'&&((!devtoolsReview.required&&savedDelivery.browserReportDigest===undefined)||savedDelivery.browserReportDigest===browser.reportDigest)&&(!devtoolsReview.required||(devtoolsReview.status==='current'&&savedDelivery.devtoolsReviewDigest===devtoolsReview.reportDigest));
+  const delivery=savedDelivery?{status:deliveryCurrent?'current':'stale',path:'qa/delivery.json',revision:savedDelivery.revision,...(deliveryCurrent?{result:savedDelivery}:{})}:null;
+  let runtime;
+  try { const provider=require('./native-browser.cjs').resolvePlaywright(directory,options); runtime={availability:'available',...provider,launchVerified:false}; }
+  catch(error) { runtime={availability:'missing',reason:error.message}; }
+  const cli=path.join(__dirname,'native-pilot.cjs');
+  const command=(operation,args=[])=>{const argv=[process.execPath,cli,operation,directory,...args];return {argv,shell:argv.map(quote).join(' ')};};
+  let nextRevision=/^r(\d+)$/.test(current.revision)?`r${String(Number(current.revision.slice(1))+1).padStart(3,'0')}`:`${current.revision}-next`;
+  while(fs.existsSync(inside(directory,`baselines/${nextRevision}`))) nextRevision+='-next';
+  const expected=['--expected-revision',current.revision,'--expected-digest',current.digest];
+  const browserArgs=[];
+  const browserProvider=options.playwrightModule||process.env.PLAYWRIGHT_MODULE||(runtime.availability==='available'?runtime.packageRoot:null);
+  if(browserProvider) browserArgs.push('--playwright-module',browserProvider);
+  if(options.browserChannel) browserArgs.push('--browser-channel',options.browserChannel);
+  if(options.expectedCategories) browserArgs.push('--expected-categories',typeof options.expectedCategories==='string'?options.expectedCategories:JSON.stringify(options.expectedCategories));
+  if(options.expectedDescription) browserArgs.push('--expected-description',options.expectedDescription);
+  if(options.verifyBlurValidation===true) browserArgs.push('--verify-blur-validation');
+  if(options.verifyAtomicStatus===true) browserArgs.push('--verify-atomic-status');
+  const commands={state:command('state'),revise:command('revise',['--revision',nextRevision,...expected]),build:command('build',fs.existsSync(inside(directory,'app/node_modules/vite'))?[]:['--install']),browser:command('browser',browserArgs),finalize:command('finalize',expected)};
+  if(meta.runtime.contentReference) {
+    delete commands.browser;
+    commands.recordRun=command('record-run',['--report',path.join(directory,'qa/business-browser-input.json')]);
+  }
+  if(build.status==='current')commands.preview=command('preview',['--build-id',build.buildId]);
+  if(devtoolsReview.required)commands.recordDevtoolsReview=command('record-devtools-review',['--report',path.join(directory,'qa/devtools-review-input.json')]);
+  const nextAction=ownership?'wait-for-owner':structure.status!=='passed'?'repair-structure':meta.runtime.contentReference&&meta.business?.status!=='adapted'?'implement-business':!['reviewed','no-match','skipped'].includes(design.status)?'review-design':build.status!=='current'?'build':browser.status!=='current'?(meta.runtime.contentReference?'business-browser-review':'browser'):devtoolsReview.required&&devtoolsReview.status!=='current'?'devtools-review':deliveryCurrent?'return-result':'finalize';
+  return {status:structure.status==='passed'?'ready':'failed',operation:'state',readOnly:true,directory,id:meta.id,revision:current.revision,candidateDigest:current.digest,inputDigest:current.inputDigest,identity:current.identity,instanceId:meta.instanceId,scopes:json(inside(directory,'inputs/scope.json')),structure,design,build,browser,devtoolsReview,delivery,browserRuntime:runtime,ownership,verification:meta.verification,review,nextAction,commands,notes:['Design decisions and real provider queries remain the executing role responsibility.','Use the printed commands; no source-code inspection is required to recover flags or digests.','A missing browser provider requires an existing Playwright module path; no automatic install or global changes.','A current DevTools review checks evidence files and identity; actual browser Skill/MCP invocation still requires independent raw host transcript verification.']};
+}
+
+function finalize(directory,options,lib) {
+  directory=path.resolve(directory);
+  const before=lib.manifest(directory),checked=lib.inspect(directory,{acceptance:true});
+  assert.equal(checked.status,'passed',`Current acceptance required / 当前实际验收未通过: ${checked.errors?.join('; ')}`);
+  const devtools=require('./native-devtools.cjs');
+  const requiredReview=devtools.check(directory,lib);assert.ok(!requiredReview.required||requiredReview.status==='current',`Current DevTools review required: ${requiredReview.errors?.join('; ')||requiredReview.status}`);
+  const owner=`finalize-${crypto.randomUUID()}`;
+  lib.claim(directory,{owner,expectedRevision:options.expectedRevision||before.revision,expectedDigest:options.expectedDigest||before.digest});
+  try {
+    const again=lib.inspect(directory,{acceptance:true});assert.equal(again.status,'passed',again.errors?.join('; '));
+    const devtoolsReview=devtools.check(directory,lib);assert.ok(!devtoolsReview.required||devtoolsReview.status==='current','Current DevTools review required');
+    assert.equal(lib.manifest(directory).digest,before.digest,'Candidate changed before final handoff');
+    const meta=json(inside(directory,'prototype.json')),scope=json(inside(directory,'inputs/scope.json'));
+    const review=lib.effectiveReview(meta,before);
+    const latest=json(inside(directory,'qa/latest.json')),report=json(inside(directory,latest.report));
+    const delivery={schemaVersion:1,status:'complete',operation:'finalize',id:meta.id,revision:before.revision,candidateDigest:before.digest,inputDigest:before.inputDigest,framework:meta.framework,template:meta.template,expertMode:meta.expertMode,expert:meta.expert.status,verification:'passed',review:review.status,checks:{structure:'passed',acceptance:'passed',build:'current',browser:'current'},buildId:report.buildId,buildDigest:report.buildDigest,report:latest.report,executor:report.executor,tool:report.tool,handoff:path.join(directory,'HANDOFF.md'),receipt:'qa/delivery.json',openQuestions:scope.openQuestions||[],humanConfirmationRequired:review.status!=='approved'};
+    delivery.browserReportDigest=F.hash(fs.readFileSync(inside(directory,latest.report)));
+    if(devtoolsReview.required){delivery.devtoolsReview=devtoolsReview.report;delivery.devtoolsReviewDigest=devtoolsReview.reportDigest;delivery.checks.devtoolsReview='current';delivery.invocationEvidence='Verify actual Skill/MCP calls independently in the host transcript';}
+    const start='<!-- native-delivery:start -->',end='<!-- native-delivery:end -->';
+    const block=[start,'## 当前真实交付状态',`- 原型：${delivery.id} / ${delivery.revision}`,`- candidateDigest：${delivery.candidateDigest}`,`- inputDigest：${delivery.inputDigest}`,`- 构建：${delivery.buildId} / ${delivery.buildDigest}`,`- 浏览器：${latest.report}；实际执行者 ${report.executor}；${report.tool}`,`- 专业模式：${delivery.expertMode} / ${delivery.expert}`,`- verification：passed；review：${delivery.review}。本工具不确认或冻结基线。`,`- 待确认问题：${delivery.openQuestions.length?JSON.stringify(delivery.openQuestions):'无新增；仍需用户评审。'}`,end].join('\n');
+    const file=inside(directory,'HANDOFF.md'),previous=fs.existsSync(file)?fs.readFileSync(file,'utf8'):'';
+    const begin=previous.indexOf(start),finish=previous.indexOf(end);
+    assert.ok((begin===-1&&finish===-1)||(begin>=0&&finish>begin&&previous.indexOf(start,begin+1)===-1&&previous.indexOf(end,finish+1)===-1),'Ambiguous generated handoff markers; preserve the user file');
+    const updated=begin===-1?`${previous.trimEnd()}\n\n${block}\n`:`${previous.slice(0,begin)}${block}${previous.slice(finish+end.length)}`;
+    assert.equal(lib.manifest(directory).digest,before.digest,'Candidate changed while finalizing');
+    if(updated!==previous) write(directory,'HANDOFF.md',updated);
+    write(directory,'qa/delivery.json',delivery);
+    return delivery;
+  } finally { lib.release(directory,owner); }
+}
+module.exports={state,finalize};

package/skills/i3-ui-prototype/scripts/native-devtools.cjs

@@ -0,0 +1,91 @@
+'use strict';
+// Checks evidence completeness and current identity, not the truth of a model's
+// claims. Actual Skill/MCP invocation must be checked against the host transcript.
+const F=require('./native-files.cjs');
+const {fs,path,assert,hash,json,inside,write,crypto}=F;
+const zlib=require('node:zlib');
+const KINDS=['dom','screenshot','console','network','accessibility','performance'];
+const METHODS=['evaluate_script','take_screenshot','list_console_messages','list_network_requests','take_snapshot','performance_start_trace','performance_stop_trace'];
+const limitations='Evidence structure, file bytes and current identity checked; verify actual Skill/MCP calls and findings independently in the raw host transcript.';
+function policy(){return {schemaVersion:1,required:true,skill:'i3-browser-testing-with-devtools',provider:'chrome-devtools-mcp',observations:[...KINDS]};}
+function readPolicy(directory){
+ const configured=json(inside(directory,'inputs/acceptance.json')).browserReview;
+ const frameworkFile=inside(directory,'inputs/framework.json');
+ if(fs.existsSync(frameworkFile)){const fixed=json(frameworkFile).acceptance?.browserReview;if(fixed!==undefined)assert.deepEqual(configured,fixed,'DevTools browser review policy differs from its fixed framework input');}
+ if(configured===undefined)return null;
+ assert.equal(configured.schemaVersion,1,'Unknown DevTools review policy');assert.equal(configured.required,true,'DevTools review policy cannot silently opt out');
+ assert.deepEqual(configured.observations,KINDS,'Required DevTools observations changed');assert.equal(configured.skill,policy().skill);assert.equal(configured.provider,'chrome-devtools-mcp');return configured;
+}
+const text=(value,label)=>assert.ok(typeof value==='string'&&value.trim(),`${label} required`);
+const crcTable=Array.from({length:256},(_,value)=>{for(let bit=0;bit<8;bit++)value=(value>>>1)^((value&1)?0xedb88320:0);return value>>>0;});
+function crc32(bytes){let crc=0xffffffff;for(const byte of bytes)crc=(crc>>>8)^crcTable[(crc^byte)&255];return (crc^0xffffffff)>>>0;}
+function verifyPng(bytes){
+ assert.ok(bytes.length>=57&&bytes.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])),'Complete PNG screenshot required');
+ let offset=8,header=null,ended=false;const image=[];
+ while(offset<bytes.length){
+  assert.ok(offset+12<=bytes.length,'Truncated PNG chunk');const size=bytes.readUInt32BE(offset),end=offset+size+12;assert.ok(end<=bytes.length,'Truncated PNG data');
+  const kind=bytes.toString('ascii',offset+4,offset+8),data=bytes.subarray(offset+8,offset+8+size);assert.equal(crc32(bytes.subarray(offset+4,offset+8+size)),bytes.readUInt32BE(offset+8+size),'Invalid PNG chunk CRC');
+  if(!header){assert.equal(kind,'IHDR','PNG header must be first');assert.equal(size,13,'Invalid PNG IHDR');header=data;}
+  else assert.notEqual(kind,'IHDR','Duplicate PNG header');
+  if(kind==='IDAT')image.push(data);
+  if(kind==='IEND'){assert.equal(size,0,'Invalid PNG end');assert.equal(end,bytes.length,'Trailing PNG bytes');ended=true;break;}offset=end;
+ }
+ assert.ok(ended&&image.length,'PNG needs image data and IEND');
+ const width=header.readUInt32BE(0),height=header.readUInt32BE(4),depth=header[8],channels={0:1,2:3,3:1,4:2,6:4}[header[9]];
+ assert.ok(width&&height&&channels&&[1,2,4,8,16].includes(depth),'Invalid PNG dimensions or color format');assert.equal(header[10],0,'Unsupported PNG compression');assert.equal(header[11],0,'Unsupported PNG filter method');assert.equal(header[12],0,'Expected noninterlaced Chrome screenshot PNG');
+ const stride=Math.ceil(width*channels*depth/8)+1,expected=stride*height;assert.ok(Number.isSafeInteger(expected)&&expected<=64*1024*1024,'PNG decoded image is too large');
+ let pixels;try{pixels=zlib.inflateSync(Buffer.concat(image),{maxOutputLength:64*1024*1024});}catch{throw new Error('Invalid PNG compressed image data');}
+ assert.equal(pixels.length,expected,'Incomplete PNG pixels');for(let row=0;row<height;row++)assert.ok(pixels[row*stride]<=4,'Invalid PNG scanline filter');
+}
+function validate(directory,report,current,build,configured){
+ assert.equal(report.schemaVersion,1);assert.equal(report.status,'passed','DevTools review has not passed');
+ assert.equal(report.revision,current.revision,'DevTools review revision is stale');assert.equal(report.candidateDigest,current.digest,'DevTools review candidate is stale');
+ assert.equal(report.buildId,build.buildId,'DevTools review build is stale');assert.equal(report.buildDigest,build.buildDigest,'DevTools review build bytes differ');
+ text(report.executor,'DevTools executor');const start=Date.parse(report.startedAt),end=Date.parse(report.completedAt);assert.ok(Number.isFinite(start)&&Number.isFinite(end)&&end>=start,'DevTools review timestamps required');
+ const url=new URL(report.previewBaseURL);assert.ok(url.protocol==='http:'&&['127.0.0.1','localhost','[::1]'].includes(url.hostname)&&!url.username&&!url.password,'DevTools preview must be the known local build');
+ assert.equal(report.skill?.name,configured.skill,'Required browser Skill missing');text(report.skill.toolCallId,'Skill tool call ID');text(report.skill.evidence,'Skill host transcript locator');
+ assert.equal(report.mcp?.name,'chrome-devtools-mcp');text(report.mcp.version,'MCP version');text(report.mcp.evidence,'MCP host transcript locator');
+ assert.ok(Array.isArray(report.mcp.calls)&&report.mcp.calls.length,'Actual MCP call locators required');
+ for(const call of report.mcp.calls){assert.ok(typeof call.tool==='string'&&call.tool.startsWith('mcp__'),'Native MCP tool name required');text(call.toolCallId,'MCP tool call ID');}
+ assert.equal(new Set(report.mcp.calls.map(call=>call.toolCallId)).size,report.mcp.calls.length,'Duplicate MCP call IDs');
+ for(const method of METHODS)assert.ok(report.mcp.calls.some(call=>call.tool.endsWith(`__${method}`)),`Missing DevTools method: ${method}`);
+ assert.ok(Array.isArray(report.openItems),'DevTools openItems required');assert.ok(!report.openItems.some(item=>item?.blocking===true),'Blocking DevTools findings remain');
+ const evidenceDigests={},seen=new Set();
+ for(const kind of KINDS){
+  const observed=report.observations?.[kind];assert.equal(observed?.status,'passed',`Missing passed DevTools observation: ${kind}`);text(observed.summary,`${kind} finding`);
+  assert.ok(typeof observed.evidence==='string'&&observed.evidence.startsWith('qa/')&&!seen.has(observed.evidence),'Each DevTools observation needs a distinct QA evidence path');seen.add(observed.evidence);
+  const file=inside(directory,observed.evidence);assert.ok(fs.statSync(file).isFile(),`${kind} evidence is not a file`);const bytes=fs.readFileSync(file);assert.ok(bytes.length&&bytes.length<=64*1024*1024,`${kind} evidence is empty or too large`);
+  if(kind==='screenshot')verifyPng(bytes);
+  if(kind==='performance'){
+   assert.ok(!bytes.subarray(0,2).equals(Buffer.from('PK')),'Playwright ZIP is not a DevTools trace');
+   let trace;try{const decoded=bytes[0]===31&&bytes[1]===139?zlib.gunzipSync(bytes,{maxOutputLength:64*1024*1024}):bytes;trace=JSON.parse(decoded.toString('utf8'));}catch{throw new Error('Parseable DevTools trace JSON required');}
+   const events=Array.isArray(trace)?trace:trace?.traceEvents;assert.ok(Array.isArray(events)&&events.length&&events.some(event=>typeof event.name==='string'),'Nonempty DevTools trace events required');
+  }
+  evidenceDigests[observed.evidence]=hash(bytes);
+ }
+ if(report.evidenceDigests)assert.deepEqual(report.evidenceDigests,evidenceDigests,'DevTools evidence bytes changed');
+ return evidenceDigests;
+}
+function check(directory,lib){
+ try{
+  const configured=readPolicy(directory);if(!configured)return {status:'not-required',required:false};
+  const file=inside(directory,'qa/devtools-review.json');if(!fs.existsSync(file))return {status:'not-run',required:true,missing:[...KINDS],limitations};
+  const report=json(file),current=lib.manifest(directory),build=lib.verifyBuild(directory,report.buildId);
+  const latestFile=inside(directory,'last-build.json');if(fs.existsSync(latestFile))assert.equal(json(latestFile).buildId,report.buildId,'DevTools review is not for the latest build');
+  const browserFile=inside(directory,'qa/latest.json');if(fs.existsSync(browserFile)){const supplemental=json(inside(directory,json(browserFile).report));assert.equal(supplemental.buildId,report.buildId,'DevTools review and browser regression build differ');assert.equal(supplemental.buildDigest,report.buildDigest,'DevTools review and browser regression bytes differ');}
+  const evidenceDigests=validate(directory,report,current,build,configured);assert.ok(report.evidenceDigests,'Recorded DevTools evidence hashes required');
+  return {status:'current',required:true,report:'qa/devtools-review.json',reportDigest:hash(fs.readFileSync(file)),revision:report.revision,candidateDigest:report.candidateDigest,buildId:report.buildId,buildDigest:report.buildDigest,evidenceDigests,invocationVerified:false,limitations};
+ }catch(error){return {status:'failed',required:true,errors:[error.message],limitations};}
+}
+function record(directory,report,lib){
+ const configured=readPolicy(directory);assert.ok(configured,'This fixed input has no DevTools review policy; use its original contract');
+ const current=lib.manifest(directory),build=lib.verifyBuild(directory,report.buildId),copy=JSON.parse(JSON.stringify(report));
+ const latestFile=inside(directory,'last-build.json');if(fs.existsSync(latestFile))assert.equal(json(latestFile).buildId,report.buildId,'DevTools review is not for the latest build');
+ copy.evidenceDigests=validate(directory,copy,current,build,configured);
+ const owner=`devtools-${crypto.randomUUID()}`;lib.claim(directory,{owner,expectedRevision:current.revision,expectedDigest:current.digest});
+ try{
+  assert.equal(lib.manifest(directory).digest,current.digest,'Candidate changed during DevTools review');validate(directory,copy,current,lib.verifyBuild(directory,copy.buildId),configured);
+  write(directory,'qa/devtools-review.json',copy);return {status:'passed',report:'qa/devtools-review.json',candidateDigest:current.digest,buildId:copy.buildId,invocationVerified:false,limitations};
+ }finally{lib.release(directory,owner);}
+}
+module.exports={KINDS,policy,readPolicy,validate,check,record};

package/skills/i3-ui-prototype/scripts/native-files.cjs

@@ -0,0 +1,35 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const assert = require('node:assert/strict');
+const hash = value => crypto.createHash('sha256').update(value).digest('hex');
+const json = file => JSON.parse(fs.readFileSync(file,'utf8'));
+const id = value => { assert.match(value || '',/^[a-z0-9]+(?:-[a-z0-9]+)*$/,'Invalid identifier'); return value; };
+function inside(root,relative) {
+  assert.ok(typeof relative==='string' && relative && !path.isAbsolute(relative) && !path.win32.isAbsolute(relative) && !relative.includes('\\') && relative.split('/').every(p=>p && p!=='.' && p!=='..'),'Unsafe prototype path');
+  let current=path.resolve(root);
+  for(const part of relative.split('/')) { current=path.join(current,part); if(fs.existsSync(current)) assert.ok(!fs.lstatSync(current).isSymbolicLink(),'Prototype symlink refused'); }
+  return current;
+}
+function walk(root,prefix='',exclude=()=>false) {
+  const location=prefix?inside(root,prefix):root;
+  if(!fs.existsSync(location)) return [];
+  return fs.readdirSync(location,{withFileTypes:true}).sort((a,b)=>a.name.localeCompare(b.name)).flatMap(entry=>{
+    const relative=prefix?`${prefix}/${entry.name}`:entry.name;
+    if(exclude(relative,entry.name)) return [];
+    assert.ok(!entry.isSymbolicLink(),`Prototype symlink refused: ${relative}`);
+    return entry.isDirectory()?walk(root,relative,exclude):entry.isFile()?[relative]:[];
+  });
+}
+function write(root,relative,value) {
+  const file=inside(root,relative); fs.mkdirSync(path.dirname(file),{recursive:true});
+  const tmp=`${file}.${crypto.randomUUID()}.tmp`;
+  try { fs.writeFileSync(tmp,typeof value==='string'?value:JSON.stringify(value,null,2)+'\n',{flag:'wx'}); fs.renameSync(tmp,file); }
+  finally { if(fs.existsSync(tmp)) fs.unlinkSync(tmp); }
+}
+function entries(root,files) { return Object.fromEntries([...new Set(files)].sort().map(file=>[file,hash(fs.readFileSync(inside(root,file)))])); }
+const cacheRoots = new Set(['node_modules','dist','.vite','.git','coverage',...['app','starter'].flatMap(root=>['node_modules','dist','.vite','.git','coverage'].map(name=>`${root}/${name}`))]);
+// A source/public subdirectory named "dist", or an imported .log file, is still source.
+const excluded = (relative,name) => cacheRoots.has(relative) || name==='.DS_Store' || ['app/tsconfig.tsbuildinfo','starter/tsconfig.tsbuildinfo'].includes(relative);
+module.exports={fs,path,crypto,assert,hash,json,id,inside,walk,write,entries,excluded};

package/skills/i3-ui-prototype/scripts/native-pilot-lib.cjs

@@ -0,0 +1,244 @@
+'use strict';
+const F=require('./native-files.cjs');
+const {fs,path,crypto,assert,hash,json,id,inside,walk,write,entries,excluded}=F;
+const skillRoot=path.resolve(__dirname,'..');
+const frameworkRoot=path.join(skillRoot,'assets/frameworks/vue-antdv-next');
+const templates=()=>require('./template-contract.cjs');
+function metadata(directory) { const data=json(inside(directory,'prototype.json')); assert.equal(data.schemaVersion,2,'Not a native v2 prototype'); assert.equal(data.runtime.kind,'vue-antdv-next'); return data; }
+function effectiveReview(data,current) {
+  const review=data.review;
+  if(review.status!=='approved'||(review.revision===current.revision&&review.digest===current.digest))return review;
+  return {status:'pending-review',previousApproval:review,reason:'The stored approval applies to a different revision or candidate digest'};
+}
+function analyze(options={}) {
+  if(options.execution!==undefined)assert.ok(['inline','delegated'].includes(options.execution),'Invalid execution declaration: use inline or delegated');
+  const project=path.resolve(options.project||'.');
+  return {operation:'analyze',readOnly:true,project,projectExists:fs.existsSync(project),supportedOperations:['analyze','create','revise','inspect','confirm-baseline'],execution:options.execution??null,executionEvidence:options.execution===undefined?'unverified':'caller-declared',sideEffects:[]};
+}
+function prepareTemplate(options) { return templates().prepareTemplate(options); }
+function manifest(directory) {
+  const data=metadata(directory);
+  const inputFiles=walk(directory,'inputs');
+  const inputs=entries(directory,inputFiles), inputDigest=hash(JSON.stringify(inputs));
+  const files=entries(directory,[...inputFiles,'requirements-map.json',...['app','mocks','design-system'].flatMap(folder=>walk(directory,folder,excluded))]);
+  const identity={...(data.runtime.contentReference?{business:data.business}:{}),schemaVersion:2,id:data.id,revision:data.revision,artifactKind:data.artifactKind,runtime:data.runtime,template:data.template,framework:data.framework,expertMode:data.expertMode};
+  return {schemaVersion:2,revision:data.revision,identity,inputDigest,files,digest:hash(JSON.stringify({identity,files}))};
+}
+function defaultScope() {
+  return {schemaVersion:1,title:'设备清单首期演示需求',requirements:[
+    {id:'PILOT-01',text:'设备列表支持查询、当前页多选、分页和批量变更状态',source:{type:'prd',reference:'pilot-fixture/PILOT-01',statement:'21条记录，每页10条；换页或筛选清空选择；批量操作仅影响选中记录'}},
+    {id:'PILOT-02',text:'编辑抽屉使用真实表单校验，失败保留输入，成功更新对应记录',source:{type:'prd',reference:'pilot-fixture/PILOT-02',statement:'设备名称必填；可模拟提交失败并重试'}},
+    {id:'PILOT-03',text:'加载、空、失败和恢复可触发；抽屉开合、遮罩模糊及焦点可验证',source:{type:'prd',reference:'pilot-fixture/PILOT-03',statement:'首期演示规则；不是任何生产项目的已确认权限或流程'}}
+  ],exemptions:[],openQuestions:[]};
+}
+function createPrototype(options) {
+  assert.ok(options.framework===undefined||options.framework==='vue-antdv-next','Unsupported framework / 不支持的框架');
+  assert.ok(options.title===undefined||(typeof options.title==='string'&&options.title.trim()),'Title must be a nonempty string');
+  const project=path.resolve(options.project||'.'); assert.ok(fs.statSync(project).isDirectory(),'Project must exist'); id(options.id);
+  const mode=options.expertMode||'professional'; assert.ok(['professional','template'].includes(mode),'Invalid expert mode');
+  let provider=null;
+  if(mode==='professional') {
+    provider=require('./prototype-lib.cjs').checkDesignProvider({...options,project});
+    if(provider.availability!=='available') return {status:'needs-design-provider',provider,sideEffects:[],choices:['locate-or-repair','explicit-template-mode','analyze']};
+  }
+  const template=options.templateRoot?templates().loadTemplate(path.resolve(options.templateRoot)):templates().loadBundledTemplate();
+  const reference=template.kind==='content-reference';
+  assert.ok(!reference||options.scope,'A sourced scope file is required for business generation; no default device demo');
+  const scope=options.scope?json(path.resolve(options.scope)):defaultScope();
+  const selection=reference?require('./content-template.cjs').scopeInputs(template,scope,templates()):null;
+  const content=reference?{pageTitle:scope.title||'业务原型'}:templates().projectAdminListContent(template);
+  if(options.title!==undefined)content.pageTitle=options.title;
+  const profile=json(path.join(frameworkRoot,'profile.json'));
+  const target=inside(project,`prototypes/${options.id}`); assert.ok(!fs.existsSync(target),'Prototype exists; revise without reinitializing');
+  const lockFile=inside(project,'.i3-ui-prototypes.lock'); const lock=fs.openSync(lockFile,'wx');
+  let stage=null,published=false;
+  try {
+    fs.mkdirSync(path.dirname(target),{recursive:true}); stage=fs.mkdtempSync(path.join(path.dirname(target),'.native-'));
+    const registryPath=inside(project,'.i3-ui-prototypes.json'); const registry=fs.existsSync(registryPath)?json(registryPath):{schemaVersion:1,prototypes:[]};
+    assert.equal(registry.schemaVersion,1); assert.ok(Array.isArray(registry.prototypes)); assert.ok(!registry.prototypes.some(p=>p.id===options.id),'Duplicate prototype ID');
+    const frameworkFiles=entries(frameworkRoot,walk(frameworkRoot,'',excluded));
+    const instanceId=crypto.randomUUID();
+    const data={schemaVersion:2,id:options.id,title:options.title||content.pageTitle||'设备清单原型',revision:'r001',artifactKind:'framework-prototype',runtime:{kind:'vue-antdv-next',version:'1',...(reference?{contentReference:true}:{})},...(reference?{business:{status:'needs-adaptation',source:'inputs/scope.json'}}:{}),template:{id:template.id,version:template.version,digest:template.digest},framework:{id:'vue-antdv-next',version:profile.version||'1',digest:hash(JSON.stringify(frameworkFiles))},expertMode:mode,expert:{status:provider?'pending':'skipped',provider},verification:{status:'not-run'},review:{status:'pending-review'},instanceId};
+    write(stage,'prototype.json',data);
+    for(const file of template.files) {
+      assert.equal(file.encoding,'base64');
+      const destination=inside(stage,`inputs/template/${file.path}`); fs.mkdirSync(path.dirname(destination),{recursive:true}); fs.writeFileSync(destination,Buffer.from(file.content,'base64'));
+    }
+    write(stage,'inputs/template-snapshot.json',template);
+    write(stage,'inputs/scope.json',scope);
+    write(stage,'inputs/capabilities.json',selection?selection.fixed:{schemaVersion:1,definition:template.definition,bindings:template.index.bindings,regions:template.index.regions,decisions:[]});
+    write(stage,'inputs/framework.json',{profile,componentMap:json(path.join(frameworkRoot,'component-map.json')),acceptance:json(path.join(frameworkRoot,'acceptance.json')),files:frameworkFiles});
+    const checked=templates().checkInstanceCapabilities(path.join(stage,'inputs')); assert.equal(checked.status,'passed',checked.errors?.join('; '));
+    const requiredScenarios=checked.requiredScenarios.map(s=>typeof s==='string'?s:s.id);
+    write(stage,'inputs/acceptance.json',{schemaVersion:1,requiredScenarios,scenarioDetails:checked.requiredScenarios,frameworkScenarios:reference?['framework-responsive','framework-instance-isolation','template-content-projection',...(selection.fixed.regions.some(region=>region.mode==='edit-form')?['framework-drawer-motion','framework-mask-blur','framework-focus-scroll']:[])]:['framework-drawer-motion','framework-mask-blur','framework-focus-scroll','framework-states','framework-responsive','framework-instance-isolation','template-content-projection'],browserReview:json(path.join(frameworkRoot,'acceptance.json')).browserReview});
+    const requirements=json(path.join(stage,'inputs/scope.json')).requirements;
+    write(stage,'requirements-map.json',{schemaVersion:2,requirements:requirements.map(r=>({...r,pages:reference?r.pages:template.index.pages.map(page=>page.id),scenarios:reference?checked.requiredScenarios.filter(s=>s.bindingId.startsWith('app-shell/')||r.pages.some(page=>s.bindingId.startsWith(page+'/'))).map(s=>s.id):requiredScenarios})),bindings:selection?selection.fixed.bindings:template.index.bindings});
+    const starter=path.join(frameworkRoot,reference?profile.starter:(profile.legacyStarter||profile.starter));
+    fs.cpSync(starter,path.join(stage,'app'),{recursive:true,filter:file=>!excluded(`starter/${path.relative(starter,file).split(path.sep).join('/')}`,path.basename(file))});
+    const themeBinding=(selection?selection.fixed.bindings:template.index.bindings).find(binding=>binding.capabilityId==='theme');
+    write(stage,'app/public/prototype-config.json',{instanceId,storageNamespace:`i3-native-${options.id}-${instanceId}`,mockVersion:reference?'business-v1':'admin-list-v1',title:data.title,...(reference?{pages:scope.pages.map(page=>({id:page.id,title:page.title}))}:{content}),...(themeBinding?{theme:templates().resolveThemeParameters(themeBinding.parameters)}:{})});
+    write(stage,'mocks/contract.json',reference?{schemaVersion:1,instanceId,status:'needs-business-data',requirements:scope.requirements.map(r=>r.id)}:{schemaVersion:1,seed:'admin-list-v1',count:21,pageSize:10,selection:'current-page-clear-on-page-or-filter',instanceId});
+    write(stage,'design-system/MASTER.md',`# ${data.title}\n\n使用 antDv-next 原生组件与主题。管理列表采用紧凑信息层级，正文与操作可读；错误在字段附近呈现。抽屉保留进入与退出过程，显式开启遮罩模糊。\n\n本地模拟，不代表生产权限。\n`);
+    write(stage,'design-system/decisions.json',{schemaVersion:1,records:[],reviewStatus:mode==='template'?'skipped':'pending'});
+    write(stage,'qa/design-advice.json',{schemaVersion:2,provider,queries:[],records:[],status:mode==='template'?'skipped':'pending'});
+    write(stage,'HANDOFF.md',`# ${data.title}\n\n本次为 ${mode} 模式；来源 ${template.id} ${template.version}。运行形态为真实 Vue＋antDv-next。读取 inputs 中固定合同和实际源码，勿从安装目录更新旧合同。\n\n使用 native-pilot.cjs inspect／build／preview。当前未验证，待用户评审；不要把检查通过当用户认可。\n`);
+    const candidate=manifest(stage); data.inputs={digest:candidate.inputDigest}; write(stage,'prototype.json',data);
+    fs.renameSync(stage,target); published=true;
+    registry.prototypes.push({id:options.id,directory:`prototypes/${options.id}`,appliesTo:[],schemaVersion:2}); write(project,'.i3-ui-prototypes.json',registry);
+    return {status:'created',directory:target,revision:'r001',digest:manifest(target).digest};
+  } catch(error) { if(published) fs.rmSync(target,{recursive:true,force:true}); throw error; }
+  finally { if(stage&&fs.existsSync(stage)) fs.rmSync(stage,{recursive:true,force:true}); fs.closeSync(lock); fs.unlinkSync(lockFile); }
+}
+function inspectDesignReview(directory,current=manifest(directory)) {
+  const data=metadata(directory);
+  if(data.expertMode!=='professional') return {status:'skipped',queries:0,records:0,adoptedAdvice:[]};
+  const advice=json(inside(directory,'qa/design-advice.json')); assert.equal(advice.provider?.availability,'available','Professional provider not available');
+  assert.ok(advice.provider.digest,'Professional provider identity required');
+  assert.ok(advice.queries?.length && advice.queries.every(q=>q.query && q.source && q.resultDigest),'Real design query record required');
+  assert.ok(['reviewed','no-match'].includes(advice.status),'Design advice review pending');
+  assert.ok(advice.records?.length && advice.records.every(r=>['adopted','adjusted','rejected','no-match'].includes(r.decision) && r.query && advice.queries.some(q=>q.query===r.query) && r.resultIdentity && r.rationale && r.verification),'Advice decisions need query, identity, reasons and verification');
+  const decisions=json(inside(directory,'design-system/decisions.json'));
+  assert.ok(['reviewed','no-match'].includes(decisions.reviewStatus),'Design contract review pending');
+  const stable=r=>({query:r.query,resultIdentity:r.resultIdentity,decision:r.decision,rationale:r.rationale,implementation:r.implementation||null,verificationScenario:r.verificationScenario||null});
+  assert.deepEqual(decisions.records.map(stable),advice.records.map(stable),'Design contract differs from advice review');
+  const adoptedAdvice=advice.records.filter(r=>['adopted','adjusted'].includes(r.decision));
+  for(const record of adoptedAdvice)assert.ok(Object.hasOwn(current.files,record.implementation) && record.verificationScenario,'Adopted advice needs implementation and verified scenario');
+
+  return {status:advice.status,queries:advice.queries.length,records:advice.records.length,adoptedAdvice};
+}
+function inspectWithInputs(directory,options={},acceptedInputDigest) {
+  try {
+    const data=metadata(directory); const current=manifest(directory);
+    assert.equal(acceptedInputDigest??data.inputs.digest,current.inputDigest,'Input contract changed; explicitly revise fixed inputs');
+    const capability=templates().checkInstanceCapabilities(path.join(directory,'inputs')); assert.equal(capability.status,'passed',capability.errors?.join('; '));
+    const acceptance=json(inside(directory,'inputs/acceptance.json'));
+    require('./native-devtools.cjs').readPolicy(directory);
+    for(const scenario of capability.requiredScenarios.map(s=>typeof s==='string'?s:s.id)) assert.ok(acceptance.requiredScenarios.includes(scenario),`Required scenario omitted: ${scenario}`);
+    const fixedFramework=json(inside(directory,'inputs/framework.json'));
+    if(fixedFramework.acceptance?.scenarios?.some(scenario=>scenario.id==='template-content-projection'&&scenario.required))assert.ok(acceptance.frameworkScenarios.includes('template-content-projection'),'Required template-content-projection scenario omitted from fixed framework acceptance');
+    const template=json(inside(directory,'inputs/template-snapshot.json')),mapping=json(inside(directory,'requirements-map.json')),scope=json(inside(directory,'inputs/scope.json'));
+    const pageIds=new Set(data.runtime.contentReference?['app-shell',...scope.pages.map(page=>page.id)]:template.index.pages.map(page=>page.id)),bindingIds=new Set(json(inside(directory,'inputs/capabilities.json')).bindings.map(binding=>binding.id));
+    for(const requirement of scope.requirements)assert.ok(mapping.requirements.some(item=>item.id===requirement.id),`Requirement omitted from mapping: ${requirement.id}`);
+    for(const requirement of mapping.requirements) {
+      assert.ok(scope.requirements.some(item=>item.id===requirement.id),`Unknown mapped requirement: ${requirement.id}`);
+      if(data.runtime.contentReference)assert.deepEqual(requirement.pages,scope.requirements.find(item=>item.id===requirement.id).pages,`Business requirement page mapping changed: ${requirement.id}`);
+      assert.ok(requirement.pages?.length&&requirement.pages.every(page=>pageIds.has(page)),`Unknown page identity in requirement: ${requirement.id}`);
+      assert.ok(requirement.scenarios?.length&&requirement.scenarios.every(scenario=>acceptance.requiredScenarios.includes(scenario)||acceptance.frameworkScenarios.includes(scenario)),`Unknown scenario in requirement: ${requirement.id}`);
+    }
+    for(const binding of mapping.bindings||[])assert.ok(bindingIds.has(binding.id),`Unknown binding in mapping: ${binding.id}`);
+    for(const file of ['app/package.json','app/package-lock.json','app/src/App.vue','app/public/prototype-config.json','design-system/MASTER.md']) assert.ok(fs.existsSync(inside(directory,file)),`Missing ${file}`);
+    const config=json(inside(directory,'app/public/prototype-config.json')); assert.equal(config.instanceId,data.instanceId); assert.ok(config.storageNamespace.includes(data.instanceId),'Instance storage not isolated');
+    if(data.runtime.contentReference) {
+      assert.deepEqual(config.pages,scope.pages.map(page=>({id:page.id,title:page.title})),'Business configuration differs from fixed page scope');
+      assert.ok(['needs-adaptation','adapted'].includes(data.business?.status),'Unknown business implementation status');
+      const fixedBindings=json(inside(directory,'inputs/capabilities.json')).bindings;
+      assert.deepEqual((mapping.bindings||[]).map(binding=>binding.id).sort(),fixedBindings.map(binding=>binding.id).sort(),'Business mapping omits fixed capabilities');
+    }
+    const themeBinding=json(inside(directory,'inputs/capabilities.json')).bindings.find(binding=>data.runtime.contentReference?binding.capabilityId==='theme':binding.id==='devices/device-list/theme');
+    if(themeBinding)assert.deepEqual(config.theme,templates().resolveThemeParameters(themeBinding.parameters),'Theme configuration differs from fixed input binding');
+    else assert.equal(config.theme,undefined,'Theme requires an explicit optional capability binding');
+    const deps=json(inside(directory,'app/package.json')).dependencies; assert.ok(deps['antdv-next'] && deps.vue,'Native framework dependencies missing');
+    if(options.acceptance) {
+      if(data.runtime.contentReference)assert.equal(data.business?.status,'adapted','Business implementation pending; a scaffold cannot pass acceptance');
+      const adoptedAdvice=inspectDesignReview(directory,current).adoptedAdvice;
+      const report=options.report||json(inside(directory,json(inside(directory,'qa/latest.json')).report));
+      assert.equal(report.status,'passed'); assert.equal(report.candidateDigest,current.digest,'Browser evidence is stale'); assert.equal(report.revision,current.revision);
+      const build=verifyBuild(directory,report.buildId); assert.equal(report.buildDigest,build.buildDigest);
+      assert.ok(report.executor && report.tool && report.startedAt && report.completedAt && report.source,'Browser run provenance required');
+      require('./native-build.cjs').verifyBrowserReport(directory,report,build);
+      assert.deepEqual(report.consoleErrors,[],'Browser errors remain');
+      const required=[...acceptance.requiredScenarios,...acceptance.frameworkScenarios];
+      for(const scenario of required) assert.ok(report.journeys.some(j=>j.id===scenario && j.status==='passed'),`Missing browser scenario: ${scenario}`);
+      for(const record of adoptedAdvice)assert.ok(report.journeys.some(j=>j.id===record.verificationScenario && j.status==='passed'),`Advice verification missing: ${record.resultIdentity}`);
+    }
+    return {status:'passed',level:options.acceptance?'acceptance':'structure',revision:current.revision,digest:current.digest,verification:data.verification.status,review:effectiveReview(data,current).status};
+  } catch(error) { return {status:'failed',errors:[error.message]}; }
+}
+function inspect(directory,options={}) { return inspectWithInputs(directory,options); }
+function expected(directory,options) {
+  const current=manifest(directory);
+  assert.equal(options.expectedRevision,current.revision,'Stale revision / 版本冲突'); assert.equal(options.expectedDigest,current.digest,'Candidate changed / 内容变化'); return current;
+}
+function claim(directory,options) {
+  id(options.owner); expected(directory,options);
+  const lock=inside(directory,'.prototype-write.lock'); const fd=fs.openSync(lock,'wx');
+  try { fs.writeFileSync(fd,JSON.stringify({owner:options.owner,revision:options.expectedRevision,digest:options.expectedDigest})); }
+  finally { fs.closeSync(fd); }
+  write(directory,'execution.json',{owner:options.owner,status:'editing',revision:options.expectedRevision,digest:options.expectedDigest}); return {owner:options.owner};
+}
+function release(directory,owner) {
+  const lock=inside(directory,'.prototype-write.lock'); assert.equal(json(lock).owner,owner,'Different writing owner');
+  fs.unlinkSync(lock); write(directory,'execution.json',{owner,status:'released'}); return {status:'released'};
+}
+function mutate(directory,options,fn) {
+  const lock=inside(directory,'.prototype-write.lock'); const temporary=!fs.existsSync(lock); const owner=options.owner||`run-${crypto.randomUUID()}`;
+  if(temporary) claim(directory,{...options,owner}); else { assert.equal(json(lock).owner,owner,'Candidate has another writing owner'); expected(directory,options); }
+  try { return fn(); } finally { if(temporary) release(directory,owner); }
+}
+function revise(directory,options) {
+  id(options.revision);
+  assert.ok(options.acceptInputs===undefined||typeof options.acceptInputs==='boolean','--accept-inputs must be a boolean flag');
+  return mutate(directory,options,()=>{
+    const current=manifest(directory);
+    const data=metadata(directory); assert.notEqual(data.revision,options.revision); assert.ok(!fs.existsSync(inside(directory,`baselines/${options.revision}`)),'Revision already frozen');
+    if(options.acceptInputs) {
+      const checked=inspectWithInputs(directory,{},current.inputDigest);
+      assert.equal(checked.status,'passed',checked.errors?.join('; '));
+    } else assert.equal(data.inputs.digest,current.inputDigest,'Input contract changed; revise --accept-inputs must explicitly validate the new contract');
+    assert.equal(manifest(directory).digest,current.digest,'Candidate changed while validating fixed inputs');
+    if(options.acceptInputs)data.inputs={digest:current.inputDigest};
+    data.revision=options.revision; data.verification={status:'not-run'}; data.review={status:'pending-review'};
+    write(directory,'prototype.json',data); return manifest(directory);
+  });
+}
+function build(directory,options={}) { return require('./native-build.cjs').build(directory,options,{manifest,inspect}); }
+function verifyBuild(directory,buildId) { return require('./native-build.cjs').verifyBuild(directory,buildId,{manifest}); }
+function preview(directory,options={}) { return require('./native-build.cjs').preview(directory,options,{manifest}); }
+function recordRun(directory,report) {
+  report=JSON.parse(JSON.stringify(report));
+  id(report.id); const current=manifest(directory); assert.equal(report.candidateDigest,current.digest,'Candidate changed during browser run'); assert.equal(report.revision,current.revision);
+  const result=inspect(directory,{acceptance:true,report}); assert.equal(result.status,'passed',result.errors?.join('; '));
+  assert.equal(manifest(directory).digest,current.digest,'Candidate changed while checking browser report');
+  const relative=`qa/runs/${report.id}/report.json`,existing=inside(directory,relative);
+  if(fs.existsSync(existing))assert.deepEqual(json(existing),report,'Published browser run is immutable; use a new run ID');
+  else write(directory,relative,report);
+  write(directory,'qa/latest.json',{report:relative});
+  const data=metadata(directory); data.verification={status:'passed',digest:current.digest,run:report.id};
+  data.review=effectiveReview(data,current);
+  if(data.expertMode==='professional') {
+    const advice=json(inside(directory,'qa/design-advice.json'));
+    data.expert.status=advice.records.some(record=>['adopted','adjusted'].includes(record.decision))?'used':advice.records.every(record=>record.decision==='no-match')?'no-match':'reviewed';
+  }
+  write(directory,'prototype.json',data); return {...result,verification:'passed'};
+}
+function confirmBaseline(directory,confirmation) {
+  assert.ok(confirmation.reviewer && confirmation.statement && confirmation.source,'Explicit human confirmation required / 人类确认');
+  const current=manifest(directory); assert.equal(confirmation.revision,current.revision); assert.equal(confirmation.digest,current.digest);
+  return mutate(directory,{expectedRevision:current.revision,expectedDigest:current.digest},()=>{
+    const checked=inspect(directory,{acceptance:true}); assert.equal(checked.status,'passed',checked.errors?.join('; '));
+    const devtoolsReview=require('./native-devtools.cjs').check(directory,module.exports);assert.ok(!devtoolsReview.required||devtoolsReview.status==='current',`Current DevTools review required: ${devtoolsReview.errors?.join('; ')||devtoolsReview.status}`);
+    const target=inside(directory,`baselines/${id(current.revision)}`); assert.ok(!fs.existsSync(target),'Baseline exists');
+    fs.mkdirSync(path.dirname(target),{recursive:true});const stage=fs.mkdtempSync(path.join(path.dirname(target),'.freeze-'));
+    try {
+      for(const [file,digest]of Object.entries(current.files)) {
+        const destination=inside(stage,file);fs.mkdirSync(path.dirname(destination),{recursive:true});fs.copyFileSync(inside(directory,file),destination);
+        assert.equal(hash(fs.readFileSync(destination)),digest,`Snapshot copy differs: ${file}`);
+      }
+      write(stage,'manifest.json',current);write(stage,'review.json',confirmation);const reviewDigest=hash(fs.readFileSync(path.join(stage,'review.json')));
+      assert.equal(manifest(directory).digest,current.digest,'Candidate changed during freezing');
+      fs.renameSync(stage,target);
+      write(directory,'baseline.json',{schemaVersion:2,revision:current.revision,digest:current.digest,reviewDigest,directory:`baselines/${current.revision}`});
+      const data=metadata(directory);data.review={status:'approved',revision:current.revision,digest:current.digest};write(directory,'prototype.json',data);return current;
+    } finally {if(fs.existsSync(stage))fs.rmSync(stage,{recursive:true,force:true});}
+  });
+}
+function compareBaseline(directory) {
+  if(!fs.existsSync(inside(directory,'baseline.json'))) return {status:'no-baseline',changes:[],protectedChanges:[]};
+  const baseline=json(inside(directory,'baseline.json')); const folder=inside(directory,baseline.directory); const saved=json(path.join(folder,'manifest.json'));
+  if(hash(fs.readFileSync(path.join(folder,'review.json')))!==baseline.reviewDigest || saved.digest!==baseline.digest || hash(JSON.stringify({identity:saved.identity,files:saved.files}))!==saved.digest || Object.entries(saved.files).some(([f,d])=>!fs.existsSync(inside(folder,f))||hash(fs.readFileSync(inside(folder,f)))!==d)) return {status:'corrupt-baseline'};
+  const current=manifest(directory); const changes=[...new Set([...Object.keys(saved.files),...Object.keys(current.files)])].filter(f=>saved.files[f]!==current.files[f]);
+  return {status:current.digest===saved.digest?'unchanged':'changed',changes,protectedChanges:changes,revision:current.revision,baselineRevision:saved.revision};
+}
+function state(directory,options={}) { return require('./native-delivery.cjs').state(directory,options,module.exports); }
+function finalize(directory,options={}) { return require('./native-delivery.cjs').finalize(directory,options,module.exports); }
+module.exports={analyze,prepareTemplate,createPrototype,manifest,inspect,inspectDesignReview,effectiveReview,claim,release,revise,build,verifyBuild,preview,recordRun,confirmBaseline,compareBaseline,state,finalize};