@givolt/i3-composer-agent 2.3.1 → 2.3.3

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

@@ -0,0 +1,504 @@
+'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 legacyFixture = require('./lib/prototype-fixture.cjs');
+const installationFile = path.join(__dirname, 'lib/installation.js');
+const skillsDirectory = fs.existsSync(installationFile) ? require(installationFile).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const lib = require(path.join(skillsDirectory, 'i3-ui-prototype/scripts/native-pilot-lib.cjs'));
+function project(t) { const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'native-prototype-')); t.after(() => fs.rmSync(dir, { recursive:true, force:true })); return dir; }
+test('analysis is read-only even if no prototype exists', t => {
+  const dir=project(t); const before=fs.readdirSync(dir);
+  assert.equal(lib.analyze({project:dir}).operation,'analyze');
+  assert.deepEqual(fs.readdirSync(dir),before);
+});
+test('theme requires a sourced optional capability and fixes its generated configuration and acceptance', t => {
+  const dir=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir}),contract=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs'));
+  const plain=lib.createPrototype({project:dir,id:'plain',templateRoot:template.directory,expertMode:'template'}).directory;
+  assert.equal(JSON.parse(fs.readFileSync(path.join(plain,'app/public/prototype-config.json'))).theme,undefined);
+  const plainBefore=lib.manifest(plain),plainAcceptance=JSON.parse(fs.readFileSync(path.join(plain,'inputs/acceptance.json')));
+  assert.equal(plainAcceptance.requiredScenarios.length+plainAcceptance.frameworkScenarios.length,20);
+  const file=path.join(template.directory,'index.html');fs.writeFileSync(file,fs.readFileSync(file,'utf8').replace(/<!-- OPTIONAL_FOUR_THEMES:[\s\S]*?(<aside[\s\S]*?<\/aside>)\s*-->/,'$1'));contract.syncTemplate(template.directory);
+  assert.throws(()=>lib.createPrototype({project:dir,id:'unsourced-theme',templateRoot:template.directory,expertMode:'template'}),/theme.*source|主题.*来源/i);
+  const scope={schemaVersion:1,requirements:[{id:'THEME-1',text:'四种命名主题，默认明亮',source:{type:'user',reference:'theme-request',statement:'明亮、暗黑、清新、科技'},capabilities:[{pageId:'devices',regionId:'device-list',capabilityId:'theme'}]}],exemptions:[]};
+  write(dir,'scope.json',scope);
+  const themed=lib.createPrototype({project:dir,id:'themed',templateRoot:template.directory,expertMode:'template',scope:path.join(dir,'scope.json')}).directory;
+  const config=JSON.parse(fs.readFileSync(path.join(themed,'app/public/prototype-config.json')));
+  assert.deepEqual(config.theme,{defaultTheme:'light',presets:['light','dark','fresh','tech']});
+  const browser=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-browser.cjs'));
+  assert.deepEqual(browser.themePlan(themed),{source:'inputs/capabilities.json',bindingId:'devices/device-list/theme',defaultTheme:'light',presets:['light','dark','fresh','tech']});
+  assert.equal(browser.themePlan(plain),null);
+  assert.equal(lib.inspect(themed).status,'passed');
+  const themedAcceptance=JSON.parse(fs.readFileSync(path.join(themed,'inputs/acceptance.json')));
+  assert.equal(themedAcceptance.requiredScenarios.filter(id=>id.includes('/theme/')).length,3);
+  assert.equal(themedAcceptance.requiredScenarios.length+themedAcceptance.frameworkScenarios.length,23);
+  assert.deepEqual(themedAcceptance.requiredScenarios.filter(id=>!id.includes('/theme/')),plainAcceptance.requiredScenarios,'The four-theme opt-in cannot remove baseline scenarios');
+  assert.deepEqual(themedAcceptance.browserReview.observations,['dom','screenshot','console','network','accessibility','performance']);
+  assert.equal(lib.manifest(plain).digest,plainBefore.digest,'New theme inputs must not mutate an existing unbound instance');
+  assert.equal(lib.inspect(plain).status,'passed');
+  config.theme.defaultTheme='dark';write(themed,'app/public/prototype-config.json',config);assert.equal(lib.inspect(themed).status,'failed','runtime configuration cannot override the fixed binding');
+});
+test('analysis leaves host execution unverified unless explicitly declared and rejects invalid modes without writes', t => {
+  const dir=project(t),before=fs.readdirSync(dir);
+  const unknown=lib.analyze({project:dir});
+  assert.equal(unknown.execution,null,'the script cannot infer independent host invocation');
+  assert.equal(unknown.executionEvidence,'unverified');
+  for(const execution of ['inline','delegated']) {
+    const result=lib.analyze({project:dir,execution});
+    assert.equal(result.execution,execution);assert.equal(result.executionEvidence,'caller-declared');
+    assert.equal(result.readOnly,true);assert.deepEqual(result.sideEffects,[]);
+  }
+  for(const execution of ['agent',true,null,''])assert.throws(()=>lib.analyze({project:dir,execution}),/execution|inline|delegated/);
+  assert.deepEqual(fs.readdirSync(dir),before);
+});
+test('new fixed content projection acceptance cannot be dropped while legacy inputs retain their original list', t => {
+  const dir=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const root=lib.createPrototype({project:dir,id:'projection-guard',templateRoot:template.directory,expertMode:'template'}).directory;
+  const acceptance=JSON.parse(fs.readFileSync(path.join(root,'inputs/acceptance.json'))),framework=JSON.parse(fs.readFileSync(path.join(root,'inputs/framework.json')));
+  acceptance.frameworkScenarios=acceptance.frameworkScenarios.filter(id=>id!=='template-content-projection');write(root,'inputs/acceptance.json',acceptance);
+  let current=lib.manifest(root);
+  assert.throws(()=>lib.revise(root,{revision:'r002',expectedRevision:'r001',expectedDigest:current.digest,acceptInputs:true}),/template-content-projection/);
+  framework.acceptance.scenarios=framework.acceptance.scenarios.filter(scenario=>scenario.id!=='template-content-projection');write(root,'inputs/framework.json',framework);
+  current=lib.manifest(root);
+  lib.revise(root,{revision:'r002',expectedRevision:'r001',expectedDigest:current.digest,acceptInputs:true});
+  assert.equal(lib.inspect(root).status,'passed','An older fixed framework snapshot is not implicitly given a new scenario');
+});
+test('browser pagination expectations come from fixed instance bindings and retain legacy fixed semantics', t => {
+  const dir=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const browser=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-browser.cjs'));
+  const fixed=lib.createPrototype({project:dir,id:'fixed-devices',templateRoot:template.directory,expertMode:'template'}).directory;
+  assert.deepEqual(browser.paginationPlan(fixed),{source:'inputs/capabilities.json',bindingId:'devices/device-list/pagination',mode:'fixed',defaultPageSize:10,pageSizeOptions:[10]});
+  const html=path.join(template.directory,'index.html');
+  fs.writeFileSync(html,fs.readFileSync(html,'utf8').replace('"fixedPageSize":10,"minimumTestPages":3','"mode":"adjustable","defaultPageSize":10,"pageSizeOptions":[10,20,50],"minimumTestPages":3'));
+  require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')).syncTemplate(template.directory);
+  const adjustable=lib.createPrototype({project:dir,id:'adjustable-devices',templateRoot:template.directory,expertMode:'template'}).directory;
+  assert.equal(lib.inspect(adjustable).status,'passed');
+  const config=path.join(adjustable,'app/public/prototype-config.json'),data=JSON.parse(fs.readFileSync(config));
+  data.pagination={mode:'fixed',fixedPageSize:99};fs.writeFileSync(config,JSON.stringify(data));
+  assert.deepEqual(browser.paginationPlan(adjustable),{source:'inputs/capabilities.json',bindingId:'devices/device-list/pagination',mode:'adjustable',defaultPageSize:10,pageSizeOptions:[10,20,50]},'page runtime self-report cannot change the acceptance contract');
+});
+test('pagination focus regression is enabled only by the fixed framework snapshot', t => {
+  const dir=project(t),browser=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-browser.cjs'));
+  write(dir,'inputs/framework.json',{acceptance:{paginationFocusGuard:true}});assert.equal(browser.paginationFocusPlan(dir),true);
+  write(dir,'inputs/framework.json',{acceptance:{}});assert.equal(browser.paginationFocusPlan(dir),false,'Legacy snapshots do not gain a new guard');
+  for(const value of [false,'true',1]){write(dir,'inputs/framework.json',{acceptance:{paginationFocusGuard:value}});assert.throws(()=>browser.paginationFocusPlan(dir),/focus guard/);}
+});
+test('native candidate fixes inputs and excludes runtime progress from its identity', t => {
+  const dir=project(t); const template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const created=lib.createPrototype({project:dir,id:'devices',templateRoot:template.directory,expertMode:'template'});
+  assert.equal(created.status,'created'); const candidate=lib.manifest(created.directory);
+  assert.equal(lib.inspect(created.directory).status,'passed');
+  fs.writeFileSync(path.join(created.directory,'execution.json'),JSON.stringify({owner:'other-progress',status:'running'}));
+  fs.mkdirSync(path.join(created.directory,'qa'),{recursive:true}); fs.writeFileSync(path.join(created.directory,'qa','progress.log'),'testing');
+  assert.equal(lib.manifest(created.directory).digest,candidate.digest);
+  fs.appendFileSync(path.join(template.directory,'index.html'),'\n<!-- future template -->');
+  assert.equal(lib.manifest(created.directory).digest,candidate.digest);
+  fs.appendFileSync(path.join(created.directory,'app','src','App.vue'),'\n<!-- user change -->');
+  assert.notEqual(lib.manifest(created.directory).digest,candidate.digest);
+});
+test('a stale revision cannot overwrite a candidate and revise preserves actual source edits', t => {
+  const dir=project(t); const template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const created=lib.createPrototype({project:dir,id:'devices',templateRoot:template.directory,expertMode:'template'});
+  const initial=lib.manifest(created.directory);
+  fs.appendFileSync(path.join(created.directory,'app','src','App.vue'),'\n<!-- keep me -->');
+  assert.throws(()=>lib.revise(created.directory,{revision:'r002',expectedRevision:'r001',expectedDigest:initial.digest}),/changed|stale|冲突|变化/);
+  const current=lib.manifest(created.directory);
+  lib.revise(created.directory,{revision:'r002',expectedRevision:'r001',expectedDigest:current.digest});
+  assert.match(fs.readFileSync(path.join(created.directory,'app','src','App.vue'),'utf8'),/keep me/);
+  assert.equal(lib.manifest(created.directory).revision,'r002');
+});
+test('required capability deletion and input mutation cannot reuse the old contract', t => {
+  const dir=project(t); const template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const created=lib.createPrototype({project:dir,id:'devices',templateRoot:template.directory,expertMode:'template'});
+  const initial=lib.manifest(created.directory);
+  const file=path.join(created.directory,'inputs','capabilities.json'); const data=JSON.parse(fs.readFileSync(file));
+  data.bindings=data.bindings.filter(binding=>binding.capabilityId!=='pagination'); fs.writeFileSync(file,JSON.stringify(data));
+  assert.notEqual(lib.manifest(created.directory).digest,initial.digest);
+  assert.equal(lib.inspect(created.directory).status,'failed');
+});
+test('build manifests verify bytes, and a build for an old candidate is rejected', t => {
+  const dir=project(t); const template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:dir});
+  const created=lib.createPrototype({project:dir,id:'devices',templateRoot:template.directory,expertMode:'template'});
+  assert.equal(lib.inspect(created.directory,{acceptance:true}).status,'failed');
+  assert.throws(()=>lib.verifyBuild(created.directory,'missing'),/build|构建|ENOENT/);
+  assert.throws(()=>lib.confirmBaseline(created.directory,{revision:'r001',digest:lib.manifest(created.directory).digest}),/confirmation|确认|reviewer/);
+});
+
+// These are synthetic guard fixtures, never runtime or user-acceptance evidence.
+const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+function write(directory, relative, value) {
+  const file=path.join(directory,relative); fs.mkdirSync(path.dirname(file),{recursive:true});
+  fs.writeFileSync(file,Buffer.isBuffer(value)||typeof value==='string'?value:JSON.stringify(value));
+}
+function candidate(t) {
+  const root=project(t); const template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root});
+  return lib.createPrototype({project:root,id:'devices',templateRoot:template.directory,expertMode:'template'}).directory;
+}
+function syntheticBuild(directory,{embedded=true}={}) {
+  const current=lib.manifest(directory);
+  const bytes={
+    'index.html':Buffer.from('<!doctype html><script type="module" src="/assets/app.js"></script><link rel="stylesheet" href="/assets/app.css">'),
+    'assets/app.js':Buffer.from(`window.__PROTOTYPE_META__={candidateId:${JSON.stringify(embedded?current.digest:'previous-candidate')}};`),
+    'assets/app.css':Buffer.from('body{color:#123}'),
+    'prototype-config.json':fs.readFileSync(path.join(directory,'app/public/prototype-config.json')),
+  };
+  const files=Object.fromEntries(Object.entries(bytes).sort(([a],[b])=>a.localeCompare(b)).map(([name,value])=>[name,hash(value)]));
+  const buildDigest=hash(JSON.stringify(files)),buildId=`b-${buildDigest.slice(0,20)}`;
+  for(const [name,value]of Object.entries(bytes))write(directory,`builds/${buildId}/site/${name}`,value);
+  write(directory,`builds/${buildId}/manifest.json`,{schemaVersion:1,buildId,buildDigest,candidateDigest:current.digest,inputDigest:current.inputDigest,revision:current.revision,files,source:'synthetic-unit-fixture',checks:{typecheck:'synthetic contract fixture; not executed',test:'synthetic contract fixture; not executed',build:'synthetic contract fixture; not executed'}});
+  return {current,buildId,buildDigest,files};
+}
+function syntheticReport(directory,build=syntheticBuild(directory)) {
+  const png=Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=','base64');
+  write(directory,'qa/fixtures/a.png',png);write(directory,'qa/fixtures/b.png',png);
+  write(directory,'qa/fixtures/trace.zip',Buffer.concat([Buffer.from([0x50,0x4b,0x05,0x06]),Buffer.alloc(18)]));
+  const acceptance=JSON.parse(fs.readFileSync(path.join(directory,'inputs/acceptance.json')));
+  const previewBaseURL='http://127.0.0.1:4173/';
+  write(directory,'last-build.json',{buildId:build.buildId,buildDigest:build.buildDigest,candidateDigest:build.current.digest});
+  if(acceptance.browserReview){
+    const devtools=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-devtools.cjs')),observations={};
+    for(const kind of devtools.KINDS){const evidence=`qa/fixtures/devtools-${kind}.${kind==='screenshot'?'png':kind==='performance'?'json':'txt'}`;write(directory,evidence,kind==='screenshot'?png:kind==='performance'?{traceEvents:[{name:'synthetic-contract-fixture',ts:1}]}:`Synthetic ${kind} fixture; not executed`);observations[kind]={status:'passed',summary:'Synthetic guard fixture only; not actual browser acceptance',evidence};}
+    devtools.record(directory,{schemaVersion:1,status:'passed',revision:build.current.revision,candidateDigest:build.current.digest,buildId:build.buildId,buildDigest:build.buildDigest,executor:'synthetic-unit-fixture',startedAt:'2026-10-17T00:00:00.000Z',completedAt:'2026-10-17T00:00:01.000Z',previewBaseURL,skill:{name:acceptance.browserReview.skill,toolCallId:'synthetic-skill',evidence:'Synthetic fixture; no host invocation'},mcp:{name:'chrome-devtools-mcp',version:'1.11.0',evidence:'Synthetic fixture; no host invocation',calls:['evaluate_script','take_screenshot','list_console_messages','list_network_requests','take_snapshot','performance_start_trace','performance_stop_trace'].map((method,index)=>({tool:`mcp__chrome_devtools__${method}`,toolCallId:`synthetic-${index}`}))},observations,openItems:[]},lib);
+  }
+  return {id:'synthetic-guard-fixture',status:'passed',candidateDigest:build.current.digest,revision:build.current.revision,buildId:build.buildId,buildDigest:build.buildDigest,executor:'unit-fixture',tool:'unit-fixture',source:'synthetic-unit-fixture',startedAt:'2026-10-17T00:00:00.000Z',completedAt:'2026-10-17T00:00:01.000Z',consoleErrors:[],journeys:[...acceptance.requiredScenarios,...acceptance.frameworkScenarios].map(id=>({id,status:'passed'})),screenshots:['qa/fixtures/a.png','qa/fixtures/b.png'],trace:'qa/fixtures/trace.zip',viewports:[1440,768],previewBaseURL,observedResources:Object.entries(build.files).map(([name,sha256])=>({path:name,url:new URL(name==='index.html'?'':name,previewBaseURL).href,status:200,sha256,resourceType:name==='index.html'?'document':name.endsWith('.js')?'script':name.endsWith('.css')?'stylesheet':'fetch'}))};
+}
+
+test('new policy blocks finalization and human baseline when DevTools review is missing or stale',t=>{
+ const directory=candidate(t),report=syntheticReport(directory);lib.recordRun(directory,report);
+ const current=lib.manifest(directory),file=path.join(directory,'qa/devtools-review.json'),valid=fs.readFileSync(file);
+ fs.rmSync(file);assert.equal(lib.state(directory).nextAction,'devtools-review');assert.throws(()=>lib.finalize(directory),/DevTools review required/);
+ assert.throws(()=>lib.confirmBaseline(directory,{revision:current.revision,digest:current.digest,reviewer:'synthetic-fixture',statement:'Synthetic approval fixture only',source:'unit-test'}),/DevTools review required/);
+ assert.equal(fs.existsSync(path.join(directory,'qa/delivery.json')),false);fs.writeFileSync(file,valid);
+ const delivery=lib.finalize(directory);assert.equal(delivery.checks.devtoolsReview,'current');assert.equal(lib.state(directory).delivery.status,'current');
+ fs.appendFileSync(path.join(directory,'qa/fixtures/devtools-dom.txt'),'changed artifact');assert.equal(lib.state(directory).delivery.status,'stale');assert.throws(()=>lib.finalize(directory),/DevTools review required/);
+});
+
+test('old fixed inputs without browserReview retain their delivery contract',t=>{
+ const directory=candidate(t),acceptance=JSON.parse(fs.readFileSync(path.join(directory,'inputs/acceptance.json')));delete acceptance.browserReview;write(directory,'inputs/acceptance.json',acceptance);
+ const framework=JSON.parse(fs.readFileSync(path.join(directory,'inputs/framework.json')));delete framework.acceptance.browserReview;write(directory,'inputs/framework.json',framework);
+ const edited=lib.manifest(directory);lib.revise(directory,{revision:'r002',expectedRevision:edited.revision,expectedDigest:edited.digest,acceptInputs:true});
+ const report=syntheticReport(directory);lib.recordRun(directory,report);
+ assert.equal(lib.state(directory).devtoolsReview.status,'not-required');const result=lib.finalize(directory);assert.equal(result.status,'complete');assert.equal(result.devtoolsReview,undefined);
+});
+test('required DevTools policy cannot disappear from only the derived acceptance input',t=>{
+ const directory=candidate(t),acceptance=JSON.parse(fs.readFileSync(path.join(directory,'inputs/acceptance.json')));delete acceptance.browserReview;write(directory,'inputs/acceptance.json',acceptance);
+ const current=lib.manifest(directory);assert.throws(()=>lib.revise(directory,{revision:'r002',expectedRevision:current.revision,expectedDigest:current.digest,acceptInputs:true}),/DevTools|browser review/i);assert.equal(lib.manifest(directory).revision,'r001');
+});
+test('a finalized receipt becomes stale if its valid browser report bytes change',t=>{
+ const directory=candidate(t),report=syntheticReport(directory);lib.recordRun(directory,report);lib.finalize(directory);
+ const file=path.join(directory,'qa/runs',report.id,'report.json'),changed=JSON.parse(fs.readFileSync(file));changed.executor='different-synthetic-executor';write(directory,path.relative(directory,file),changed);
+ assert.equal(lib.state(directory).browser.status,'current','the edited report remains structurally valid');
+ assert.equal(lib.state(directory).delivery.status,'stale','the saved receipt binds the exact report bytes');
+});
+
+test('professional review requires recorded decisions and verifies adopted guidance; zero adoption remains valid', t => {
+  const directory=candidate(t),meta=JSON.parse(fs.readFileSync(path.join(directory,'prototype.json')));
+  meta.expertMode='professional';write(directory,'prototype.json',meta);
+  const query={query:'error summary validation',source:'synthetic-unit-provider',resultDigest:hash('fixture-result')};
+  const advice={provider:{availability:'available',digest:hash('provider')},queries:[query],records:[],status:'reviewed'};
+  write(directory,'qa/design-advice.json',advice);write(directory,'design-system/decisions.json',{reviewStatus:'reviewed',records:[]});
+  assert.equal(lib.inspect(directory,{acceptance:true,report:syntheticReport(directory)}).status,'failed','empty decisions must not pass as reviewed');
+  const rejected={query:query.query,resultIdentity:'fixture result',decision:'rejected',rationale:'Already covered by the native form contract',verification:'No additional implementation required'};
+  advice.records=[rejected];write(directory,'qa/design-advice.json',advice);
+  assert.equal(lib.inspect(directory,{acceptance:true,report:syntheticReport(directory)}).status,'failed','QA alone cannot change design decisions');
+  write(directory,'design-system/decisions.json',{reviewStatus:'reviewed',records:[rejected]});
+  assert.equal(lib.inspect(directory,{acceptance:true,report:syntheticReport(directory)}).status,'passed');
+  lib.recordRun(directory,syntheticReport(directory));
+  assert.equal(JSON.parse(fs.readFileSync(path.join(directory,'prototype.json'))).expert.status,'reviewed','zero adoption must remain reviewed after real report validation');
+  const adopted={...rejected,decision:'adopted',implementation:'app/src/App.vue'};
+  advice.records=[adopted];write(directory,'qa/design-advice.json',advice);write(directory,'design-system/decisions.json',{reviewStatus:'reviewed',records:[adopted]});
+  assert.equal(lib.inspect(directory,{acceptance:true,report:syntheticReport(directory)}).status,'failed','adoption needs a real verified scenario');
+});
+
+test('failed staging releases the project lock so a repaired directory can be retried', t => {
+  const root=project(t);legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root});
+  fs.writeFileSync(path.join(root,'prototypes'),'blocking file');
+  assert.throws(()=>lib.createPrototype({project:root,id:'devices',templateRoot:path.join(root,'ui-templates/admin-list'),expertMode:'template'}),/EEXIST/);
+  assert.equal(fs.existsSync(path.join(root,'.i3-ui-prototypes.lock')),false);
+  fs.rmSync(path.join(root,'prototypes'));
+  assert.equal(lib.createPrototype({project:root,id:'devices',templateRoot:path.join(root,'ui-templates/admin-list'),expertMode:'template'}).status,'created');
+});
+
+test('all source resources participate while only explicit root caches are excluded', t => {
+  const directory=candidate(t);
+  for(const relative of ['app/src/copy.log','app/src/dist/label.txt','app/public/coverage/text.txt'])write(directory,relative,'first');
+  const before=lib.manifest(directory);
+  for(const relative of ['app/src/copy.log','app/src/dist/label.txt','app/public/coverage/text.txt'])assert.ok(Object.hasOwn(before.files,relative),relative);
+  write(directory,'app/src/copy.log','changed');assert.notEqual(lib.manifest(directory).digest,before.digest);
+  const source=lib.manifest(directory).digest;
+  write(directory,'app/node_modules/fake.js','dependency cache');write(directory,'app/dist/output.js','build output');
+  assert.equal(lib.manifest(directory).digest,source);
+});
+
+test('requirements map references actual pages and rejects unknown page identities', t => {
+  const directory=candidate(t),file=path.join(directory,'requirements-map.json');
+  const map=JSON.parse(fs.readFileSync(file));
+  assert.deepEqual(map.requirements[0].pages,['devices']);
+  map.requirements[0].pages=['missing-page'];fs.writeFileSync(file,JSON.stringify(map));
+  assert.equal(lib.inspect(directory).status,'failed');
+});
+
+test('a build claiming current metadata must actually embed its candidate identity in JavaScript', t => {
+  const directory=candidate(t),build=syntheticBuild(directory,{embedded:false});
+  assert.throws(()=>lib.verifyBuild(directory,build.buildId),/embed|candidate|identity|标识/);
+});
+
+test('browser guard rejects missing, stale or mismatched resource observations before publishing', t => {
+  const directory=candidate(t),report=syntheticReport(directory);
+  assert.equal(lib.inspect(directory,{acceptance:true,report}).status,'passed');
+  lib.recordRun(directory,report);
+  const latest=fs.readFileSync(path.join(directory,'qa/latest.json'),'utf8');
+  const badReports=[
+    {...report,id:'missing-observations',observedResources:[]},
+    {...report,id:'missing-stylesheet',observedResources:report.observedResources.filter(entry=>!entry.path.endsWith('.css'))},
+    {...report,id:'wrong-bytes',observedResources:report.observedResources.map((entry,index)=>index?entry:{...entry,sha256:'0'.repeat(64)})},
+    {...report,id:'other-server',observedResources:report.observedResources.map(entry=>({...entry,url:entry.url.replace(':4173',':9999')}))},
+    {...report,id:'bad-status',observedResources:report.observedResources.map(entry=>({...entry,status:304}))},
+    {...report,id:'wrong-request-type',observedResources:report.observedResources.map(entry=>entry.path.endsWith('.js')?{...entry,resourceType:'fetch'}:entry)},
+    {...report,id:'bad-time',startedAt:'invented'},
+  ];
+  for(const bad of badReports){assert.throws(()=>lib.recordRun(directory,bad));assert.equal(fs.readFileSync(path.join(directory,'qa/latest.json'),'utf8'),latest);assert.equal(fs.existsSync(path.join(directory,`qa/runs/${bad.id}/report.json`)),false);}
+});
+
+test('nonempty text is refused as PNG or trace evidence', t => {
+  const directory=candidate(t),report=syntheticReport(directory);
+  fs.writeFileSync(path.join(directory,report.screenshots[0]),'not a PNG');
+  assert.throws(()=>lib.recordRun(directory,report),/PNG|screenshot/);
+  const valid=syntheticReport(directory);
+  fs.writeFileSync(path.join(directory,valid.trace),'not a ZIP');
+  assert.throws(()=>lib.recordRun(directory,valid),/ZIP|trace/);
+});
+
+test('failed baseline staging leaves no partial revision and can be retried', t => {
+  const directory=candidate(t),report=syntheticReport(directory);lib.recordRun(directory,report);
+  const current=lib.manifest(directory),confirmation={revision:current.revision,digest:current.digest,reviewer:'synthetic-fixture',statement:'Synthetic unit test only; not actual human acceptance',source:'unit-test'};
+  const original=fs.copyFileSync;
+  try{fs.copyFileSync=()=>{throw new Error('simulated copy failure');};assert.throws(()=>lib.confirmBaseline(directory,confirmation),/simulated copy failure/);}finally{fs.copyFileSync=original;}
+  assert.equal(fs.existsSync(path.join(directory,'baselines/r001')),false);
+  assert.equal(lib.confirmBaseline(directory,confirmation).digest,current.digest);
+  assert.equal(lib.compareBaseline(directory).status,'unchanged');
+});
+
+test('editing and syncing HTML projects supported content into new prototypes without mutating old ones', t => {
+  const root=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root});
+  const first=lib.createPrototype({project:root,id:'first',templateRoot:template.directory,expertMode:'template'});
+  const configFile=path.join(first.directory,'app/public/prototype-config.json');
+  const original=fs.readFileSync(configFile,'utf8');
+  assert.equal(JSON.parse(original).content.fields.name.label,'设备名称');
+  const htmlFile=path.join(template.directory,'index.html');
+  fs.writeFileSync(htmlFile,fs.readFileSync(htmlFile,'utf8')
+    .replace('<h1>设备管理</h1>','<h1>资产台账</h1>')
+    .replace('data-field-id="device-name">设备名称','data-field-id="device-name">资产名称')
+    .replace('data-action-id="query" type="button">查询','data-action-id="query" type="button">检索'));
+  require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')).syncTemplate(template.directory);
+  const second=lib.createPrototype({project:root,id:'second',templateRoot:template.directory,expertMode:'template'});
+  const updated=JSON.parse(fs.readFileSync(path.join(second.directory,'app/public/prototype-config.json')));
+  assert.equal(updated.title,'资产台账');
+  assert.equal(updated.content.fields.name.label,'资产名称');
+  assert.equal(updated.content.actions.query,'检索');
+  assert.equal(fs.readFileSync(configFile,'utf8'),original);
+  assert.equal(lib.inspect(first.directory).status,'passed');
+});
+
+test('unsupported template fields require explicit framework adaptation instead of silently disappearing', t => {
+  const root=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root}),htmlFile=path.join(template.directory,'index.html');
+  fs.writeFileSync(htmlFile,fs.readFileSync(htmlFile,'utf8').replace('data-field-id="device-status">状态</th>','data-field-id="device-status">状态</th><th data-field-id="device-owner">负责人</th>'));
+  require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')).syncTemplate(template.directory);
+  assert.throws(()=>lib.createPrototype({project:root,id:'unsupported',templateRoot:template.directory,expertMode:'template'}),/unsupported|adaptation|适配/i);
+  assert.equal(fs.existsSync(path.join(root,'prototypes/unsupported')),false);
+});
+
+test('HTML cannot silently remove the required name field validation in the pilot projection', t => {
+  const root=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root}),htmlFile=path.join(template.directory,'index.html');
+  fs.writeFileSync(htmlFile,fs.readFileSync(htmlFile,'utf8').replace('value="一号循环泵" required','value="一号循环泵"'));
+  require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')).syncTemplate(template.directory);
+  assert.throws(()=>lib.createPrototype({project:root,id:'no-validation',templateRoot:template.directory,expertMode:'template'}),/required|必填|adaptation/i);
+});
+
+test('a changed fixed input requires explicit acceptance and failed acceptance does not advance revision', t => {
+  const directory=candidate(t),scopeFile=path.join(directory,'inputs/scope.json');
+  const scope=JSON.parse(fs.readFileSync(scopeFile));scope.openQuestions=['Explicitly added review question'];fs.writeFileSync(scopeFile,JSON.stringify(scope));
+  const current=lib.manifest(directory),options={revision:'r002',expectedRevision:'r001',expectedDigest:current.digest};
+  assert.throws(()=>lib.revise(directory,options),/input|contract|输入/i);
+  assert.equal(lib.manifest(directory).revision,'r001');
+  const updated=lib.revise(directory,{...options,acceptInputs:true});
+  assert.equal(updated.revision,'r002');assert.equal(lib.inspect(directory).status,'passed');
+  const file=path.join(directory,'inputs/capabilities.json'),capabilities=JSON.parse(fs.readFileSync(file));
+  capabilities.bindings=capabilities.bindings.filter(binding=>binding.capabilityId!=='pagination');fs.writeFileSync(file,JSON.stringify(capabilities));
+  const invalid=lib.manifest(directory);
+  assert.throws(()=>lib.revise(directory,{revision:'r003',expectedRevision:'r002',expectedDigest:invalid.digest,acceptInputs:true}),/binding|capability|pagination/i);
+  assert.equal(lib.manifest(directory).revision,'r002');
+});
+
+test('CLI check rejects a stale generated index without updating it', async t => {
+  const root=project(t),template=legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root}),file=path.join(template.directory,'capabilities.generated.json');
+  const before=fs.readFileSync(file,'utf8');fs.appendFileSync(path.join(template.directory,'index.html'),'\n<!-- edit -->');
+  const cli=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-pilot.cjs'));
+  await assert.rejects(cli.main(['sync-template',template.directory,'--check']),/stale|不同步/);
+  assert.equal(fs.readFileSync(file,'utf8'),before);
+});
+
+test('an explicit title is projected to the visible page and unsupported frameworks write nothing', t => {
+  const root=project(t);legacyFixture.prepareTemplate(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/template-contract.cjs')), {project:root});
+  assert.throws(()=>lib.createPrototype({project:root,id:'wrong',framework:'react-material-ui',expertMode:'template'}),/framework|框架|unsupported/i);
+  assert.equal(fs.existsSync(path.join(root,'prototypes')),false);assert.equal(fs.existsSync(path.join(root,'.i3-ui-prototypes.json')),false);
+  const {directory}=lib.createPrototype({project:root,id:'titled',templateRoot:path.join(root,'ui-templates/admin-list'),title:'明确指定的新标题',expertMode:'template'});
+  const config=JSON.parse(fs.readFileSync(path.join(directory,'app/public/prototype-config.json')));
+  assert.equal(config.title,'明确指定的新标题');assert.equal(config.content.pageTitle,config.title);
+});
+
+test('ordinary revise can start repair of broken user code without accepting changed contracts', t => {
+  const directory=candidate(t);fs.rmSync(path.join(directory,'app/src/App.vue'));
+  const current=lib.manifest(directory);
+  assert.equal(lib.revise(directory,{revision:'r002',expectedRevision:current.revision,expectedDigest:current.digest}).revision,'r002');
+  assert.equal(lib.inspect(directory).status,'failed');
+});
+
+test('a failing real npm test prevents the build command and fixed build publication', t => {
+  const directory=candidate(t),app=path.join(directory,'app'),file=path.join(app,'package.json');
+  const pkg=JSON.parse(fs.readFileSync(file));
+  pkg.scripts={typecheck:'node -e "process.exit(0)"',test:'node -e "process.exit(3)"',build:'node build-test.cjs'};
+  fs.writeFileSync(file,JSON.stringify(pkg));
+  fs.writeFileSync(path.join(app,'build-test.cjs'),'require("node:fs").writeFileSync("build-ran.txt","unexpected build execution");\n');
+  fs.mkdirSync(path.join(app,'node_modules/vite'),{recursive:true});
+  assert.throws(()=>lib.build(directory),/npm test failed/);
+  assert.equal(fs.existsSync(path.join(app,'build-ran.txt')),false);
+  assert.equal(fs.existsSync(path.join(directory,'last-build.json')),false);
+  assert.equal(fs.existsSync(path.join(directory,'builds')),false);
+});
+
+test('a build manifest missing its required test step cannot be reused for acceptance', t => {
+  const directory=candidate(t),build=syntheticBuild(directory),file=path.join(directory,`builds/${build.buildId}/manifest.json`);
+  const data=JSON.parse(fs.readFileSync(file));delete data.checks.test;fs.writeFileSync(file,JSON.stringify(data));
+  assert.throws(()=>lib.verifyBuild(directory,build.buildId),/test|check|步骤/);
+});
+
+test('state is a read-only compact handoff with exact current commands', async t => {
+  const directory=candidate(t),before=lib.manifest(directory);
+  const tree=()=>Object.fromEntries(require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-files.cjs')).walk(directory).map(file=>[file,hash(fs.readFileSync(path.join(directory,file)))]));
+  const snapshot=tree();
+  const result=lib.state(directory);
+  assert.equal(result.candidateDigest,before.digest);
+  assert.equal(result.inputDigest,before.inputDigest);
+  assert.equal(result.revision,'r001');
+  assert.equal(result.design.status,'skipped');
+  assert.equal(result.build.status,'not-run');
+  assert.equal(result.browser.status,'not-run');
+  assert.equal(result.nextAction,'build');
+  assert.ok(result.scopes.requirements.length);
+  assert.ok(result.commands.revise.argv.includes(before.digest));
+  assert.ok(result.commands.browser.argv.includes('browser'));
+  assert.deepEqual(tree(),snapshot,'state must not write progress, directories or host memory');
+  const cli=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-pilot.cjs'));
+  assert.equal((await cli.main(['state',directory])).candidateDigest,before.digest);
+});
+
+test('state identifies pending professional review without inventing decisions', t => {
+  const directory=candidate(t),meta=JSON.parse(fs.readFileSync(path.join(directory,'prototype.json')));
+  meta.expertMode='professional';write(directory,'prototype.json',meta);
+  write(directory,'qa/design-advice.json',{provider:{availability:'available',digest:hash('fixture-provider')},queries:[],records:[],status:'pending'});
+  write(directory,'design-system/decisions.json',{reviewStatus:'pending',records:[]});
+  assert.equal(lib.state(directory).design.status,'pending');
+  assert.equal(lib.state(directory).nextAction,'review-design');
+  assert.throws(()=>lib.finalize(directory),/acceptance|验收/i);
+  assert.equal(JSON.parse(fs.readFileSync(path.join(directory,'qa/design-advice.json'))).status,'pending');
+});
+
+test('finalize refuses unverified candidates and preserves user handoff on failure', t => {
+  const directory=candidate(t),file=path.join(directory,'HANDOFF.md'),before=fs.readFileSync(file,'utf8');
+  assert.throws(()=>lib.finalize(directory),/acceptance|verified|验收/i);
+  assert.equal(fs.readFileSync(file,'utf8'),before);
+  assert.equal(fs.existsSync(path.join(directory,'.prototype-write.lock')),false);
+});
+
+test('finalize summarizes verified guard fixtures without changing identity or human approval', t => {
+  const directory=candidate(t),report=syntheticReport(directory);lib.recordRun(directory,report);
+  write(directory,'last-build.json',{buildId:report.buildId,buildDigest:report.buildDigest,candidateDigest:report.candidateDigest});
+  const before=lib.manifest(directory),file=path.join(directory,'HANDOFF.md');
+  fs.appendFileSync(file,'\nUSER_HANDOFF_NOTE: preserve this paragraph\n');
+  const result=lib.finalize(directory,{expectedRevision:before.revision,expectedDigest:before.digest});
+  assert.equal(result.status,'complete');assert.equal(result.candidateDigest,before.digest);
+  assert.equal(result.review,'pending-review');assert.equal(result.verification,'passed');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(directory,'qa/delivery.json'))).candidateDigest,before.digest);
+  assert.equal(lib.state(directory).delivery.status,'current');
+  assert.equal(lib.state(directory).nextAction,'return-result');
+  assert.match(fs.readFileSync(file,'utf8'),/USER_HANDOFF_NOTE/);
+  assert.equal(lib.manifest(directory).digest,before.digest);
+  const text=fs.readFileSync(file,'utf8');lib.finalize(directory);
+  assert.equal(fs.readFileSync(file,'utf8'),text,'repeat finalize must not duplicate generated handoff');
+  assert.equal(fs.existsSync(path.join(directory,'baseline.json')),false);
+  fs.appendFileSync(path.join(directory,'app/src/App.vue'),'\n<!-- new user edit -->');
+  const changed=lib.state(directory);
+  assert.equal(changed.delivery.status,'stale');assert.equal(changed.nextAction,'build');
+  assert.throws(()=>lib.finalize(directory),/acceptance|stale|验收/i);
+});
+
+test('browser and final handoff cannot write while another candidate owner is active', async t => {
+  const directory=candidate(t),report=syntheticReport(directory);lib.recordRun(directory,report);
+  const current=lib.manifest(directory);lib.claim(directory,{owner:'active-owner',expectedRevision:current.revision,expectedDigest:current.digest});
+  try {
+    assert.throws(()=>lib.finalize(directory),/EEXIST|owner|writing|锁/i);
+    const browser=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-browser.cjs'));
+    await assert.rejects(browser.main(directory,{playwrightModule:'definitely-unavailable'}),/EEXIST|owner|writing|锁/i);
+  } finally { lib.release(directory,'active-owner'); }
+});
+
+test('installed browser resolves only an existing project or explicit Playwright provider', t => {
+  const directory=candidate(t),browser=require(path.join(skillsDirectory,'i3-ui-prototype/scripts/native-browser.cjs'));
+  assert.throws(()=>browser.resolvePlaywright(directory,{playwrightModule:path.join(directory,'absent-provider')}),/Playwright|provider|模块/i);
+  const provider=path.join(directory,'app/node_modules/playwright');
+  write(provider,'package.json',{name:'playwright',version:'0.0.0-resolution-unit-fixture',main:'index.js'});
+  write(provider,'index.js','throw new Error("Resolution must not execute this unit fixture");');
+  assert.equal(browser.resolvePlaywright(directory).packageRoot,fs.realpathSync(provider));
+  assert.equal(browser.resolvePlaywright(directory,{playwrightModule:provider}).version,'0.0.0-resolution-unit-fixture');
+  const projectRoot=path.resolve(directory,'../..'),tools=path.join(projectRoot,'.prototype-tools/node_modules/playwright');
+  write(tools,'package.json',{name:'playwright',version:'0.0.0-tools-unit-fixture',main:'index.js'});
+  write(tools,'index.js','throw new Error("Resolution only; never execute the fixture");');
+  assert.equal(browser.resolvePlaywright(directory).packageRoot,fs.realpathSync(tools));
+  const currentTools=path.join(projectRoot,'.codebuddy/tools/i3-prototype/playwright/node_modules/playwright');
+  write(currentTools,'package.json',{name:'playwright',version:'0.0.0-current-tools-unit-fixture',main:'index.js'});
+  write(currentTools,'index.js','throw new Error("Resolution only; never execute the fixture");');
+  assert.equal(browser.resolvePlaywright(directory,{host:'codebuddy'}).packageRoot,fs.realpathSync(currentTools));
+  fs.rmSync(path.join(projectRoot,'.codebuddy/tools'),{recursive:true});
+  assert.equal(lib.state(directory).commands.browser.argv.includes(fs.realpathSync(tools)),true,'state prints the discovered project tool provider');
+  assert.equal(browser.resolvePlaywright(directory,{playwrightModule:provider}).packageRoot,fs.realpathSync(provider),'explicit provider wins');
+  fs.rmSync(tools,{recursive:true});fs.rmSync(provider,{recursive:true});
+  const projectProvider=path.join(projectRoot,'node_modules/playwright');
+  write(projectProvider,'package.json',{name:'playwright',version:'0.0.0-project-unit-fixture',main:'index.js'});
+  write(projectProvider,'index.js','throw new Error("Resolution only; never execute the fixture");');
+  assert.equal(browser.resolvePlaywright(directory).packageRoot,fs.realpathSync(projectProvider));
+});
+
+test('approval applies only to its confirmed revision and digest after direct user edits', t => {
+  const directory=candidate(t),first=syntheticReport(directory);lib.recordRun(directory,first);
+  const approved=lib.manifest(directory);
+  lib.confirmBaseline(directory,{revision:approved.revision,digest:approved.digest,reviewer:'synthetic-unit-reviewer',statement:'Synthetic approval fixture only, never actual user approval',source:'unit-fixture'});
+  const baselineFile=path.join(directory,'baseline.json'),baseline=fs.readFileSync(baselineFile,'utf8');
+  assert.equal(lib.inspect(directory).review,'approved');
+  write(directory,'last-build.json',{buildId:first.buildId,buildDigest:first.buildDigest,candidateDigest:first.candidateDigest});
+  assert.equal(lib.finalize(directory).humanConfirmationRequired,false,'a matching existing approval remains valid');
+  fs.appendFileSync(path.join(directory,'app/src/App.vue'),'\n<!-- direct user edit, same revision -->');
+  const edited=lib.manifest(directory);assert.equal(edited.revision,approved.revision);assert.notEqual(edited.digest,approved.digest);
+  const state=lib.state(directory);
+  assert.equal(state.review.status,'pending-review','the previous human decision cannot approve new bytes');
+  assert.equal(lib.inspect(directory).review,'pending-review');
+  assert.equal(JSON.parse(fs.readFileSync(path.join(directory,'prototype.json'))).review.status,'approved','read-only state must preserve the historical stored approval');
+  const second=syntheticReport(directory);second.id='synthetic-after-user-edit';lib.recordRun(directory,second);
+  write(directory,'last-build.json',{buildId:second.buildId,buildDigest:second.buildDigest,candidateDigest:second.candidateDigest});
+  assert.equal(JSON.parse(fs.readFileSync(path.join(directory,'prototype.json'))).review.status,'pending-review','recordRun must not carry approval into the new candidate');
+  // Compatibility with an artifact already written by the previous runtime:
+  // fresh QA exists but its stored approval still refers to the old candidate.
+  const legacy=JSON.parse(fs.readFileSync(path.join(directory,'prototype.json')));
+  legacy.review={status:'approved',revision:approved.revision,digest:approved.digest};write(directory,'prototype.json',legacy);
+  const result=lib.finalize(directory);
+  assert.equal(result.review,'pending-review');assert.equal(result.humanConfirmationRequired,true);
+  assert.equal(result.candidateDigest,edited.digest);
+  const incorrectReceipt={...result,review:'approved',humanConfirmationRequired:false};write(directory,'qa/delivery.json',incorrectReceipt);
+  assert.equal(lib.state(directory).delivery.status,'stale','a receipt made by the old bug is not current');
+  assert.equal(lib.finalize(directory).humanConfirmationRequired,true);
+  assert.equal(fs.readFileSync(baselineFile,'utf8'),baseline,'do not move or rewrite the old human baseline');
+  assert.equal(lib.compareBaseline(directory).status,'changed');
+});

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

@@ -0,0 +1,53 @@
+'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');
+const assert = require('node:assert/strict');
+const R = require(prototypeScripts+'/codebuddy-registration.cjs');
+const options = { action: 'enable', scope: 'project', product: 'ide', base: '/work/project/.codebuddy',
+  project: '/work/project', nodePath: '/runtime with spaces/node', scriptPath: '/work/project/.codebuddy/skills/i3-ui-prototype/scripts/hosts/codebuddy.cjs', scriptDigest: 'a'.repeat(64) };
+test('registration planning preserves unrelated hooks and never grants permissions', () => {
+  const before = { theme: 'dark', hooks: { PreToolUse: [{ matcher: 'Write', hooks: [{ type: 'command', command: 'original-check' }] }] } };
+  const result = R.plan({ ...options, currentText: JSON.stringify(before) });
+  const after = JSON.parse(result.afterText);
+  assert.equal(after.theme, 'dark'); assert.deepEqual(after.hooks.PreToolUse[0], before.hooks.PreToolUse[0]);
+  assert.ok(result.summary.events.includes('PostToolUse'));
+  assert.match(after.hooks.PreToolUse[1].hooks[0].command, /'\/runtime with spaces\/node'/);
+  assert.equal(result.recordAfter.active, undefined);
+  assert.equal(result.summary.status, 'registered');
+});
+test('repeated enable is idempotent, disable removes only owned groups', () => {
+  const first = R.plan({ ...options, currentText: '{"userOption":42}' });
+  const again = R.plan({ ...options, currentText: first.afterText, record: first.recordAfter });
+  assert.equal(again.afterText, first.afterText);
+  const removed = R.plan({ ...options, action: 'disable', currentText: again.afterText, record: again.recordAfter });
+  assert.equal(JSON.parse(removed.afterText).userOption, 42);
+  assert.equal(Object.values(JSON.parse(removed.afterText).hooks).flat().length, 0);
+});
+test('missing ownership and modified owned hooks cannot be force adopted', () => {
+  const first = R.plan({ ...options, currentText: '{}' });
+  assert.throws(() => R.plan({ ...options, currentText: first.afterText }), /ownership|Ownership/);
+  const edited = JSON.parse(first.afterText); edited.hooks.Stop[0].hooks[0].timeout = 9;
+  assert.throws(() => R.plan({ ...options, currentText: JSON.stringify(edited), record: first.recordAfter }), /modified|changed/);
+  assert.throws(() => R.plan({ ...options, currentText: '{broken' }), /JSON/);
+});
+test('global CLI registration and defaults remain separate from actual activation', () => {
+  const keep = R.plan({ ...options, action: 'keep', currentText: null });
+  assert.equal(keep.afterText, null); assert.equal(keep.summary.status, 'not-enabled');
+  const global = R.plan({ ...options, scope: 'global', base: '/user/.codebuddy', product: 'cli', currentText: '{}' });
+  assert.equal(global.summary.status, 'pending-host-review');
+  assert.match(global.recordAfter.groups.Stop.hooks[0].command, /--scope' 'global/);
+  assert.throws(() => R.plan({ ...options, product: 'workbuddy' }), /product/);
+});
+test('configuration transaction refuses stale previews and restores only its own failed write in memory', () => {
+  const change = R.plan({ ...options, currentText: '{}' });
+  const files = new Map([[change.settingsPath, '{}']]); let fail = true;
+  const io = { read: file => files.get(file) ?? null, write(file, text) {
+    if (file === change.recordPath && fail) { fail = false; throw new Error('record write failed'); }
+    if (text === null) files.delete(file); else files.set(file, text);
+  } };
+  assert.throws(() => R.apply(change, io), /record write failed/);
+  assert.equal(files.get(change.settingsPath), '{}');
+  files.set(change.settingsPath, '{"userEdit":true}');
+  assert.throws(() => R.apply(change, io), /changed after preview/);
+  assert.equal(files.get(change.settingsPath), '{"userEdit":true}');
+});