@givolt/i3-composer-agent 3.1.0 → 4.0.0

package/scripts/template-adapter-test.js

@@ -1,155 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const installation = path.join(__dirname, 'lib/installation.js');
-const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const skill = path.join(skills, 'i3-ui-prototype');
-const lib = require(path.join(skill, 'scripts/prototype-lib.cjs'));
-const { createTemplateRegistry } = require(path.join(skill, 'scripts/template-adapters.cjs'));
-const read = (root, file) => JSON.parse(fs.readFileSync(path.join(root, file), 'utf8'));
-function write(root, file, value) {
-  fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
-  fs.writeFileSync(path.join(root, file), typeof value === 'string' ? value : JSON.stringify(value, null, 2));
-}
-function fixture(t) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'template-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const assets = path.join(root, 'assets'), project = path.join(root, 'project');
-  fs.mkdirSync(project);
-  write(assets, 'catalog.json', { schemaVersion: 2, defaultTemplate: 'independent-demo', templates: [
-    { id: 'independent-demo', name: 'Independent test fixture', version: '1.0.0', availability: 'available', manifest: 'independent-demo/manifest.json' },
-    { id: 'not-built', name: 'Planned fixture', version: null, availability: 'planned' },
-  ], legacyTemplates: [] });
-  write(assets, 'independent-demo/manifest.json', { schemaVersion: 1, adapter: 'independent-test', preset: 'independent-demo/preset.json', resources: { root: 'independent-demo/runtime' }, defaultTitle: 'Independent fixture' });
-  write(assets, 'independent-demo/preset.json', { layout: 'independent', primitive: {}, semantic: { 'color-primary': '#123456' }, component: {} });
-  write(assets, 'independent-demo/runtime/index.html', '<!doctype html><title>Independent fixture</title><main>Independent runtime</main>');
-  write(assets, 'independent-demo/runtime/unique.txt', 'INDEPENDENT RUNTIME');
-  const adapter = {
-    version: 'test-fixture-1',
-    runtime: { kind: 'independent-test', requiredFiles: ['app/unique.txt'], identityFields: ['runtime'], excludedBrowserPrefixes: [], protectedFiles: ['app/unique.txt'], protectedDirectories: [] },
-    fingerprintInputs: ({ resources }) => [resources.root],
-    initialize(directory, options, context) {
-      fs.cpSync(context.resource('root'), path.join(directory, 'app'), { recursive: true });
-      fs.mkdirSync(path.join(directory, 'mocks'));
-      write(directory, 'design-system/MASTER.md', '# Independent design');
-      write(directory, 'requirements-map.json', { schemaVersion: 1, requirements: [{ id: 'ONLY-01', pages: ['app/index.html'], roles: ['test'], actions: ['read'], scenarios: ['independent-flow'] }] });
-      return { metadata: { runtime: { kind: 'independent-test', entry: 'app/index.html' } }, handoff: 'Independent test fixture only.' };
-    },
-    validateRuntime(metadata) { assert.equal(metadata.runtime?.kind, 'independent-test'); },
-  };
-  const registry = () => createTemplateRegistry({ assetRoot: assets, adapters: { 'independent-test': adapter } });
-  return { assets, project, registry, adapter };
-}
-test('a registered independent runtime initializes and validates without any common assets', t => {
-  const f = fixture(t), registry = f.registry();
-  const result = lib.initPrototype({ project: f.project, id: 'standalone', expertMode: 'template' }, registry);
-  assert.equal(result.status, 'created');
-  assert.equal(fs.existsSync(path.join(f.assets, 'common')), false);
-  assert.equal(fs.readFileSync(path.join(result.directory, 'app/unique.txt'), 'utf8'), 'INDEPENDENT RUNTIME');
-  assert.equal(read(result.directory, 'prototype.json').template.adapter, 'independent-test');
-  const checked = lib.checkPrototype(result.directory, {}, registry);
-  assert.equal(checked.status, 'passed', JSON.stringify(checked));
-  fs.unlinkSync(path.join(result.directory, 'app/unique.txt'));
-  assert.match(lib.checkPrototype(result.directory, {}, registry).errors.join(' '), /unique\.txt/);
-});
-test('planned, unknown and unregistered adapters fail before touching the output project', t => {
-  const f = fixture(t);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'planned', template: 'not-built', expertMode: 'template' }, f.registry()), /planned|尚未/);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-  const manifest = read(f.assets, 'independent-demo/manifest.json');
-  manifest.adapter = 'missing-adapter'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'unknown', expertMode: 'template' }, f.registry()), /adapter/i);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-});
-test('catalog and manifest paths reject traversal, absolute paths and symlinks before writes', t => {
-  for (const unsafe of ['../outside', '/tmp/outside', 'C:\\outside', 'independent-demo/../outside']) {
-    const f = fixture(t), manifest = read(f.assets, 'independent-demo/manifest.json');
-    manifest.resources.root = unsafe; write(f.assets, 'independent-demo/manifest.json', manifest);
-    assert.throws(() => lib.initPrototype({ project: f.project, id: 'unsafe', expertMode: 'template' }, f.registry()), /path|路径|outside|inside|unsafe/i);
-    assert.deepEqual(fs.readdirSync(f.project), []);
-  }
-  const f = fixture(t), manifest = read(f.assets, 'independent-demo/manifest.json');
-  fs.symlinkSync(path.join(f.assets, 'independent-demo/runtime'), path.join(f.assets, 'linked'), 'dir');
-  manifest.resources.root = 'linked'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.throws(() => lib.initPrototype({ project: f.project, id: 'linked', expertMode: 'template' }, f.registry()), /symlink|符号链接/i);
-  assert.deepEqual(fs.readdirSync(f.project), []);
-});
-test('duplicate catalog identities and unsafe manifest locations cannot alias another template', t => {
-  const f = fixture(t), catalog = read(f.assets, 'catalog.json');
-  catalog.legacyTemplates.push({ ...catalog.templates[0] }); write(f.assets, 'catalog.json', catalog);
-  assert.throws(() => f.registry().list(), /duplicate|重复/i);
-  catalog.legacyTemplates = []; catalog.templates[0].manifest = '../manifest.json'; write(f.assets, 'catalog.json', catalog);
-  assert.throws(() => f.registry().list(), /path|路径|manifest/i);
-});
-test('independent runtime and manifest changes are included in the template fingerprint', t => {
-  const f = fixture(t), original = f.registry().list()[0].digest;
-  fs.appendFileSync(path.join(f.assets, 'independent-demo/runtime/unique.txt'), '\nchanged');
-  const changedRuntime = f.registry().list()[0].digest;
-  assert.notEqual(changedRuntime, original);
-  const manifest = read(f.assets, 'independent-demo/manifest.json');
-  manifest.defaultTitle = 'Changed default title'; write(f.assets, 'independent-demo/manifest.json', manifest);
-  assert.notEqual(f.registry().list()[0].digest, changedRuntime);
-});
-test('adapter versions and declared implementation files participate in template fingerprints', t => {
-  const f = fixture(t), initial = f.registry().list()[0].digest;
-  f.adapter.version = 'test-fixture-2';
-  assert.notEqual(f.registry().list()[0].digest, initial);
-  const implementation = path.join(f.assets, 'adapter-fixture.cjs');
-  fs.writeFileSync(implementation, '// fixture adapter implementation v1');
-  f.adapter.implementationFiles = [implementation];
-  const before = f.registry().list()[0].digest;
-  fs.writeFileSync(implementation, '// fixture adapter implementation v2');
-  assert.notEqual(f.registry().list()[0].digest, before);
-});
-test('selected catalog metadata affects fingerprints without coupling unrelated templates', t => {
-  const f = fixture(t), original = f.registry().resolve('independent-demo').entry.digest;
-  const catalog = read(f.assets, 'catalog.json');
-  catalog.templates[0].name = 'Renamed independent fixture'; write(f.assets, 'catalog.json', catalog);
-  const renamed = f.registry().resolve('independent-demo').entry.digest;
-  assert.notEqual(renamed, original);
-  catalog.templates[1].name = 'Renamed unrelated planned fixture'; write(f.assets, 'catalog.json', catalog);
-  assert.equal(f.registry().resolve('independent-demo').entry.digest, renamed);
-});
-test('baseline guards use independent adapter protected paths and reject runtime substitution', t => {
-  const f = fixture(t), registry = f.registry();
-  const dir = lib.initPrototype({ project: f.project, id: 'baseline', expertMode: 'template' }, registry).directory;
-  const manifest = lib.contentManifest(dir, registry);
-  write(dir, 'qa/unit-fixture.txt', 'UNIT FIXTURE ONLY; not browser evidence or human approval');
-  write(dir, 'qa/browser.json', { revision: manifest.revision, digest: manifest.digest, status: 'passed', source: 'UNIT FIXTURE ONLY', screenshots: ['qa/unit-fixture.txt'], journeys: [{ id: 'independent-flow', status: 'passed' }], consoleErrors: [], viewports: [390, 1440] });
-  lib.freezeBaseline(dir, { revision: manifest.revision, digest: manifest.digest, reviewer: 'unit fixture', statement: 'UNIT FIXTURE ONLY', source: 'test fixture' }, registry);
-  fs.appendFileSync(path.join(dir, 'app/unique.txt'), '\nchanged');
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('app/unique.txt'));
-  fs.appendFileSync(path.join(dir, 'design-system/MASTER.md'), '\nchanged design contract');
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('design-system/MASTER.md'));
-  const identityChange = read(dir, 'prototype.json');
-  identityChange.runtime.variant = 'changed'; write(dir, 'prototype.json', identityChange);
-  assert.ok(lib.compareBaseline(dir, registry).protectedChanges.includes('runtime-contract'));
-  const metadata = read(dir, 'prototype.json'); metadata.template.adapter = 'legacy-html'; write(dir, 'prototype.json', metadata);
-  assert.equal(lib.checkPrototype(dir, {}, registry).status, 'failed');
-});
-test('pre-adapter legacy instances retain their original manifest digest and remain inspectable', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'legacy-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const dir = lib.initPrototype({ project: root, id: 'old-legacy', template: 'classic-admin', expertMode: 'template' }).directory;
-  const metadata = read(dir, 'prototype.json'); delete metadata.template.adapter; delete metadata.runtime; write(dir, 'prototype.json', metadata);
-  const identity = { id: metadata.id, revision: metadata.revision, template: metadata.template, expertMode: metadata.expertMode, artifactKind: metadata.artifactKind };
-  const manifest = lib.contentManifest(dir);
-  assert.deepEqual(manifest.identity, identity);
-  assert.equal(manifest.digest, crypto.createHash('sha256').update(JSON.stringify({ identity, files: manifest.files })).digest('hex'));
-  assert.equal(lib.checkPrototype(dir).status, 'passed');
-});
-test('pre-adapter EASEL identities keep the previous content-manifest field order and digest', t => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'old-easel-adapter-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const dir = lib.initPrototype({ project: root, id: 'old-easel', purpose: 'template-review', expertMode: 'template' }).directory;
-  const metadata = read(dir, 'prototype.json'); delete metadata.template.adapter; write(dir, 'prototype.json', metadata);
-  const identity = { id: metadata.id, revision: metadata.revision, template: metadata.template, expertMode: metadata.expertMode, artifactKind: metadata.artifactKind, purpose: metadata.purpose, business: metadata.business, runtime: metadata.runtime };
-  const manifest = lib.contentManifest(dir);
-  assert.equal(JSON.stringify(manifest.identity), JSON.stringify(identity));
-  assert.equal(manifest.digest, crypto.createHash('sha256').update(JSON.stringify({ identity, files: manifest.files })).digest('hex'));
-  assert.equal(lib.checkPrototype(dir).status, 'passed');
-});

package/scripts/ui-prototype-binding-recovery-test.js

@@ -1,84 +0,0 @@
-'use strict';
-// Regression cases reduced from a real IDE failure; no native host is installed.
-const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os'),cp=require('node:child_process');
-const installed=path.join(__dirname,'lib/installation.js');
-const scripts=path.join(fs.existsSync(installed)?require(installed).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
-const E=require(path.join(scripts,'execution-evidence.cjs')),H=require(path.join(scripts,'codebuddy-hook.cjs')),N=require(path.join(scripts,'native-command.cjs')),R=require(path.join(scripts,'execution-recovery.cjs'));
-const raw=rows=>rows.map(row=>JSON.stringify(row)).join('\n')+'\n';
-for(const flat of [false,true])test(`raw ${flat?'flat':'paired'} use_skill is a real Skill without accepting Read or forged names`,()=>{
- const rows=flat?[
-  {type:'function_call',callId:'front',name:'use_skill',arguments:'{"command":"i3-frontend-ui-engineering"}',sessionId:'s1'},
-  {type:'function_call_result',callId:'front',name:'Skill',status:'completed',output:'Frontend instructions',sessionId:'s1'}
- ]:[
-  {type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'front',name:'use_skill',input:{command:'i3-frontend-ui-engineering'}}]}},
-  {type:'user',sessionId:'s1',message:{content:[{type:'tool_result',tool_use_id:'front',tool_name:'Skill',content:'Frontend instructions'}]}}
- ];
- const calls=E.parse(raw(rows));assert.equal(E.loaded(calls,'frontend').length,1);assert.equal(calls[0].name,'Skill');assert.equal(calls[0].rawName,'use_skill');
- assert.equal(H.eventCall({hook_event_name:'PostToolUse',tool_name:'use_skill',tool_use_id:'front',tool_input:calls[0].input},{prompts:[{line:0}],calls}).toolCallId,'front');
- for(const name of ['Read','use_skill_fake']){
-  const changed=JSON.parse(JSON.stringify(rows));if(flat){changed[0].name=changed[1].name=name;}else{changed[0].message.content[0].name=changed[1].message.content[0].tool_name=name;}
-  assert.equal(E.loaded(E.parse(raw(changed)),'frontend').length,0);
- }
- const wrong=JSON.parse(JSON.stringify(rows));if(flat)wrong[1].sessionId='s2';else wrong[1].sessionId='s2';assert.throws(()=>E.parse(raw(wrong)),/session/);
-});
-test('native execute_command success cannot hide a failed stage inside result or stdout',()=>{
- for(const result of [
-  {type:'execute_command_result',exitCode:1,stdout:'failed'},
-  {type:'execute_command_result',exitCode:0,stdout:'{"status":"failed","errors":["No native Hook task binding"]}\r\n\r\n'},
-  {type:'execute_command_result',exitCode:0,stdout:'Error: unavailable'},
-  {status:'failed',errors:['native stage failed']}
- ])assert.equal(E.successful({content:{status:'success',success:true,result}}),false);
- assert.equal(E.successful({content:{status:'success',success:true,result:{type:'execute_command_result',exitCode:0,stdout:'{"status":"bound","runId":"r1"}'}}}),true);
- assert.equal(E.successful({content:{result:{status:'failed'},observedApplicationState:true}}),true,'A browser observation of an error is not a failed tool');
-});
-test('frontend already loaded leaves only execution-begin missing until the native begin actually succeeds',()=>{
- const directory='/work/prototypes/a',binding={entryLine:1,contextLine:0,sessionId:'s1',runId:'r1',directory,project:'/work'};
- const source={prompts:[{line:1,text:'实现原型'}],contextLine:0,calls:[{skill:'frontend',success:true,sessionId:'s1',requestLine:2,resultLine:3}]};
- const input={event:'PreToolUse',source,binding,tool:'Write',input:{file_path:directory+'/app/src/A.vue'},directory,cwd:'/work'};
- let answer=H.decision(input);assert.equal(answer.deny,true);assert.deepEqual(answer.missing,['execution-begin']);assert.doesNotMatch(answer.reason,/调用 i3-frontend/);
- const command=`node /skills/native-pilot.cjs execution-begin '${directory}'`;
- const begin={toolCallId:'begin',name:'Bash',input:{command},cwd:'/work',success:false,sessionId:'s1',result:{status:'bound',runId:'r1',sessionId:'s1',directory},requestLine:4,resultLine:5};source.calls.push(begin);
- assert.equal(H.decision(input).deny,true);begin.success=true;assert.equal(H.decision(input).continue,true);
- begin.result={...begin.result,runId:'another-run'};assert.equal(H.decision(input).deny,true);begin.result.runId='r1';
- begin.result.status='success';assert.equal(H.decision(input).deny,true);begin.result.status='bound';
- source.stableThroughLine=4;assert.equal(H.decision(input).deny,true);delete source.stableThroughLine;
- source.calls.push({...begin,toolCallId:'failed-rebind',requestLine:6,resultLine:7,success:false});assert.equal(H.decision(input).deny,true,'A failed rebind must not inherit old success');
-});
-test('binding recovery emits one absolute quoted command that the strict parser recognizes',()=>{
- const directory="/work with spaces/prototypes/customer's demo";
- const command=N.beginCommand(directory);const parsed=N.nativeCommand('Bash',{command},'/unrelated');
- assert.equal(parsed.operation,'execution-begin');assert.equal(parsed.root,directory);assert.ok(path.isAbsolute(parsed.argv[0]));assert.ok(path.isAbsolute(parsed.argv[1]));
- assert.match(R.instruction(['execution-begin'],{directory}),new RegExp('execution-begin'));assert.ok(R.instruction(['execution-begin'],{directory}).includes(command));
- assert.match(R.instruction(['execution-begin'],{directory}),/管道|pipeline/);
- assert.equal(N.nativeCommand('Bash',{command:`cd /work && ${command} 2>&1 | head -80`},'/work'),null);
-});
-test('unbound CLI execution-begin exits nonzero with an actionable standalone command and creates no proof',t=>{
- const root=fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(),'i3-unbound-regression-')));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
- const result=cp.spawnSync(process.execPath,[path.join(scripts,'native-pilot.cjs'),'execution-begin',root],{encoding:'utf8'});
- assert.equal(result.status,1);const failure=JSON.parse(result.stderr);assert.equal(failure.status,'failed');assert.match(failure.errors.join(),/No native Hook task binding/);
- assert.ok(failure.errors.join().includes(N.beginCommand(root)));assert.deepEqual(fs.readdirSync(root),[]);
-});
-test('PostToolUse failures use additionalContext and keep the tool return intact',()=>{
- const value=require(path.join(scripts,'hosts/codebuddy.cjs')).format({feedback:true,reason:'实际返回失败，请补调'},'PostToolUse');
- assert.equal(value.output.continue,true);assert.deepEqual(value.output.hookSpecificOutput,{hookEventName:'PostToolUse',additionalContext:'实际返回失败，请补调'});
- const bound={status:'bound',runId:'r1'};assert.deepEqual(E.resultValue([{type:'text',text:JSON.stringify(bound)}]),bound);
-});
-test('native wrappers preserve actual JSON facts and quoted findings without matching escaped wrapper bytes',()=>{
- const facts={form:{errors:1},observed:true},wrapped={status:'success',success:true,result:JSON.stringify(facts)};
- const A=require(path.join(scripts,'execution-assertions.cjs'));
- assert.equal(A.extract(A.resultData(wrapped),'/form/errors'),1);assert.ok(E.resultText(wrapped).includes('"observed":true'));
- assert.deepEqual(A.resultData({result:{status:'failed'},observedApplicationState:true}),{result:{status:'failed'},observedApplicationState:true});
- assert.equal(E.successful({content:{type:'text',text:'{"status":"failed","operation":"execution-begin"}'}}),false);
-});
-test('loading a missing browser Skill cannot let another stage stand in for the denied finalize retry',()=>{
- const source={prompts:[{line:1,digest:'task',text:'实现原型'}],contextLine:0,calls:[]},index={};
- const context={source,sessionId:'s1',directory:'/work/prototypes/a',stage:'delivery',event:'PreToolUse',eventKey:'deny-finalize',expectedRetry:{kind:'stage',stage:'delivery',operation:'finalize'}};
- R.record(index,context,{deny:true,missing:['browser']});
- source.calls.push({skill:'browser',toolCallId:'actual-browser-load',sessionId:'s1',requestLine:2,resultLine:3,success:true});
- const failedPrerequisite=R.record(index,{...context,stage:'browser-entry',event:'PostToolUse',eventKey:'failed-review',expectedRetry:{kind:'stage',stage:'browser-entry',operation:'record-devtools-review'}},{feedback:true,missing:['execution-evidence']});
- assert.equal(failedPrerequisite.recovery.expectedRetry.operation,'finalize');
- const other=R.record(index,{...context,stage:'browser-entry',resolved:['execution-evidence'],event:'PostToolUse',eventKey:'other-stage-result',retrySucceeded:true,retry:{kind:'stage',stage:'browser-entry',operation:'record-devtools-review',requestLine:4,resultLine:5}},{continue:true});
- assert.equal(other.recovery.status,'ready-to-retry');
- const correct=R.record(index,{...context,event:'PostToolUse',eventKey:'finalize-result',retrySucceeded:true,retry:{kind:'stage',stage:'delivery',operation:'finalize',requestLine:6,resultLine:7}},{continue:true});
- assert.equal(correct.recovery.status,'recovered');
-});

package/scripts/ui-prototype-buddy-lifecycle-test.js

@@ -1,102 +0,0 @@
-'use strict';
-// Real filesystem/Hook handlers with explicitly synthetic native events, not host acceptance.
-const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),os=require('node:os'),path=require('node:path');
-const installed=path.join(__dirname,'lib/installation.js');
-const scripts=path.join(fs.existsSync(installed)?require(installed).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
-const H=require(path.join(scripts,'codebuddy-hook.cjs')),R=require(path.join(scripts,'codebuddy-registration.cjs')),C=require(path.join(scripts,'codebuddy-context.cjs'));
-const P=require(path.join(scripts,'execution-policy.cjs')),A=require(path.join(scripts,'execution-assertions.cjs')),lib=require(path.join(scripts,'native-pilot-lib.cjs')),X=require(path.join(scripts,'execution-runtime.cjs'));
-function fixture(t,host,scope,client){
- const root=fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(),'i3-buddy-lifecycle-fixture-')));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
- const project=path.join(root,'business'),home=path.join(root,'isolated-home');fs.mkdirSync(project);fs.mkdirSync(home);
- const scopeFile=path.join(root,'scope.json');fs.writeFileSync(scopeFile,JSON.stringify({schemaVersion:1,title:'Synthetic fixture',pages:[{id:'orders',title:'Orders',referencePage:'models-page',regions:[{id:'list',mode:'management-list'}]}],requirements:[{id:'R1',text:'Synthetic contract only',pages:['orders'],source:{type:'prd',reference:'fixture',statement:'Not native host or business acceptance'}}],exemptions:[]}));
- const opts={project,scope:scopeFile,expertMode:'template'};
- const facts=A.template(opts);for(const item of facts.scenarios)item.checks=[{method:'evaluate_script',pointer:'/fixture',operator:'equals',expected:true}];
- const assertions=path.join(root,'facts.json');fs.writeFileSync(assertions,JSON.stringify(facts));
- const created=lib.createPrototype({...opts,id:'orders',host,executionPolicy:P.AUTO_ID,executionAssertions:assertions});
- const base=scope==='project'?path.join(project,'.codebuddy'):path.join(home,`.${host}`),entry=path.join(scripts,'hosts/codebuddy.cjs');
- const registered=R.plan({action:'enable',scope,host,base,project,nodePath:process.execPath,scriptPath:entry,scriptDigest:C.bundle(entry)});R.apply(registered);
- const file=client?path.join(root,'native.jsonl'):path.join(home,`.${host}`,'projects','business','fixture-native-session.jsonl'),sessionId='fixture-native-session',rows=[];let number=0;
- fs.mkdirSync(path.dirname(file),{recursive:true});
- function append(row){
-  if(!client){
-   const block=Array.isArray(row.message?.content)?row.message.content[0]:null;
-   if(block?.type==='tool_use')row={type:'function_call',callId:block.id,name:block.name,arguments:JSON.stringify(block.input)};
-   else if(block?.type==='tool_result')row={type:'function_call_result',callId:block.tool_use_id,output:block.content,status:block.is_error?'failed':'completed'};
-   else row={type:'message',role:row.type,content:[{type:row.type==='user'?'input_text':'output_text',text:row.message?.content||''}]};
-  }
-  rows.push({...row,sessionId,cwd:project});fs.writeFileSync(file,rows.map(value=>JSON.stringify(value)).join('\n')+'\n');
- }
- function hook(event,name,input,id){return H.handle({client,hook_event_name:event,session_id:sessionId,transcript_path:file,cwd:project,tool_name:name,tool_input:input,tool_use_id:id},{event,base,scope,product:'auto',home,env:{}});}
- function request(name,input){const id='fixture-call-'+(++number);append({type:'assistant',message:{content:[{type:'tool_use',id,name,input}]}});return id;}
- function result(id,content,failed=false){append({type:'user',message:{content:[{type:'tool_result',tool_use_id:id,content,is_error:failed}]}});}
- function tool(name,input,content='success',action=()=>{}){
-  const id=request(name,input),decision=hook('PreToolUse',name,input,id);
-  if(decision.deny){result(id,decision.reason,true);return {id,decision};}
-  action();result(id,typeof content==='function'?content():content);return {id,decision,post:hook('PostToolUse',name,input,id)};
- }
- append({type:'user',message:{content:'实现原型，使用模板模式。Synthetic fixture only.'}});
- tool('Skill',{skill:'i3-ui-prototype'},'Prototype Skill loaded');
- const begin=()=>tool('Bash',{command:`node '${path.join(scripts,'native-pilot.cjs')}' execution-begin '${created.directory}'`},()=>{const pointer=JSON.parse(fs.readFileSync(path.join(created.directory,'qa/execution-context.json')));return JSON.stringify({status:'bound',runId:pointer.runId,sessionId,directory:created.directory});});begin();
- return {root,project,base,directory:created.directory,append,hook,tool,begin,result,request,read(){const pointer=JSON.parse(fs.readFileSync(path.join(created.directory,'qa/execution-context.json')));const selected=C.select({project,product:client==='CodeBuddyCLI'||!client&&host==='codebuddy'?'cli':'ide',host,home,env:{}});return JSON.parse(fs.readFileSync(path.join(C.sessionDirectory(selected,project,pointer.sessionId),'session.json')));}};
-}
-for(const [host,client] of [['codebuddy','CodeBuddyCLI'],['codebuddy','CodeBuddyIDE'],['workbuddy','WorkBuddy'],['codebuddy',null],['workbuddy',null]])for(const scope of ['project','global'])test(`${host} ${client||'native-flat-log'} ${scope}: deny, correlate successful Skills, retry and retain budget`,t=>{
- const f=fixture(t,host,scope,client),file=path.join(f.directory,'app/src/RecoveryFixture.vue');
- const denied=f.tool('Write',{file_path:file,content:'fixture'});assert.equal(denied.decision.deny,true);assert.equal(fs.existsSync(file),false);
- assert.match(denied.decision.reason,/i3-frontend-ui-engineering/);
- const before=Object.values(f.read().recoveries)[0].total;f.begin();assert.equal(Object.values(f.read().recoveries)[0].total,before);
- const frontend=f.tool('Skill',{skill:'i3-frontend-ui-engineering'},'Frontend Skill successfully loaded');
- const official=f.tool('Skill',{skill:'antdv'},'Official Skill successfully loaded');
- const retry=f.tool('Write',{file_path:file,content:'fixture'},'written',()=>fs.writeFileSync(file,'fixture'));
- assert.equal(retry.decision.continue,true);assert.equal(fs.readFileSync(file,'utf8'),'fixture');
- const recovery=f.read().bindings[f.directory].recovery;assert.equal(recovery.status,'recovered');assert.equal(recovery.retry.toolCallId,retry.id);
- assert.deepEqual(recovery.invocations.map(item=>item.toolCallId).sort(),[frontend.id,official.id].sort());
- assert.equal(X.check(f.directory,'delivery',lib).status,'failed','Recovery is not business acceptance or a delivery receipt');
-});
-test('Stop asks for missing Skills twice, then reports blocked without an endless loop',t=>{
- const f=fixture(t,'codebuddy','project','CodeBuddyCLI');
- const input={file_path:path.join(f.directory,'app/src/Stopped.vue'),content:'fixture'};
- const attempted=f.request('Write',input);f.result(attempted,'Synthetic operation was not completed',true);
- for(let n=0;n<3;n++){
-  f.append({type:'assistant',message:{content:'已完成，可以交付 '+n}});
-  const answer=f.hook('Stop');
-  if(n<2)assert.equal(answer.feedback,true);else {assert.equal(answer.continue,true);assert.equal(answer.recovery.status,'blocked');}
- }
- f.append({type:'user',message:{content:'先分析，不改代码'}});
- const answer=f.tool('Write',{file_path:path.join(f.directory,'app/src/NoWrite.vue'),content:'no'});assert.equal(answer.decision.deny,true);assert.match(answer.decision.reason,/read-only/);
-});
-test('late successful Skills release writes after the reminder limit without granting delivery',t=>{
- const f=fixture(t,'codebuddy','project','CodeBuddyCLI');
- const file=path.join(f.directory,'app/src/AfterBudget.vue');
- for(let n=0;n<3;n++)assert.equal(f.tool('Write',{file_path:file,content:'fixture'}).decision.deny,true);
- assert.equal(fs.existsSync(file),false);assert.equal(f.read().bindings[f.directory].recovery.status,'blocked');
- f.tool('Skill',{skill:'i3-frontend-ui-engineering'});f.tool('Skill',{skill:'antdv'});
- const answer=f.tool('Write',{file_path:file,content:'fixture'},'written',()=>fs.writeFileSync(file,'fixture'));
- assert.notEqual(answer.decision.deny,true);assert.equal(fs.readFileSync(file,'utf8'),'fixture');assert.equal(f.read().bindings[f.directory].recovery.status,'recovered');
- assert.equal(f.read().bindings[f.directory].recovery.total,2,'Keep reminder counts as audit history');
- assert.equal(X.check(f.directory,'delivery',lib).status,'failed','Successful loading and writing do not replace browser acceptance');
-});
-test('a duplicated native callback does not spend recovery budget when the transcript grows',t=>{
- const f=fixture(t,'workbuddy','project',null),input={file_path:path.join(f.directory,'app/src/Duplicate.vue'),content:'fixture'};
- const id=f.request('Write',input);assert.equal(f.hook('PreToolUse','Write',input,id).deny,true);
- f.append({type:'assistant',message:{content:'native transcript metadata was persisted'}});
- assert.equal(f.hook('PreToolUse','Write',input,id).deny,true);
- assert.equal(Object.values(f.read().recoveries)[0].total,1);
-});
-test('stage recovery waits for its shared gate and the matching successful command result',t=>{
- const f=fixture(t,'codebuddy','project','CodeBuddyCLI');
- f.tool('Skill',{skill:'i3-frontend-ui-engineering'});f.tool('Skill',{skill:'antdv'});
- // This test covers the Hook/recovery boundary; execution-runtime tests exercise
- // the real shared predicate with genuine source/evidence fixtures separately.
- const original=X.check;t.after(()=>{X.check=original;});
- X.check=()=>({status:'failed',errors:['Synthetic implementation evidence missing']});
- const command=`node '${path.join(scripts,'native-pilot.cjs')}' build '${f.directory}'`;
- assert.equal(f.tool('Bash',{command}).decision.deny,true);
- X.check=()=>({status:'passed'});
- const file=path.join(f.directory,'app/src/Unrelated.vue');
- f.tool('Write',{file_path:file,content:'unrelated'},'written',()=>fs.writeFileSync(file,'unrelated'));
- assert.equal(f.read().bindings[f.directory].recovery.status,'required','An unrelated successful UI edit cannot resolve a stage failure');
- const retry=f.tool('Bash',{command},'successful native build command');
- const recovery=f.read().bindings[f.directory].recovery;
- assert.equal(recovery.status,'recovered');assert.equal(recovery.retry.toolCallId,retry.id);
- assert.equal(recovery.retry.kind,'stage');assert.equal(recovery.retry.stage,'implementation');assert.equal(recovery.retry.operation,'build');
-});

package/scripts/ui-prototype-codebuddy-hook-test.js

@@ -1,112 +0,0 @@
-'use strict';
-const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
-const test=require('node:test'),assert=require('node:assert/strict');
-const H=require(prototypeScripts+'/codebuddy-hook.cjs'),E=require(prototypeScripts+'/execution-evidence.cjs');
-test('only explicit implementation instructions release a user restriction in Chinese and English',()=>{
- const C=require(prototypeScripts+'/codebuddy-context.cjs');
- for(const prompt of ['继续实施当前原型','继续吧','那就按这版方案实施吧，先保存任务清单','请帮我生成原型','continue','Please resume implementation'])assert.equal(C.userRestriction(prompt),false,prompt);
- for(const prompt of ['你调用了哪三个skill','继续实施需要哪些技能？','继续解释错误','继续原型方案讨论','continue the prototype discussion','resume the prototype analysis','What skills did you use?'])assert.equal(C.userRestriction(prompt),null,prompt);
- for(const prompt of ['先分析，不改代码','暂停当前原型实施','cancel current implementation'])assert.equal(C.userRestriction(prompt),true,prompt);
-});
-test('native command parsing handles quoted paths without evaluating shell substitutions or chains',()=>{
- const c=H.nativeCommand('Bash',{command:"'/node path/node' '/skills path/native-pilot.cjs' execution-begin '/work/prototypes/a b'"},'/work');
- assert.equal(c.root,'/work/prototypes/a b');assert.equal(c.operation,'execution-begin');
- for(const command of ['node x; node native-pilot.cjs finalize /x','$(steal) native-pilot.cjs build /x','node x | node native-pilot.cjs finalize /x'])assert.equal(H.nativeCommand('Bash',{command},'/work'),null);
-});
-test('before UI write requires a successful frontend Skill in the same live context and task',()=>{
- const source={prompts:[{line:1,text:'create prototype'}],calls:[],contextLine:0},binding={entryLine:1,contextLine:0,sessionId:'s1',runId:'r1',directory:'/work/prototypes/p',project:'/work'};
- const input={event:'PreToolUse',source,binding,tool:'Write',input:{file_path:'/work/prototypes/p/app/src/A.vue'},directory:'/work/prototypes/p'};
- assert.equal(H.decision(input).deny,true);
- source.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:true},{name:'Bash',input:{command:'node /skills/native-pilot.cjs execution-begin /work/prototypes/p'},sessionId:'s1',result:{status:'bound',runId:'r1',sessionId:'s1',directory:binding.directory},requestLine:4,resultLine:5,success:true}];assert.equal(H.decision(input).continue,true);
- source.contextLine=4;assert.equal(H.decision(input).deny,true);
-});
-test('analysis overrides old tasks and Stop feedback is bounded without granting tool permissions',()=>{
- const source={prompts:[{line:1,text:'先分析，不改代码'}],calls:[],contextLine:0};
- assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false}).feedback,undefined);
- source.prompts[0].text='implement prototype';
- source.latestAssistant='已完成，可以交付';
- assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false}).feedback,true);
- assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:false,stopHookActive:true}).continue,true);
- assert.equal(H.decision({event:'Stop',source,binding:{},deliveryCurrent:true}).continue,true);
- assert.equal(JSON.stringify(H.decision({event:'PreToolUse',source,tool:'Read',directory:'/p'})).includes('permissionDecision'),false);
-});
-test('native compact boundaries invalidate loads and mixed-session results are rejected',()=>{
- const rows=[{type:'user',sessionId:'s1',message:{content:'create prototype'}},{type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'f',name:'Skill',input:{skill:'i3-frontend-ui-engineering'}}]}},{type:'user',sessionId:'s2',message:{content:[{type:'tool_result',tool_use_id:'f',content:'loaded'}]}}];
- assert.throws(()=>E.parse(rows.map(r=>JSON.stringify(r)).join('\n')),/session/);
- rows[2].sessionId='s1';rows.push({type:'system',subtype:'compact_boundary'});
- assert.equal(E.describe(rows.map(r=>JSON.stringify(r)).join('\n')).contextLine,4);
-});
-test('effective binding differs by IDE override and CLI merge without writing any settings',()=>{
- const C=require(prototypeScripts+'/codebuddy-context.cjs'),path=require('node:path');
- const texts=new Map(),records=new Map(),project='/work/p',home='/home/user',projectBase=path.join(project,'.codebuddy'),globalBase=path.join(home,'.codebuddy');
- const args={project,home,env:{},readText:file=>texts.get(file)||null,loadRegistration:base=>records.get(base)||null};
- records.set(globalBase,{base:globalBase,product:'ide'});texts.set(path.join(projectBase,'settings.json'),'{}');
- assert.equal(C.select({...args,product:'ide'}),null,'IDE cannot fall back through shadowing project settings');
- records.set(globalBase,{base:globalBase,product:'cli'});assert.equal(C.select({...args,product:'cli'}).base,globalBase);
- records.set(projectBase,{base:projectBase,product:'cli'});assert.equal(C.select({...args,product:'cli'}).base,projectBase);
- texts.set(path.join(projectBase,'settings.local.json'),'{"hooks":{}}');assert.throws(()=>C.select({...args,product:'cli'}),/overrides/);
- assert.notEqual(C.projectKey('/work/p'),C.projectKey('/other/p'));
-});
-test('read-only intent does not confuse business pause buttons with cancelling implementation',()=>{
- const C=require(prototypeScripts+'/codebuddy-context.cjs');
- assert.equal(C.readOnly('先分析，不改代码'),true);assert.equal(C.readOnly('先检查再实现原型'),false);
- assert.equal(C.readOnly('增加暂停按钮，不改业务逻辑'),false);assert.equal(C.readOnly('暂停当前修改'),true);
-});
-test('a Hook payload must resolve to the actual current native request rather than a model-written begin',()=>{
- const source={prompts:[{line:1,text:'create prototype'}],calls:[{name:'Bash',toolCallId:'native-begin',input:{command:'node native-pilot.cjs execution-begin /p'},requestLine:3}]};
- const payload={hook_event_name:'PreToolUse',tool_name:'Bash',tool_input:{command:'node native-pilot.cjs execution-begin /p'}};
- assert.equal(H.eventCall(payload,source).toolCallId,'native-begin');
- assert.throws(()=>H.eventCall({...payload,tool_input:{command:'fabricated begin'}},source),/uniquely/);
- source.calls[0].resultLine=4;assert.throws(()=>H.eventCall(payload,source),/uniquely/);
-});
-test('project-scope callbacks use their registered root when tools run in a subdirectory',()=>{
- const payload={cwd:'/business/p/src'},real=p=>p;
- assert.equal(H.safeProject(payload,{scope:'project',base:'/business/p/.codebuddy'},{},real),'/business/p');
- assert.equal(H.safeProject(payload,{scope:'global',base:'/custom/codebuddy'},{CODEBUDDY_PROJECT_DIR:'/business/p'},real),'/business/p');
- assert.equal(H.safeProject({hook_event_name:'SessionStart'},{scope:'global',base:'/custom/codebuddy'},{},real,'/business/p'),'/business/p');
- assert.throws(()=>H.safeProject({cwd:'/other'},{scope:'project',base:'/business/p/.codebuddy'},{},real),/outside/);
-});
-test('the frontend gate blocks project-relative native Write calls before any run binding',()=>{
- const result=H.decision({event:'PreToolUse',source:{prompts:[{line:1,text:'实现原型'}],calls:[],contextLine:0},tool:'Write',input:{file_path:'prototypes/p/app/src/Probe.vue'},directory:'/work/prototypes/p',cwd:'/work'});
- assert.equal(result.deny,true);assert.match(result.reason,/frontend/);
- const ide=H.decision({event:'PreToolUse',source:{prompts:[{line:1,text:'实现原型'}],calls:[],contextLine:0},tool:'Write',input:{filePath:'/work/prototypes/p/app/src/Probe.vue'},directory:'/work/prototypes/p',cwd:'/work'});
- assert.equal(ide.deny,true);
-});
-test('IDE streaming requests correlate only within the exact native generation and unique call',()=>{
- const source={format:'codebuddy-ide-index-v1',prompts:[{line:1}],calls:[{name:'Write',toolCallId:'actual-ide-call',nativeRequestId:'generation-1',input:{content:'<template>'},requestLine:2}]};
- const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'generation-1',tool_name:'Write',tool_input:{filePath:'/work/p/app/src/A.vue',content:'<template><p>A</p></template>'}};
- assert.equal(H.eventCall(payload,source).toolCallId,'actual-ide-call');
- assert.throws(()=>H.eventCall({...payload,generation_id:'other'},source),/uniquely/);
- assert.throws(()=>H.eventCall({...payload,client:'other'},source),/uniquely/);
- assert.throws(()=>H.eventCall({...payload,tool_input:{content:'unrelated'}},source),/uniquely/);
- source.calls.push({...source.calls[0],toolCallId:'second-call'});assert.throws(()=>H.eventCall(payload,source),/uniquely/);
-});
-test('IDE and CLI transient reads retry within a fixed limit; wrong generations and requests remain rejected',()=>{
- const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'g1',tool_name:'Write',tool_input:{content:'ui'}};
- const pending={format:'codebuddy-ide-index-v1',prompts:[{line:1,nativeRequestId:'g1'}],calls:[{name:'Write',toolCallId:'w1',nativeRequestId:'g1',input:{content:'ui'},requestLine:2}]};
- let reads=0,waits=0;
- const readSource=()=>{if(++reads<3)throw new Error('native index write in progress');return pending;};
- const result=H.eventSource(payload,{product:'ide'},'/work',{readSource,pause:ms=>{assert.equal(ms,100);waits++;}});
- assert.equal(result.calls[0].toolCallId,'w1');assert.equal(result.nativeReadAttempts,3);assert.equal(waits,2);
- reads=0;assert.throws(()=>H.eventSource({...payload,generation_id:'g2'},{product:'ide'},'/work',{readSource:()=>{reads++;return pending;},pause:()=>{}}),/generation/);assert.equal(reads,8);
- assert.throws(()=>H.eventSource({...payload,tool_input:{content:'different'}},{product:'ide'},'/work',{readSource:()=>pending,pause:()=>{}}),/uniquely/);
- reads=0;assert.throws(()=>H.eventSource({...payload,client:'cli'},{product:'cli'},'/work',{readSource:()=>{reads++;return {...pending,calls:[]};},pause:()=>{}}),/uniquely/);assert.equal(reads,8);
-});
-test('IDE defers current callback evidence until the host persists it and never invents Skill success',()=>{
- const source={format:'codebuddy-ide-index-v1',prompts:[{line:1,nativeRequestId:'g1',text:'implement prototype'}],calls:[],contextLine:0};
- const payload={hook_event_name:'PreToolUse',client:'CodeBuddyIDE',generation_id:'g1',tool_name:'Write',tool_input:{filePath:'/work/prototypes/p/app/src/A.vue'}};
- const result=H.eventSource(payload,{product:'ide'},'/work',{readSource:()=>source});
- assert.equal(result.nativeRequestStatus,'deferred-until-native-persistence');assert.deepEqual(result.calls,[]);
- assert.equal(H.decision({event:'PreToolUse',source:result,binding:{entryLine:1,contextLine:0,sessionId:'s1'},tool:'Write',input:payload.tool_input,directory:'/work/prototypes/p'}).deny,true);
- assert.throws(()=>E.reference(result.calls,{toolCallId:'made-up'}),/Successful native/);
- assert.throws(()=>H.eventSource(payload,{product:'ide'},'/work',{readSource:()=>({...source,prompts:[{line:1,nativeRequestId:'old'}]}),pause:()=>{}}),/generation/);
-});
-test('only the observed project IDE root-cwd sentinel is mapped to the registered project',()=>{
- const options={scope:'project',base:'/business/p/.codebuddy',product:'ide'},payload={cwd:'/',client:'CodeBuddyIDE'};
- assert.equal(H.safeProject(payload,options,{},p=>p),'/business/p');
- assert.throws(()=>H.safeProject({...payload,cwd:'/other'},options,{},p=>p),/outside/);
- assert.throws(()=>H.safeProject(payload,{...options,product:'cli'},{},p=>p),/outside/);
- assert.equal(H.safeProject({...payload,transcript_path:'/native/index.json',session_id:'s1'},{scope:'global',product:'ide'},{},p=>p,'/ignored',(file,session)=>{assert.equal(file,'/native/index.json');assert.equal(session,'s1');return '/business/p';}),'/business/p');
- const cwd=H.toolCwd(payload,{product:'ide'},'/business/p');assert.equal(cwd,'/business/p');
- assert.equal(H.nativeCommand('Bash',{command:'node /skills/native-pilot.cjs execution-begin prototypes/p'},cwd).root,'/business/p/prototypes/p');
-});

package/scripts/ui-prototype-content-test.js

@@ -1,123 +0,0 @@
-'use strict';
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const installation = path.join(__dirname, 'lib/installation.js');
-const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
-const root = path.join(skills, 'i3-ui-prototype');
-const contract = require(path.join(root, 'scripts/template-contract.cjs'));
-const native = require(path.join(root, 'scripts/native-pilot-lib.cjs'));
-const read = (directory, file) => JSON.parse(fs.readFileSync(path.join(directory, file), 'utf8'));
-const write = (directory, file, data) => fs.writeFileSync(path.join(directory, file), JSON.stringify(data, null, 2));
-const files = directory => Object.fromEntries(fs.readdirSync(directory, { recursive: true }).filter(file => fs.statSync(path.join(directory, file)).isFile()).sort().map(file => [file, crypto.createHash('sha256').update(fs.readFileSync(path.join(directory, file))).digest('hex')]));
-function fixture(t, { prepare = true } = {}) {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-full-content-'));
-  t.after(() => fs.rmSync(project, { recursive: true, force: true }));
-  const template = prepare ? contract.prepareTemplate({ project }) : null;
-  const scope = { schemaVersion: 1, title: '资产审核', pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page',
-    regions: [{ id: 'list', mode: 'management-list' }, { id: 'editor', mode: 'edit-form' }] }],
-    requirements: [{ id: 'ASSET-01', text: '查询、选择和修改资产', pages: ['assets'], source: { type: 'prd', reference: 'PRD.md#ASSET-01', statement: '按资产字段实现清单与编辑；使用模板通用能力约定。' } }], exemptions: [] };
-  write(project, 'scope.json', scope);
-  const create = options => native.createPrototype({ project, id: 'assets', expertMode: 'template', scope: path.join(project, 'scope.json'), ...(template ? { templateRoot: template.directory } : {}), ...options });
-  return { project, template, scope, create };
-}
-test('explicit legacy preparation uses the complete offline reference and never overwrites a working copy', t => {
-  const { project, template } = fixture(t);
-  const snapshot = contract.loadTemplate(template.directory);
-  assert.equal(snapshot.kind, 'content-reference'); assert.equal(snapshot.id, 'enterprise-admin');
-  assert.equal(snapshot.index.pages.length, 35); assert.equal(snapshot.index.routes.length, 44); assert.equal(snapshot.index.htmlFragments.length, 93);
-  assert.deepEqual(Object.keys(snapshot.index.extractor.files).sort(), ['content-template.cjs', 'template-contract.cjs']);
-  const file = path.join(template.directory, 'index.html');
-  fs.writeFileSync(file, fs.readFileSync(file, 'utf8').replace('<h1>模型管理</h1>', '<h1>资产参考内容</h1>'));
-  assert.throws(() => contract.loadTemplate(template.directory), /stale|不同步/);
-  const index = contract.syncTemplate(template.directory);
-  assert.equal(index.pages.find(page => page.id === 'models-page').title, '资产参考内容');
-  const content = require(path.join(root, 'scripts/content-template.cjs')).pageContent(contract.loadTemplate(template.directory), 'models-page');
-  assert.ok(content.html.includes('<h1>资产参考内容</h1>')); assert.equal(content.readOnly, true);
-  assert.equal(contract.prepareTemplate({ project }).created, false);
-  assert.ok(fs.readFileSync(file, 'utf8').includes('资产参考内容'));
-});
-test('default creation reads the released template without preparing a business template directory or modifying Skill assets', t => {
-  const { project, create } = fixture(t, { prepare: false });
-  const builtin = path.join(root, 'assets/templates/enterprise-admin');
-  const before = files(builtin);
-  const created = create();
-  assert.equal(fs.existsSync(path.join(project, 'ui-templates')), false);
-  assert.equal(fs.existsSync(path.join(project, '.prototype-preparation')), false);
-  assert.deepEqual(files(builtin), before);
-  assert.equal(native.inspect(created.directory).status, 'passed');
-  const snapshot = read(created.directory, 'inputs/template-snapshot.json');
-  assert.equal(snapshot.id, 'enterprise-admin'); assert.equal(snapshot.index.pages.length, 35);
-  assert.deepEqual(snapshot, contract.loadBundledTemplate());
-  assert.deepEqual(read(created.directory, 'inputs/scope.json'), read(project, 'scope.json'));
-});
-test('an existing edited template copy is preserved and used only when explicitly selected', t => {
-  const { project, template, create } = fixture(t);
-  const entry = path.join(template.directory, 'index.html');
-  fs.writeFileSync(entry, fs.readFileSync(entry, 'utf8').replace('<h1>模型管理</h1>', '<h1>用户维护的旧模板</h1>'));
-  contract.syncTemplate(template.directory);
-  const before = files(template.directory);
-  const current = create({ id: 'current', templateRoot: undefined });
-  const legacy = create({ id: 'legacy' });
-  assert.notEqual(read(current.directory, 'inputs/template-snapshot.json').digest, read(legacy.directory, 'inputs/template-snapshot.json').digest);
-  assert.equal(read(legacy.directory, 'inputs/template-snapshot.json').index.pages.find(page => page.id === 'models-page').title, '用户维护的旧模板');
-  assert.deepEqual(files(template.directory), before);
-});
-test('new business generation requires a sourced scope and does not silently generate a device list', t => {
-  const { project, create } = fixture(t);
-  assert.throws(() => create({ scope: undefined }), /scope|需求/i);
-  assert.equal(fs.existsSync(path.join(project, 'prototypes')), false);
-  const created = create(), meta = read(created.directory, 'prototype.json');
-  assert.equal(meta.runtime.contentReference, true); assert.equal(meta.business.status, 'needs-adaptation');
-  assert.equal(native.inspect(created.directory).status, 'passed');
-  assert.match(native.inspect(created.directory, { acceptance: true }).errors.join('; '), /implementation pending|scaffold/);
-  const config = read(created.directory, 'app/public/prototype-config.json');
-  assert.deepEqual(config.pages, [{ id: 'assets', title: '资产台账' }]);
-  assert.deepEqual(config.theme, { defaultTheme: 'light', presets: ['light', 'dark', 'fresh', 'tech'] });
-  assert.equal(config.content, undefined); assert.equal(read(created.directory, 'mocks/contract.json').count, undefined);
-  assert.equal(fs.existsSync(path.join(created.directory, 'app/src/domain/devices.ts')), false);
-  const state = native.state(created.directory, {});
-  assert.equal(state.nextAction, 'implement-business'); assert.equal(state.commands.browser, undefined); assert.ok(state.commands.recordRun);
-});
-test('the complete content reference yields fixed common capabilities for the selected business regions', t => {
-  const { create } = fixture(t), directory = create().directory;
-  const fixed = read(directory, 'inputs/capabilities.json'), acceptance = read(directory, 'inputs/acceptance.json');
-  for (const id of ['filter', 'selection', 'pagination', 'bulk', 'feedback']) assert.ok(fixed.bindings.some(binding => binding.id === `assets/list/${id}`));
-  assert.ok(fixed.bindings.some(binding => binding.id === 'assets/editor/edit'));
-  assert.ok(fixed.bindings.some(binding => binding.id === 'app-shell/appearance/theme'));
-  assert.ok(acceptance.requiredScenarios.includes('assets/list/pagination/pages'));
-  assert.ok(acceptance.requiredScenarios.includes('app-shell/appearance/theme/persistence'));
-  assert.equal(acceptance.requiredScenarios.some(id => id.startsWith('devices/')), false);
-  fixed.bindings = fixed.bindings.filter(binding => binding.capabilityId !== 'selection'); write(directory, 'inputs/capabilities.json', fixed);
-  const candidate = native.manifest(directory);
-  assert.throws(() => native.revise(directory, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true }), /binding|capabilit|合同/i);
-});
-test('business page and requirement references must remain explicit and unambiguous', t => {
-  const { project, scope, create } = fixture(t);
-  for (const modify of [
-    value => { value.pages[0].referencePage = 'missing-page'; },
-    value => { value.pages.push(structuredClone(value.pages[0])); },
-    value => { value.requirements.push(structuredClone(value.requirements[0])); },
-    value => { value.requirements[0].source = {}; },
-    value => { value.requirements[0].pages = ['other-business']; },
-    value => { value.pages[0].regions[0].mode = 'unknown-mode'; },
-  ]) {
-    const broken = structuredClone(scope); modify(broken); write(project, 'scope.json', broken);
-    assert.throws(() => create()); assert.equal(fs.existsSync(path.join(project, 'prototypes')), false);
-  }
-});
-test('offline reference synchronization rejects missing runtime resources and module loading', t => {
-  const { template } = fixture(t), file = path.join(template.directory, 'index.html'), html = fs.readFileSync(file, 'utf8');
-  fs.writeFileSync(file, html.replace('src="offline.js"', 'src="missing.js"')); assert.throws(() => contract.syncTemplate(template.directory), /resource missing/);
-  fs.writeFileSync(file, html.replace('<script src="offline.js"', '<script type="module" src="offline.js"')); assert.throws(() => contract.syncTemplate(template.directory), /modules/);
-  fs.writeFileSync(file, html); fs.appendFileSync(path.join(template.directory, 'offline.js'), '\nfetch("parts.html")'); assert.throws(() => contract.syncTemplate(template.directory), /Offline runtime/);
-});
-test('the historical device regression runner refuses a business contract before writing evidence', async t => {
-  const { create } = fixture(t), directory = create().directory;
-  const before = fs.readdirSync(path.join(directory, 'qa'));
-  await assert.rejects(require(path.join(root, 'scripts/native-browser.cjs')).main(directory), /historical device-list/);
-  assert.deepEqual(fs.readdirSync(path.join(directory, 'qa')), before);
-});