@givolt/i3-composer-agent 2.3.2 → 2.3.3

package/hooks/codebuddy-upstream.cjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+'use strict';
+// Original scripts stay unchanged; this adapter only maps host paths and input fields.
+const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
+const M=require('./manage.cjs');
+function projectKey(project){return (path.basename(project).replace(/[^a-zA-Z0-9_-]/g,'-').slice(0,32)||'project')+'-'+M.sha(project).slice(0,16);}
+function effective({project,product,group,home=os.homedir(),env=process.env,read=file=>M.modules().R.fileIO.read(file),load=base=>registration(base)}) {
+ const projectBase=path.join(project,'.codebuddy'),globalBase=M.modules().P.globalBase({home,env});
+ const projectText=read(path.join(projectBase,'settings.json')),local=read(path.join(projectBase,'settings.local.json'));
+ if(local){const settings=M.config(local);assert.ok(!settings.hooks&&!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Local Hook override requires review');}
+ for(const base of [projectBase,globalBase]){const settings=M.config(read(path.join(base,'settings.json')));assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents Hooks');}
+ const bases=product==='ide'&&projectText!==null?[projectBase]:[projectBase,globalBase];
+ for(const base of [...new Set(bases)]){const record=load(base);if(record?.groups[group]){assert.equal(record.product,product,'Conflicting CodeBuddy products');return record;}}
+ return null;
+}
+function projectFor(options,payload,env=process.env,real=file=>fs.realpathSync(file),callbackCwd=process.cwd(),workspace=(file,session)=>require(path.join(M.modules().scripts,'execution-evidence.cjs')).ideWorkspace(file,session)) {
+ // CLI 2.169 omits cwd on SessionStart. Use the actual startup Hook process
+ // directory only for that event; other events still require native cwd.
+ const cwd=payload.cwd||(payload.hook_event_name==='SessionStart'?callbackCwd:null);
+ assert.ok(path.isAbsolute(cwd||''),'Native Hook cwd required');
+ const ideRoot=options.product==='ide'&&payload.client==='CodeBuddyIDE'&&cwd==='/';
+ const project=real(options.scope==='project'?path.dirname(options.base):ideRoot?workspace(payload.transcript_path,payload.session_id):env.CODEBUDDY_PROJECT_DIR||env.CLAUDE_PROJECT_DIR||cwd);
+ const relative=path.relative(project,real(ideRoot?project:cwd));assert.ok(relative!=='..'&&!relative.startsWith('..'+path.sep)&&!path.isAbsolute(relative),'Hook working directory is outside the registered project');return project;
+}
+function invocation({group,event,project,cwd=project,base,payload},source) {
+ const value=structuredClone(payload),cache=path.join(base,'cache/i3-composer-agent/hooks',projectKey(project));
+ if(group==='sdd-cache') {
+  if(value.tool_name!=='WebFetch'||!['PreToolUse','PostToolUse'].includes(event))return null;
+  const before='${CLAUDE_PROJECT_DIR:-$PWD}/.claude/sdd-cache';assert.equal(source.split(before).length,3,'Upstream cache path changed; review the adapter');
+  source=source.replaceAll(before,'${I3_HOOK_CACHE}/sdd-cache');
+ } else if(group==='simplify-ignore') {
+  if(event==='Stop')value.tool_name='';
+  if(event!=='Stop') {
+   if(event==='PreToolUse'?value.tool_name!=='Read':!['Edit','Write'].includes(value.tool_name))return null;
+   const file=value.tool_input?.file_path||value.tool_input?.filePath;if(typeof file!=='string')return null;
+   const resolved=path.resolve(cwd,file),relative=path.relative(project,resolved);
+   if(relative==='..'||relative.startsWith('..'+path.sep)||path.isAbsolute(relative))return null;
+   value.tool_input.file_path=resolved;
+  }
+  const before='${CLAUDE_PROJECT_DIR:-.}/.claude/.simplify-ignore-cache';assert.equal(source.split(before).length,2,'Upstream simplify cache path changed; review the adapter');
+  source=source.replace(before,'${I3_HOOK_CACHE}/simplify-ignore');
+ }else assert.ok(group==='session-start'&&event==='SessionStart','Unknown upstream Hook event');
+ return {source,payload:value,cache,env:{CLAUDE_PROJECT_DIR:project,CODEBUDDY_PROJECT_DIR:project,I3_HOOK_CACHE:cache}};
+}
+function bundle(directory=__dirname) {
+ const files=['manage.cjs','codebuddy-upstream.cjs','session-start.sh','sdd-cache-pre.sh','sdd-cache-post.sh','simplify-ignore.sh'];
+ return M.sha(JSON.stringify(files.map(file=>{let text=fs.readFileSync(path.join(directory,file),'utf8');if(file==='session-start.sh')text=text.replace(/^SKILLS_DIR=.*$/m,'SKILLS_DIR=<native-layout>');return [file,M.sha(text)];})));
+}
+function registration(base) {
+ const io=M.modules().R.fileIO,raw=io.read(path.join(base,'state/i3-composer-agent/hooks.json'));if(raw===null)return null;
+ const record=JSON.parse(raw),settingsText=io.read(path.join(base,'settings.json'));
+ M.validateOwned(M.config(settingsText),record,base,record.scope);
+ for(const item of Object.values(record.groups))assert.equal(item.scriptDigest,bundle(),'Upstream Hook adapter changed; refresh registration');
+ return {...record,settingsDigest:M.sha(settingsText)};
+}
+function observe(base,project,group,payload,record,result) {
+ const io=M.modules().R.fileIO,file=path.join(base,'state/i3-composer-agent/hook-observations',projectKey(project),group+'.json'),unlock=io.lock(file);
+ try {
+  const before=io.read(file),old=before?JSON.parse(before):null;
+  const same=old?.settingsDigest===record.settingsDigest&&old?.scriptDigest===record.groups[group].scriptDigest;
+  const value={schemaVersion:1,group,base,project,sessionId:payload.session_id||null,event:payload.hook_event_name,at:new Date().toISOString(),
+   events:[...new Set([...(same?old.events:[]),payload.hook_event_name])],exitCode:result.status,settingsDigest:record.settingsDigest,scriptDigest:record.groups[group].scriptDigest,invocationVerified:false};
+  io.write(file,M.json(value),M.digest(before));
+ }finally{unlock();}
+}
+function main(argv=process.argv.slice(2),raw=fs.readFileSync(0,'utf8')) {
+ assert.ok(Buffer.byteLength(raw)<=4*1024*1024,'Hook input too large');const options={};
+ while(argv.length){const flag=argv.shift();assert.ok(flag.startsWith('--')&&argv.length,'Invalid Hook argument');assert.ok(['registration','group','base','scope','product','event'].includes(flag.slice(2)),'Unknown Hook argument');options[flag.slice(2)]=argv.shift();}
+ assert.equal(options.registration,M.OWNER,'Invalid Hook registration');assert.ok(path.isAbsolute(options.base||''),'Absolute Hook base required');assert.ok(['project','global'].includes(options.scope),'Invalid Hook scope');
+ const item=M.catalog.find(x=>x.id===options.group&&x.origin==='upstream');assert.ok(item?.events.includes(options.event),'Invalid Hook group/event');
+ const payload=JSON.parse(raw);assert.equal(payload.hook_event_name,options.event,'Hook payload event differs');const project=projectFor(options,payload);
+ const expected=options.scope==='project'?path.join(project,'.codebuddy'):M.modules().P.globalBase();assert.equal(options.base,expected,'Hook installation scope differs');
+ const record=registration(options.base);
+ if(!record?.groups[options.group])return {status:0,stdout:'{"continue":true}\n',stderr:''};
+ assert.equal(record.product,options.product,'Hook product differs');
+ if(effective({project,product:options.product,group:options.group})?.base!==options.base)return {status:0,stdout:'{"continue":true}\n',stderr:''};
+ const filename=options.group==='session-start'?'session-start.sh':options.group==='simplify-ignore'?'simplify-ignore.sh':options.event==='PreToolUse'?'sdd-cache-pre.sh':'sdd-cache-post.sh';
+ const cwd=options.product==='ide'&&payload.client==='CodeBuddyIDE'&&payload.cwd==='/'?project:payload.cwd||project;
+ const script=path.join(__dirname,filename),prepared=invocation({...options,project,cwd,payload},fs.readFileSync(script,'utf8'));
+ if(!prepared)return {status:0,stdout:'{"continue":true}\n',stderr:''};
+ if(options.group==='simplify-ignore'&&options.event!=='Stop'&&fs.existsSync(prepared.payload.tool_input.file_path)) {
+  const real=fs.realpathSync(prepared.payload.tool_input.file_path),relative=path.relative(project,real);assert.ok(relative!=='..'&&!relative.startsWith('..'+path.sep)&&!path.isAbsolute(relative),'Protected file symlink escapes the project');
+ }
+ const unlock=M.modules().R.fileIO.lock(path.join(prepared.cache,'.'+options.group+'.event'));
+ let result;try {
+  result=require('node:child_process').spawnSync(record.groups[options.group].bashPath,['-c',prepared.source,script],{cwd:project,env:{...process.env,...prepared.env},input:JSON.stringify(prepared.payload),encoding:'utf8',timeout:15000,maxBuffer:8*1024*1024});
+  if(result.error||result.status===null)throw new Error(result.error?.message||'Upstream Hook did not complete');
+ }finally{unlock();}
+ try{observe(options.base,project,options.group,payload,record,result);}catch(error){result.stderr=(result.stderr||'')+`\ni3 Hook observation unavailable: ${error.message}\n`;}
+ return result;
+}
+module.exports={projectKey,projectFor,effective,invocation,bundle,registration,observe,main};
+if(require.main===module)try{const result=main();process.stdout.write(result.stdout||'');process.stderr.write(result.stderr||'');process.exitCode=result.status;}catch(error){process.stderr.write(`i3 CodeBuddy Hook unavailable: ${error.message}\n`);process.exitCode=1;}

package/hooks/i3-prototype.cjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+// Stable host Hook entry; the workflow and A+B implementation remain in the Skill.
+const fs=require('node:fs'),path=require('node:path');
+function main(argv=process.argv.slice(2),raw=fs.readFileSync(0,'utf8'),load=()=>require(path.join(require('./manage.cjs').modules().scripts,'hosts/codebuddy.cjs'))) {
+ return load().main(argv,raw);
+}
+module.exports={main};
+if(require.main===module)try {
+ const result=main();process.stdout.write(JSON.stringify(result.output)+'\n');
+ if(result.code===2)process.stderr.write(result.output.reason+'\n');process.exitCode=result.code;
+}catch(error){process.stderr.write(`i3 prototype audit unavailable: ${error.message}. Strict A gates remain unverified.\n`);process.exitCode=1;}

package/hooks/manage.cjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+'use strict';
+// CodeBuddy settings protocol: https://www.codebuddy.cn/docs/cli/hooks
+// IDE override semantics: https://www.codebuddy.cn/docs/ide/Features/Hooks
+const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),crypto=require('node:crypto'),assert=require('node:assert/strict');
+const OWNER='i3-composer-agent-codebuddy-v1';
+const catalog=[
+ {id:'session-start',name:'Skill 发现与路由',origin:'upstream',files:['session-start.sh'],events:['SessionStart'],dependencies:['bash','jq'],condition:'明确 skill-routing=hook；原生路由使用 native，避免重复注入'},
+ {id:'sdd-cache',name:'官方文档请求缓存',origin:'upstream',files:['sdd-cache-pre.sh','sdd-cache-post.sh'],events:['PreToolUse','PostToolUse'],dependencies:['bash','jq','curl','sha256'],condition:'实际 WebFetch；仅源站 304 复用'},
+ {id:'simplify-ignore',name:'代码块简化保护',origin:'upstream',files:['simplify-ignore.sh'],events:['PreToolUse','PostToolUse','Stop'],dependencies:['bash','jq','sha1'],condition:'使用 simplify-ignore 标记；会在运行期间替换标记块并在 Stop 恢复'},
+ {id:'prototype',name:'原型执行审计',origin:'i3',events:['SessionStart','UserPromptSubmit','PreToolUse','PostToolUse','Stop'],dependencies:['node'],condition:'真实 CodeBuddy IDE/CLI；默认从原生 Hook 自动识别日志，支持手动目录限制'},
+];
+const digest=value=>crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const sha=bytes=>crypto.createHash('sha256').update(bytes).digest('hex');
+const json=value=>JSON.stringify(value,null,2)+'\n';
+function selection(value,action='check') {
+ const ids=value===undefined?(['check','list'].includes(action)?catalog.map(x=>x.id):['prototype']):value==='all'?catalog.map(x=>x.id):value.split(',');
+ assert.ok(ids.length&&ids.every(id=>catalog.some(item=>item.id===id)),'Unknown Hook group; choose session-start,sdd-cache,simplify-ignore,prototype or all');
+ return [...new Set(ids)];
+}
+function quote(value){assert.ok(typeof value==='string'&&!/[\x00\r\n]/.test(value),'Unsafe Hook argument');return "'"+value.replaceAll("'","'\\''")+"'";}
+function config(raw){const value=raw===null?{}:JSON.parse(raw);assert.ok(value&&typeof value==='object'&&!Array.isArray(value),'Settings must be an object');assert.ok(value.hooks===undefined||value.hooks&&typeof value.hooks==='object'&&!Array.isArray(value.hooks),'Invalid hooks configuration');for(const groups of Object.values(value.hooks||{})){assert.ok(Array.isArray(groups),'Invalid Hook groups');for(const group of groups)assert.ok(group&&Array.isArray(group.hooks),'Invalid Hook group');}return value;}
+function modules() {
+ const roots=[path.resolve(__dirname,'..'),path.resolve(__dirname,'../..')];
+ const candidates=roots.flatMap(root=>['i3-ui-prototype',['ui','prototype'].join('-')].map(id=>path.join(root,'skills',id,'scripts')));
+ const scripts=candidates.find(dir=>fs.existsSync(path.join(dir,'prototype-hooks.cjs')));assert.ok(scripts,'Prototype audit implementation is missing; install the complete package');
+ return {scripts,R:require(path.join(scripts,'codebuddy-registration.cjs')),P:require(path.join(scripts,'prototype-hooks.cjs'))};
+}
+function owned(group){return group.hooks.some(h=>typeof h.command==='string'&&h.command.includes(OWNER));}
+function validateOwned(settings,record,base,scope) {
+ if(record){assert.equal(record.owner,OWNER,'Unknown Hook ownership');assert.equal(record.schemaVersion,1,'Unsupported Hook ownership');assert.equal(record.base,base,'Hook base differs');assert.equal(record.scope,scope,'Hook scope differs');assert.ok(record.groups&&typeof record.groups==='object'&&!Array.isArray(record.groups),'Invalid owned Hook groups');
+  for(const [id,item] of Object.entries(record.groups)){const known=catalog.find(x=>x.id===id&&x.origin==='upstream');assert.ok(known&&item&&item.groups,'Unknown owned Hook group');assert.deepEqual(Object.keys(item.groups).sort(),[...known.events].sort(),'Owned Hook events changed');}
+ }
+ const found=new Set();
+ for(const [event,groups] of Object.entries(settings.hooks||{}))for(const group of groups.filter(owned)) {
+  const ids=Object.keys(record?.groups||{}).filter(id=>record.groups[id].groups[event]&&group.hooks.some(h=>h.command?.includes(`--group' '${id}'`)));
+  assert.equal(ids.length,1,'Hook ownership is missing; preserve the unknown command');const key=ids[0]+':'+event;
+  assert.ok(!found.has(key),'Duplicate owned Hook');assert.deepEqual(group,record.groups[ids[0]].groups[event],'Owned Hook was modified; preserve user changes');found.add(key);
+ }
+ for(const [id,item] of Object.entries(record?.groups||{}))for(const event of Object.keys(item.groups))assert.ok(found.has(id+':'+event),'Owned Hook registration is missing');
+}
+function requirements(id,deps) {
+ for(const name of catalog.find(x=>x.id===id).dependencies){if(name==='sha256')assert.ok(deps.shasum||deps.sha256sum,'Missing shasum or sha256sum');else if(name==='sha1')assert.ok(deps.shasum||deps.sha1sum,'Missing shasum or sha1sum');else assert.ok(deps[name],`Missing ${name}; install it separately before enabling ${id}`);}
+}
+function planUpstream(options) {
+ const {base,scope,product,action,record=null,settingsText=null,nodePath,hookDirectory,scriptDigest,dependencies={},skillRouting}=options;
+ assert.ok(['keep','enable','disable'].includes(action),'Invalid Hook action');assert.ok(['project','global'].includes(scope),'Specify project or global scope');
+ const settings=config(settingsText);validateOwned(settings,record,base,scope);
+ const chosen=selection(options.groups,action).filter(id=>id!=='prototype'),enabled=new Set(Object.keys(record?.groups||{}));
+ if(action==='enable')for(const id of chosen){if(id==='session-start')assert.equal(skillRouting,'hook','session-start requires explicit skill-routing=hook; native routing must not be duplicated');requirements(id,dependencies);enabled.add(id);}
+ if(action==='disable')for(const id of chosen)enabled.delete(id);
+ if(enabled.size){assert.ok(['ide','cli'].includes(product),'Specify CodeBuddy product ide or cli');if(record)assert.equal(product,record.product,'Disable the previous product profile before changing it');assert.match(scriptDigest,/^[a-f0-9]{64}$/);for(const p of [base,nodePath,hookDirectory])assert.ok(path.isAbsolute(p),'Absolute registration paths required');}
+ // Remove only exact owned groups after validation. All user Hook groups survive.
+ for(const event of Object.keys(settings.hooks||{}))settings.hooks[event]=settings.hooks[event].filter(g=>!owned(g));
+ const groups={};
+ for(const item of catalog.filter(x=>enabled.has(x.id))) {
+  const entry={product,scriptDigest,nodePath,bashPath:dependencies.bash||record?.groups[item.id]?.bashPath,skillRouting:item.id==='session-start'?'hook':null,groups:{}};
+  for(const event of item.events) {
+   const matcher=item.id==='sdd-cache'?'^WebFetch$':event==='PreToolUse'?'^Read$':'^(Edit|Write)$';
+   const argv=[nodePath,path.join(hookDirectory,'codebuddy-upstream.cjs'),'--registration',OWNER,'--group',item.id,'--base',base,'--scope',scope,'--product',product,'--event',event];
+   const group={...(event.endsWith('ToolUse')?{matcher}:{}),hooks:[{type:'command',command:argv.map(quote).join(' '),timeout:item.id==='sdd-cache'?15:20}]};
+   entry.groups[event]=group;settings.hooks||={};(settings.hooks[event]||=[]).push(group);
+  }
+  groups[item.id]=entry;
+ }
+ const recordAfter=enabled.size?{schemaVersion:1,owner:OWNER,base,scope,product,productVersion:options.productVersion||record?.productVersion||'unreported',groups}:null;
+ const afterText=!record&&!chosen.length||!record&&action!=='enable'?settingsText:json(settings);
+ return {afterText,recordAfter};
+}
+function apply(change,io=modules().R.fileIO) {
+ const unlock=io.lock?io.lock(change.changes[0].file):()=>{},written=[];
+ try {
+  for(const entry of change.changes)assert.equal(digest(io.read(entry.file)),digest(entry.before),'Hook configuration changed after planning');
+  try {for(const entry of change.changes)if(entry.before!==entry.after){io.write(entry.file,entry.after,digest(entry.before));written.push(entry);}}
+  catch(error){for(const entry of written.reverse())if(io.read(entry.file)===entry.after)io.write(entry.file,entry.before,digest(entry.after));throw error;}
+  return change.summary;
+ }finally{unlock();}
+}
+function executable(name,env=process.env) {
+ for(const folder of (env.PATH||'').split(path.delimiter)){const file=path.resolve(folder,name);try{if(fs.statSync(file).isFile()){fs.accessSync(file,fs.constants.X_OK);return file;}}catch{}}
+ return null;
+}
+function dependencies(){return Object.fromEntries(['bash','jq','curl','shasum','sha256sum','sha1sum'].map(name=>[name,executable(name)]));}
+function location(options) {
+ assert.equal(options.host||'codebuddy','codebuddy','Unified Hooks currently support CodeBuddy only');assert.ok(['project','global'].includes(options.scope),'Specify project or global scope');
+ const project=fs.realpathSync(path.resolve(options.project||'.'));assert.ok(fs.statSync(project).isDirectory(),'Project must be a directory');
+ return {project,base:options.scope==='project'?path.join(project,'.codebuddy'):modules().P.globalBase(options)};
+}
+function unmanaged(settings) {
+ const files={ 'session-start':['session-start.sh'],'sdd-cache':['sdd-cache-pre.sh','sdd-cache-post.sh'],'simplify-ignore':['simplify-ignore.sh'] },result=[];
+ for(const [event,groups] of Object.entries(settings.hooks||{}))for(const group of groups)for(const hook of group.hooks) {
+  if(typeof hook.command!=='string'||hook.command.includes(OWNER))continue;
+  for(const [id,names] of Object.entries(files))if(names.some(name=>hook.command.includes(name)))result.push({id,event,command:hook.command});
+ }
+ return result;
+}
+function pendingSimplify(base) {
+ const parent=path.join(base,'cache/i3-composer-agent/hooks');if(!fs.existsSync(parent))return [];
+ return fs.readdirSync(parent,{withFileTypes:true}).filter(entry=>entry.isDirectory()&&!entry.isSymbolicLink()).flatMap(entry=>{
+  const dir=path.join(parent,entry.name,'simplify-ignore');if(!fs.existsSync(dir))return [];
+  assert.ok(!fs.lstatSync(dir).isSymbolicLink(),'Simplify cache symlink requires review');return fs.readdirSync(dir).filter(file=>file.endsWith('.bak')).map(file=>path.join(dir,file));
+ });
+}
+function prepare(options,runtime={}) {
+ const {P,R}=runtime.modules||modules(),{project,base}=runtime.location||location(options),io=R.fileIO,action=options.action||'keep',ids=selection(options.groups,action);
+ const settingsPath=path.join(base,'settings.json'),recordPath=path.join(base,'state/i3-composer-agent/hooks.json'),prototypePath=path.join(base,'state/i3-prototype/installation.json');
+ const before=io.read(settingsPath),recordText=io.read(recordPath),record=recordText?JSON.parse(recordText):null,prototypeText=io.read(prototypePath),prototype=prototypeText?JSON.parse(prototypeText):null;
+ if(action!=='disable'&&(action!=='keep'||record||prototype))assert.ok(process.platform!=='win32','CodeBuddy Hook quoting on Windows has not been validated; default installation without Hooks remains available');
+ const product=options.product||record?.product||prototype?.product,settings=config(before);
+ if(action!=='disable'&&(action!=='keep'||record||prototype)) {
+  assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents automatic Hooks; preserve the policy');
+  const manifest=io.read(path.join(base,'.i3-composer-agent.json'));if(manifest)assert.ok(!JSON.parse(manifest).agents?.includes('workbuddy'),'Shared WorkBuddy scope cannot identify CodeBuddy safely');
+  assert.ok(!options.agents?.includes('workbuddy'),'Use an exclusive CodeBuddy scope for Hooks');
+ }
+ if(action==='enable')for(const id of ids)assert.ok(!unmanaged(settings).some(item=>item.id===id),`Unmanaged ${id} Hook already exists; preserve it and resolve the duplicate before enabling`);
+ if(ids.includes('simplify-ignore')&&['enable','disable'].includes(action)) {
+  for(const candidate of [...new Set([base,path.join(project,'.codebuddy'),P.globalBase?P.globalBase(options):path.join(options.home||os.homedir(),'.codebuddy')])])assert.equal((runtime.pendingSimplify||pendingSimplify)(candidate).length,0,'Simplify protection is still active; finish the session and restore blocks before changing Hooks');
+ }
+ const prototypeAction=ids.includes('prototype')?action:'keep';
+ const prototypeChange=action==='disable'&&!ids.includes('prototype')?{unchanged:true}:P.prepare({...options,project,product,action:prototypeAction,entryPath:path.join(base,'i3-composer-agent/hooks/i3-prototype.cjs'),entrySource:path.join(__dirname,'i3-prototype.cjs')});
+ const upstream=planUpstream({...options,base,product,action,record,settingsText:prototypeChange.unchanged?before:prototypeChange.afterText,nodePath:process.execPath,
+  hookDirectory:path.join(base,'i3-composer-agent/hooks'),scriptDigest:runtime.scriptDigest||require('./codebuddy-upstream.cjs').bundle(),dependencies:runtime.dependencies||dependencies()});
+ const changes=[{file:settingsPath,before,after:upstream.afterText},{file:recordPath,before:recordText,after:upstream.recordAfter?json(upstream.recordAfter):null},
+  {file:prototypePath,before:prototypeText,after:prototypeChange.unchanged?prototypeText:prototypeChange.recordAfter?json(prototypeChange.recordAfter):null}];
+ return {changes,summary:{host:'codebuddy',scope:options.scope,base,product:product||null,action,groups:ids,changed:changes.some(item=>item.before!==item.after),
+  enabledGroups:[...Object.keys(upstream.recordAfter?.groups||{}),...((prototypeChange.unchanged?prototype:prototypeChange.recordAfter)?['prototype']:[])],
+  ...(prototypeChange.summary?.transcript?{transcript:prototypeChange.summary.transcript}:{}),
+  next:product==='cli'?'Review /hooks in CodeBuddy Code and start a new session.':'Reload CodeBuddy and verify actual Hook events. Registration is not activation.'}};
+}
+function check(options) {
+ const {P,R}=modules(),{project,base}=location(options),io=R.fileIO,ids=selection(options.groups,options.action||'check'),settingsText=io.read(path.join(base,'settings.json')),settings=config(settingsText),deps=dependencies(),items=[];
+ let record=null,error=null;try{record=require('./codebuddy-upstream.cjs').registration(base);}catch(e){error=e.message;}
+ for(const id of ids) {
+  const item=catalog.find(x=>x.id===id),entry=path.join(base,'i3-composer-agent/hooks',id==='prototype'?'i3-prototype.cjs':'codebuddy-upstream.cjs');
+  if(id==='prototype'){try{const result=P.check({...options,project});items.push({...item,...result,...(result.effective===false&&result.status!=='failed'?{status:'shadowed'}:{}),entryPath:entry});}catch(e){items.push({...item,status:'failed',reason:e.message,entryPath:entry});}continue;}
+  const missingFiles=[entry,...item.files.map(file=>path.join(base,'i3-composer-agent/hooks',file))].filter(file=>!fs.existsSync(file));
+  const row={...item,entryPath:entry,filesPresent:missingFiles.length===0,missingFiles,status:missingFiles.length?'not-installed':'files-present',invocationVerified:false,nativeValidation:'pending-user'};
+  try{requirements(id,deps);}catch(e){row.dependencyIssue=e.message;}
+  if(error){row.status='failed';row.reason=error;}
+  else if(record?.groups[id])try {
+   const U=require('./codebuddy-upstream.cjs'),selected=U.effective({project,product:record.product,group:id,home:options.home,env:options.env});row.effective=selected?.base===base;
+   row.status=!row.effective?'shadowed':record.product==='cli'?'pending-host-review':'registered';
+   const raw=io.read(path.join(base,'state/i3-composer-agent/hook-observations',U.projectKey(project),id+'.json'));
+   if(raw){const observation=JSON.parse(raw);if(observation.settingsDigest===record.settingsDigest&&observation.scriptDigest===record.groups[id].scriptDigest){row.observation=observation;row.status=row.effective?'triggered':row.status;}}
+   row.product=record.product;row.productVersion=record.productVersion;
+  }catch(e){row.status='failed';row.reason=e.message;}
+  items.push(row);
+ }
+ return {host:'codebuddy',scope:options.scope,base,readOnly:true,changed:false,status:items.some(item=>item.status==='failed')?'failed':'checked',hooks:items,unmanagedHooks:unmanaged(settings),
+  next:'files-present is not enabled; registered is not triggered; triggered is not business acceptance. CLI: review /hooks; IDE: reload.'};
+}
+function configure(options){const change=prepare(options);return options.preview?change.summary:apply(change);}
+function main(argv=process.argv.slice(2)) {
+ if(argv.includes('--help'))return {usage:'node manage.cjs list|check|enable|disable --host codebuddy --scope project|global --project <directory> [--groups <ids>|all] [--product ide|cli] [--skill-routing hook] [--transcript-root <native-directory>|auto]',hooks:catalog,default:'keep; enable/disable default prototype; list/check default all; transcripts auto for new registrations',nativeValidation:'pending-user'};
+ const options={action:argv.shift()||'list',host:'codebuddy',project:process.cwd()};
+ assert.ok(['list','check','enable','disable','keep'].includes(options.action),'Choose list, check, enable or disable');
+ while(argv.length){const arg=argv.shift();assert.ok(arg.startsWith('--')&&argv[0]&&!argv[0].startsWith('--'),'Hook option needs a value');const key=arg.slice(2).replace(/-([a-z])/g,(_,c)=>c.toUpperCase());assert.ok(['host','scope','project','product','productVersion','transcriptRoot','groups','skillRouting'].includes(key),'Unknown Hook option');options[key]=argv.shift();}
+ if(options.skillRouting!==undefined)assert.ok(['native','hook'].includes(options.skillRouting),'skill-routing must be native or hook');
+ return ['list','check'].includes(options.action)?check(options):configure(options);
+}
+module.exports={OWNER,catalog,digest,sha,json,quote,config,selection,modules,validateOwned,requirements,planUpstream,apply,dependencies,location,unmanaged,pendingSimplify,prepare,check,configure,main};
+if(require.main===module)try{const result=main();process.stdout.write(json(result));if(result.status==='failed')process.exitCode=1;}catch(error){process.stderr.write(error.message+'\n');process.exitCode=1;}

package/package.json

@@ -183,17 +183,32 @@
     "scripts/lib/prototype-fixture.cjs",
     "scripts/lib/skill-lint-test.js",
     "scripts/lib/skill-lint.js",
+    "scripts/prototype-cache-test.js",
+    "scripts/prototype-generation-entry-test.js",
+    "scripts/prototype-generation-evidence-test.js",
+    "scripts/prototype-generation-native-test.js",
+    "scripts/prototype-generation-test.js",
+    "scripts/prototype-inventory-test.js",
     "scripts/prototype-locations-test.js",
+    "scripts/prototype-project-test.js",
     "scripts/run-evals-test.js",
     "scripts/run-evals.js",
     "scripts/run-regressions.js",
     "scripts/template-adapter-test.js",
+    "scripts/ui-prototype-codebuddy-hook-test.js",
     "scripts/ui-prototype-content-test.js",
     "scripts/ui-prototype-dependencies-test.js",
     "scripts/ui-prototype-devtools-test.js",
+    "scripts/ui-prototype-execution-evidence-test.js",
+    "scripts/ui-prototype-execution-gates-test.js",
+    "scripts/ui-prototype-execution-policy-test.js",
+    "scripts/ui-prototype-execution-runtime-test.js",
+    "scripts/ui-prototype-ide-source-test.js",
     "scripts/ui-prototype-native-test.js",
+    "scripts/ui-prototype-registration-test.js",
     "scripts/ui-prototype-template-test.js",
     "scripts/ui-prototype-test.js",
+    "scripts/ui-prototype-transcript-auto-test.js",
     "scripts/validate-artifact-paths-test.js",
     "scripts/validate-artifact-paths.js",
     "scripts/validate-commands-test.js",
@@ -386,17 +401,32 @@
       "scripts/lib/prototype-fixture.cjs",
       "scripts/lib/skill-lint-test.js",
       "scripts/lib/skill-lint.js",
+      "scripts/prototype-cache-test.js",
+      "scripts/prototype-generation-entry-test.js",
+      "scripts/prototype-generation-evidence-test.js",
+      "scripts/prototype-generation-native-test.js",
+      "scripts/prototype-generation-test.js",
+      "scripts/prototype-inventory-test.js",
       "scripts/prototype-locations-test.js",
+      "scripts/prototype-project-test.js",
       "scripts/run-evals-test.js",
       "scripts/run-evals.js",
       "scripts/run-regressions.js",
       "scripts/template-adapter-test.js",
+      "scripts/ui-prototype-codebuddy-hook-test.js",
       "scripts/ui-prototype-content-test.js",
       "scripts/ui-prototype-dependencies-test.js",
       "scripts/ui-prototype-devtools-test.js",
+      "scripts/ui-prototype-execution-evidence-test.js",
+      "scripts/ui-prototype-execution-gates-test.js",
+      "scripts/ui-prototype-execution-policy-test.js",
+      "scripts/ui-prototype-execution-runtime-test.js",
+      "scripts/ui-prototype-ide-source-test.js",
       "scripts/ui-prototype-native-test.js",
+      "scripts/ui-prototype-registration-test.js",
       "scripts/ui-prototype-template-test.js",
       "scripts/ui-prototype-test.js",
+      "scripts/ui-prototype-transcript-auto-test.js",
       "scripts/validate-artifact-paths-test.js",
       "scripts/validate-artifact-paths.js",
       "scripts/validate-commands-test.js",
@@ -408,7 +438,7 @@
       "scripts/validate-versions.js"
     ]
   },
-  "version": "2.3.2",
+  "version": "2.3.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/49780522/i3-composer-agent.git"

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "i3-composer-agent",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "覆盖需求、计划、开发、测试、审查与发布的软件工程技能，默认使用简体中文。",
   "homepage": "https://github.com/49780522/i3-composer-agent",
   "repository": "https://github.com/49780522/i3-composer-agent"

package/scripts/prototype-cache-test.js

@@ -0,0 +1,55 @@
+'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 installation = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(installation) ? require(installation).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const scripts = path.join(skills, 'i3-ui-prototype/scripts'), cache = require(path.join(scripts, 'browser-workspace.cjs'));
+function fixture(t, scope = 'project') {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'i3-browser-output-'))), project = path.join(root, '中文 项目'), home = path.join(root, 'isolated-home');
+  fs.mkdirSync(project); fs.mkdirSync(home); t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  return { root, project, home, host: 'codebuddy', scope, runId: 'output-test', env: {} };
+}
+for (const scope of ['project', 'global']) test(`${scope} browser output is prepared only under its host cache and can be reused without overwriting files`, t => {
+  const options = fixture(t, scope), result = cache.prepare(options);
+  assert.equal(result.status, 'prepared');
+  assert.ok(result.directory.startsWith(scope === 'global' ? options.home : path.join(options.project, '.codebuddy')));
+  assert.equal(fs.existsSync(path.join(options.project, '.playwright-cli')), false);
+  assert.equal(fs.existsSync(path.join(options.project, 'prototypes')), false);
+  const config = JSON.parse(fs.readFileSync(result.configFile));
+  assert.equal(config.outputDir, result.directory); assert.equal(config.outputMode, 'file');
+  fs.writeFileSync(path.join(result.directory, 'keep.txt'), 'keep');
+  assert.equal(cache.prepare(options).directory, result.directory);
+  assert.equal(fs.readFileSync(path.join(result.directory, 'keep.txt'), 'utf8'), 'keep');
+  if (scope === 'global') assert.deepEqual(fs.readdirSync(options.project), []);
+});
+test('CLI wrapper uses an existing explicit Node entry, cache cwd and configured output without installing anything', t => {
+  const options = fixture(t), entry = path.join(options.root, 'fixture-cli.cjs');
+  fs.writeFileSync(entry, 'const f=require("node:fs"),p=require("node:path");const c=JSON.parse(f.readFileSync(process.argv[process.argv.indexOf("--config")+1]));if(c.outputDir!==process.cwd())process.exit(5);f.writeFileSync(p.join(c.outputDir,"snapshot.yml"),"fixture snapshot");console.log("fixture command executed");');
+  const result = cache.runCli({ ...options, cli: entry, command: ['snapshot'] });
+  assert.equal(result.status, 'executed'); assert.equal(result.exitCode, 0);
+  assert.ok(fs.existsSync(path.join(result.directory, 'snapshot.yml')));
+  assert.equal(fs.existsSync(path.join(options.project, '.playwright-cli')), false);
+  assert.throws(() => cache.runCli({ ...options, cli: entry, command: ['--config=other.json', 'snapshot'] }), /config/i);
+});
+test('explicit evidence archiving preserves candidate identity and survives cache removal', t => {
+  const options = fixture(t), output = cache.prepare(options), native = require(path.join(scripts, 'native-pilot-lib.cjs'));
+  const scope = { schemaVersion: 2, moduleIds: ['assets'], title: '资产', pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page', regions: [{ id: 'list', mode: 'management-list' }] }], requirements: [{ id: 'A-01', text: '资产操作', pages: ['assets'], source: { type: 'prd', reference: 'fixture/A-01', statement: 'Synthetic fixture, not real acceptance.' } }], exemptions: [] };
+  const file = path.join(options.root, 'scope.json'); fs.writeFileSync(file, JSON.stringify(scope));
+  const prototype = native.createPrototype({ project: options.project, id: 'assets', scope: file, expertMode: 'template' }).directory, before = native.manifest(prototype);
+  fs.writeFileSync(path.join(output.directory, 'page.yml'), 'synthetic snapshot, not acceptance');
+  const archived = cache.archive({ ...options, id: 'assets', files: ['page.yml'] });
+  assert.equal(archived.status, 'archived'); assert.equal(archived.verification, 'not-assessed');
+  assert.deepEqual(native.manifest(prototype), before);
+  fs.rmSync(output.directory, { recursive: true });
+  assert.equal(fs.readFileSync(path.join(archived.directory, 'page.yml'), 'utf8'), 'synthetic snapshot, not acceptance');
+  assert.throws(() => cache.archive({ ...options, id: 'assets', files: ['../scope.json'] }), /path|cache|exist/i);
+});
+test('unsafe run identifiers and absent CLI entries fail before cache creation', t => {
+  const options = fixture(t);
+  assert.throws(() => cache.prepare({ ...options, runId: '../outside' }), /identifier|path/i);
+  assert.throws(() => cache.runCli({ ...options, cli: path.join(options.root, 'missing.cjs'), command: ['snapshot'] }));
+  assert.deepEqual(fs.readdirSync(options.project), []);
+});

package/scripts/prototype-generation-entry-test.js

@@ -0,0 +1,6 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),vm=require('node:vm');
+const install=path.join(__dirname,'lib/installation.js'),skills=fs.existsSync(install)?require(install).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills');const root=path.join(skills,'i3-ui-prototype'),lib=require(path.join(root,'scripts/native-pilot.cjs'));
+const hash=()=>require('node:crypto').createHash('sha256').update(fs.readFileSync(path.join(root,'assets/templates/enterprise-admin/template-inventory.json'))).digest('hex');
+test('template discovery and inventory commands remain read-only and expose real supported choices',async()=>{const before=hash();const options=await lib.main(['generation-options','--template','enterprise-admin']);assert.equal(options.readOnly,true);assert.equal(Object.keys(options.choices.layout).length,4);assert.equal(Object.keys(options.choices.style).length,3);assert.ok(options.patterns['tree-table']);const inventory=await lib.main(['inventory']);assert.equal(inventory.events,595);assert.equal(inventory.components,116);assert.equal(hash(),before);await assert.rejects(()=>lib.main(['generation-options','--template','../bad']));});
+test('offline preview uses metadata-derived local classic scripts and has valid JavaScript',()=>{const templates=path.join(root,'assets/templates'),context={};vm.runInNewContext(fs.readFileSync(path.join(templates,'generation-options.js'),'utf8'),context);assert.equal(context.I3_GENERATION_OPTIONS[0].id,'enterprise-admin');const html=fs.readFileSync(path.join(templates,'presentation.html'),'utf8');assert.ok(!/type="module"|https?:\/\/|fetch\(/.test(html));for(const block of html.matchAll(/<script(?:\s[^>]*)?>([\s\S]*?)<\/script>/g))new vm.Script(block[1]);assert.equal(require(path.join(root,'scripts/generation-assets.cjs')).refresh(root,{check:true}).status,'passed');});

package/scripts/prototype-generation-evidence-test.js

@@ -0,0 +1,10 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),os=require('node:os'),path=require('node:path');
+const install=path.join(__dirname,'lib/installation.js');const skills=fs.existsSync(install)?require(install).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills');
+const script=path.join(skills,'i3-ui-prototype/scripts/generation-evidence.cjs');
+function fixture(t){const directory=fs.mkdtempSync(path.join(os.tmpdir(),'i3-generation-evidence-'));t.after(()=>fs.rmSync(directory,{recursive:true,force:true}));fs.mkdirSync(path.join(directory,'app/src'),{recursive:true});fs.writeFileSync(path.join(directory,'app/src/Actual.vue'),'<template><a-tree /></template>');return directory;}
+const generation={bindings:[{id:'items/tree/hierarchy',capabilityId:'hierarchy'}],scenarios:[{id:'generation/items/tree/hierarchy/expand',bindingId:'items/tree/hierarchy'}]};
+test('each capability maps to implementation and its exact scenarios before acceptance',t=>{const lib=require(script),dir=fixture(t),fixed=lib.initialize(generation);assert.equal(lib.validateImplementation(dir,generation,fixed).status,'pending');assert.throws(()=>lib.validateImplementation(dir,generation,fixed,{complete:true}),/pending/i);const item=fixed.bindings[0];item.status='implemented';item.components=['Tree'];item.files=[{path:'app/src/Actual.vue',locator:'a-tree'}];assert.equal(lib.validateImplementation(dir,generation,fixed,{complete:true}).status,'implemented');item.scenarioIds=[];assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/scenario/i);});
+test('deleting a binding, pointing to absent code, or using input documents cannot pass',t=>{const lib=require(script),dir=fixture(t),fixed=lib.initialize(generation);fixed.bindings=[];assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/binding/i);fixed.bindings=lib.initialize(generation).bindings;Object.assign(fixed.bindings[0],{status:'implemented',components:['Tree'],files:[{path:'inputs/generation.json',locator:'Tree'}]});assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/implementation|source/i);fixed.bindings[0].files[0].path='app/src/Missing.vue';assert.throws(()=>lib.validateImplementation(dir,generation,fixed),/ENOENT|Missing/);});
+test('browser observations need every scenario, actual actions and immutable evidence bytes',t=>{const lib=require(script),dir=fixture(t);assert.throws(()=>lib.validateObservations(dir,generation,{}),/observation/i);fs.mkdirSync(path.join(dir,'qa'));fs.writeFileSync(path.join(dir,'qa/observation.txt'),'Synthetic test evidence, never a browser result.');const hash=require('node:crypto').createHash('sha256').update(fs.readFileSync(path.join(dir,'qa/observation.txt'))).digest('hex');const report={generationObservations:[{scenarioId:generation.scenarios[0].id,bindingId:generation.bindings[0].id,status:'passed',steps:[{action:'fixture action',target:'fixture tree',observed:'fixture result'}],toolCallIds:['fixture-call'],evidence:[{path:'qa/observation.txt',sha256:hash}]}]};assert.equal(lib.validateObservations(dir,generation,report).invocationVerified,false);report.generationObservations[0].steps=[];assert.throws(()=>lib.validateObservations(dir,generation,report),/step/i);report.generationObservations[0].steps=[{action:'fixture',target:'fixture',observed:'fixture'}];fs.appendFileSync(path.join(dir,'qa/observation.txt'),'changed');assert.throws(()=>lib.validateObservations(dir,generation,report),/evidence/i);});
+test('framework mapping covers all semantic capabilities without device sample assumptions',()=>{const lib=require(script),catalog=require(path.join(skills,'i3-ui-prototype/assets/capabilities/generation.json')),map=lib.framework();assert.deepEqual(Object.keys(map.capabilities).sort(),Object.keys(catalog.capabilities).sort());assert.ok(!JSON.stringify(map).includes('useDevices'));assert.ok(!JSON.stringify(map).includes('21 deterministic'));});

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

@@ -0,0 +1,78 @@
+'use strict';
+const test = require('node:test'), assert = require('node:assert/strict'), fs = require('node:fs'), os = require('node:os'), path = require('node:path');
+const install = path.join(__dirname, 'lib/installation.js');
+const skills = fs.existsSync(install) ? require(install).loadInstallation().skillsDirectory : path.resolve(__dirname, '../skills');
+const root = path.join(skills, 'i3-ui-prototype'), templates = require(path.join(root, 'scripts/template-contract.cjs')), native = require(path.join(root, 'scripts/native-pilot-lib.cjs'));
+const read = file => JSON.parse(fs.readFileSync(file));
+function fixture(t) {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'i3-generation-native-')); t.after(() => fs.rmSync(project, { recursive: true, force: true }));
+  const scope = { schemaVersion: 3, moduleIds: ['assets'], title: '资产', pages: [{ id: 'assets', title: '资产台账', referencePage: 'models-page', regions: [{ id: 'list', mode: 'content', pattern: 'tree-list' }] }], requirements: [{ id: 'A-01', text: '资产层级台账', pages: ['assets'], source: { type: 'prd', reference: 'fixture/A-01', statement: 'Synthetic source fixture only, not acceptance.' } }], generation: { presentation: { layout: 'mixed', style: 'soft', density: 'compact' } } };
+  const file = path.join(project, 'scope.json');fs.writeFileSync(file, JSON.stringify(scope));
+  return { project, scope, file, create: () => native.createPrototype({ project, id: 'assets', scope: file, expertMode: 'template' }) };
+}
+test('schema v3 creation freezes pattern contracts, customer choices and per-region acceptance', t => {
+  const { create, project } = fixture(t), result = create(), inputs = path.join(result.directory, 'inputs');
+  assert.equal(native.inspect(result.directory).status, 'passed');
+  const fixed = read(path.join(inputs, 'generation.json')), config = read(path.join(result.directory, 'app/public/prototype-config.json'));
+  assert.deepEqual(config.presentation, { layout: 'mixed', style: 'soft', density: 'compact' });
+  assert.equal(fixed.pages[0].regions[0].pattern, 'tree-list');
+  assert.ok(read(path.join(inputs, 'acceptance.json')).requiredScenarios.some(id => id.includes('/hierarchy/')));
+  assert.deepEqual(read(path.join(project, 'prototypes/index.json')).prototypes[0].appliesTo, ['assets']);
+  assert.equal(read(path.join(result.directory, 'prototype.json')).business.status, 'needs-adaptation');
+  assert.ok(fs.existsSync(path.join(result.directory, 'app/src/PrototypeShell.vue')));
+});
+test('generation constraints cannot be removed together with their acceptance IDs', t => {
+  const { create } = fixture(t), dir = create().directory, file = path.join(dir, 'inputs/generation.json');
+  const fixed = read(file);fixed.bindings = fixed.bindings.filter(item => item.capabilityId !== 'hierarchy');fs.writeFileSync(file, JSON.stringify(fixed));
+  const candidate = native.manifest(dir);
+  assert.throws(() => native.revise(dir, { revision: 'r002', expectedRevision: candidate.revision, expectedDigest: candidate.digest, acceptInputs: true }), /generation|contract/i);
+});
+test('unsupported and planned native templates are rejected rather than falling back to enterprise', t => {
+  fixture(t);
+  assert.throws(() => templates.loadBundledTemplate('ai-workbench'), /available|Unsupported|planned/);
+  assert.throws(() => templates.loadBundledTemplate('../outside'), /identifier|template/i);
+});
+test('legacy sourced scopes keep the original input contract and no new presentation is forced', t => {
+  const { scope, file, create } = fixture(t); scope.schemaVersion = 2; delete scope.generation; delete scope.pages[0].regions[0].pattern;
+  fs.writeFileSync(file, JSON.stringify(scope)); const dir = create().directory;
+  assert.equal(fs.existsSync(path.join(dir, 'inputs/generation.json')), false);
+  assert.equal(read(path.join(dir, 'app/public/prototype-config.json')).presentation, undefined);
+  assert.equal(native.inspect(dir).status, 'passed');
+});
+test('another registered content template uses its own structure and defaults without a core ID branch', t => {
+  const { project, scope, file } = fixture(t), pack = path.join(project, 'template-pack'), directory = path.join(pack, 'alternate');fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(path.join(pack, 'catalog.json'), JSON.stringify({ defaultTemplate: 'alternate', templates: [{ id: 'alternate', availability: 'available', contentRoot: 'alternate' }] }));
+  fs.writeFileSync(path.join(directory, 'template.json'), JSON.stringify({ id: 'alternate', version: '1.0.0', kind: 'content-reference', entry: 'index.html', definition: 'capability-definition.json' }));
+  fs.copyFileSync(path.join(root, 'assets/capabilities/management.json'), path.join(directory, 'capability-definition.json'));
+  fs.writeFileSync(path.join(directory, 'index.html'), '<script id="prototype-offline-routes">[{"path":"/items","component":"./Items.js"}]</script>\n<template data-source="reference/Items.html">\n<main><h1>另一套内容</h1><template data-component="Button" data-on-click="view">查看</template></main>\n</template>\n');
+  fs.writeFileSync(path.join(directory, 'component-inventory.json'), JSON.stringify({ schemaVersion: 1, components: { Button: { kind: 'framework', capabilities: ['interaction'] } } }));
+  const meta = read(path.join(root, 'assets/templates/enterprise-admin/generation.json'));meta.templateId = 'alternate';meta.shell = null;meta.defaults = { layout: 'topbar', style: 'minimal', density: 'comfortable' };meta.patterns = ['content'];
+  fs.writeFileSync(path.join(directory, 'generation.json'), JSON.stringify(meta));templates.syncTemplate(directory);
+  assert.equal(templates.loadBundledTemplate('alternate', { templatesRoot: pack }).id, 'alternate');
+  scope.pages[0].referencePage = 'items';scope.pages[0].regions[0].pattern = 'content';delete scope.generation.presentation;fs.writeFileSync(file, JSON.stringify(scope));
+  const result = native.createPrototype({ project, id: 'alternate-result', scope: file, templateRoot: directory, expertMode: 'template' });
+  assert.equal(read(path.join(result.directory, 'prototype.json')).template.id, 'alternate');
+  assert.equal(read(path.join(result.directory, 'inputs/generation.json')).presentation.layout, 'topbar');
+  assert.equal(native.inspect(result.directory).status, 'passed');
+});
+test('marking a scaffold adapted cannot bypass the new implementation acceptance gate',t=>{
+  const {create}=fixture(t),dir=create().directory,file=path.join(dir,'prototype.json'),meta=read(file);meta.business.status='adapted';fs.writeFileSync(file,JSON.stringify(meta));
+  const checked=native.inspect(dir,{acceptance:true});assert.equal(checked.status,'failed');assert.match(checked.errors.join(' '),/Implementation pending/);
+  fs.unlinkSync(path.join(dir,'design-system/implementation.json'));assert.equal(native.inspect(dir).status,'failed');
+});
+test('replan refreshes the complete fixed contract atomically and refuses invalid scope or stale identity',t=>{
+ const {create,scope,file}=fixture(t),dir=create().directory,before=native.manifest(dir);assert.equal(typeof native.replan,'function');
+ scope.generation.presentation.layout='topbar';fs.writeFileSync(file,JSON.stringify(scope));
+ const next=native.replan(dir,{scope:file,revision:'r002',expectedRevision:before.revision,expectedDigest:before.digest});assert.equal(next.revision,'r002');
+ assert.equal(read(path.join(dir,'app/public/prototype-config.json')).presentation.layout,'topbar');assert.ok(fs.readFileSync(path.join(dir,'design-system/MASTER.md'),'utf8').includes('布局 topbar'));assert.equal(native.inspect(dir).status,'passed');
+ const stable=native.manifest(dir);scope.generation.presentation.layout='bad-layout';fs.writeFileSync(file,JSON.stringify(scope));
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r003',expectedRevision:stable.revision,expectedDigest:stable.digest}),/choice/);assert.equal(native.manifest(dir).digest,stable.digest);
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r003',expectedRevision:before.revision,expectedDigest:before.digest}),/Stale|changed/);
+});
+test('replan restores fixed bytes if revision admission fails after input writes',t=>{
+ const {create,scope,file}=fixture(t),dir=create().directory,before=native.manifest(dir);scope.generation.presentation.layout='topbar';fs.writeFileSync(file,JSON.stringify(scope));fs.mkdirSync(path.join(dir,'baselines/r002'),{recursive:true});
+ assert.throws(()=>native.replan(dir,{scope:file,revision:'r002',expectedRevision:before.revision,expectedDigest:before.digest}),/frozen/);assert.deepEqual(native.manifest(dir),before);assert.equal(native.inspect(dir).status,'passed');
+});
+test('v3 state keeps recovery compact while exposing pending decisions and exact commands',t=>{
+ const {create}=fixture(t),dir=create().directory,state=native.state(dir,{});assert.equal(state.nextAction,'resolve-generation-decisions');assert.ok(Buffer.byteLength(JSON.stringify(state))<25000);assert.ok(state.commands.replan);assert.ok(state.generation.referenceReview.pendingCount>0);assert.equal(state.scopes.sourceFile,'inputs/scope.json');
+});