@givolt/i3-composer-agent 2.3.3 → 2.3.4

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

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

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

@@ -33,7 +33,7 @@ test('native compact boundaries invalidate loads and mixed-session results are r
 test('effective binding differs by IDE override and CLI merge without writing any settings',()=>{
  const C=require(prototypeScripts+'/codebuddy-context.cjs'),path=require('node:path');
  const texts=new Map(),records=new Map(),project='/work/p',home='/home/user',projectBase=path.join(project,'.codebuddy'),globalBase=path.join(home,'.codebuddy');
- const args={project,home,readText:file=>texts.get(file)||null,loadRegistration:base=>records.get(base)||null};
+ const args={project,home,env:{},readText:file=>texts.get(file)||null,loadRegistration:base=>records.get(base)||null};
  records.set(globalBase,{base:globalBase,product:'ide'});texts.set(path.join(projectBase,'settings.json'),'{}');
  assert.equal(C.select({...args,product:'ide'}),null,'IDE cannot fall back through shadowing project settings');
  records.set(globalBase,{base:globalBase,product:'cli'});assert.equal(C.select({...args,product:'cli'}).base,globalBase);

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

@@ -131,6 +131,19 @@ test('antDv error text or error JSON with exit zero is not successful knowledge'
     assert.equal(deps.check(options).antdv.tool.availability, 'unusable');
   }
 });
+test('local CLI handoff uses the real Node entry with no PATH command and rejects failed business queries',async t=>{
+ const options={...workspace(t),host:'workbuddy'};options.env.PATH='';
+ await installer.install({...options,skills:'antdv'},{prepare:officialFixture,progress(){}});
+ const detected=deps.check(options).antdv.tool;
+ assert.equal(detected.nodePath,process.execPath);assert.equal(detected.invocationVerified,false);
+ const result=deps.query({...options,kind:'info',component:'Table'});
+ assert.equal(result.status,'queried');assert.equal(result.command[0],process.execPath);assert.equal(result.command[1],detected.entry);
+ assert.equal(result.data.name,'Table');assert.equal(result.skillInvocationVerified,false);
+ const file=path.join(resultTool(options),'node_modules/@antdv-next/cli/cli.cjs');
+ fs.writeFileSync(file,'const v=process.argv[process.argv.indexOf("--ver")+1];process.stdout.write(v==="1.5.3"?"Error: missing target knowledge":JSON.stringify({name:"Table",props:[]}));');
+ assert.equal(deps.query({...options,kind:'info',component:'Table',version:'1.5.3'}).status,'failed');
+ assert.throws(()=>deps.query({...options,kind:'upgrade'}),/read-only/);
+});
 function resultTool(options) { return path.join(deps.check(options).locations.toolsDirectory, 'antdv-cli'); }
 for (const host of ['codebuddy', 'workbuddy', 'codex', 'claude-code']) for (const scope of ['project', 'global']) {
   test(`${host} ${scope} optional installation keeps all tools inside the selected host root`, async t => {

package/scripts/ui-prototype-execution-gates-test.js

@@ -36,6 +36,30 @@ test('reading a skill, adapted metadata, or incomplete review mappings cannot pa
  const g=fixture();g.proof.frontend.files=[];assert.equal(G.evaluate(g,'implementation').status,'failed');
  const h=fixture();h.proof.frontend.requirementIds=[];assert.equal(G.evaluate(h,'implementation').status,'failed');
 });
+test('new WorkBuddy implementation uses the shared design gate and rechecks recovery references',()=>{
+ const f=fixture();f.policy=P.create({id:P.AUTO_ID,host:'workbuddy',mode:'template'});
+ Object.assign(f.binding,{host:'workbuddy',identitySource:'native-client',policyDigest:f.policy.digest});f.proof.policyDigest=f.policy.digest;
+ assert.equal(G.evaluate(f,'implementation').status,'passed');
+ f.binding.recovery={status:'recovered',invocations:[{skill:'frontend',toolCallId:'front',resultDigest:f.source.calls[0].resultDigest,requestLine:3,resultLine:4,feedbackLine:1}],retry:{toolCallId:'write'}};
+ assert.equal(G.evaluate(f,'implementation').status,'passed');
+ f.binding.recovery.retry.toolCallId='invented';assert.equal(G.evaluate(f,'implementation').status,'failed');
+ delete f.binding.recovery;f.source.calls.find(call=>call.skill==='antdv').success=false;
+ assert.equal(G.evaluate(f,'implementation').status,'failed','Official loading cannot wait until finalization in the new policy');
+});
+function stageRecoveryFixture(){
+ const f=fixture(),result='native build succeeded';
+ f.source.calls.push({toolCallId:'retry-build',name:'Bash',input:{command:'node /skills/native-pilot.cjs build /work/prototypes/orders'},result,requestLine:13,resultLine:14,success:true,resultDigest:E.sha(result),sessionId:'s1'});
+ f.binding.recovery={status:'recovered',invocations:[],retry:{toolCallId:'retry-build',resultDigest:E.sha(result),kind:'stage',stage:'implementation',operation:'build',feedbackLine:12}};
+ return f;
+}
+test('the shared gate accepts an actual matching successful stage retry after recovery',()=>{
+ const f=stageRecoveryFixture();const result=G.evaluate(f,'implementation');assert.equal(result.status,'passed',result.errors?.join('; '));
+});
+test('stage recovery rejects a wrong operation, stage, root, unsafe command or failed native result',()=>{
+ for(const change of [f=>f.binding.recovery.retry.operation='finalize',f=>f.binding.recovery.retry.stage='delivery',f=>f.source.calls.at(-1).input.command='node /skills/native-pilot.cjs build /other/prototypes/orders',f=>f.source.calls.at(-1).input.command+='; echo fake',f=>f.source.calls.at(-1).success=false,f=>f.binding.recovery.retry.kind='ui-write',f=>f.binding.recovery.retry.feedbackLine=14]){
+  const f=stageRecoveryFixture();change(f);assert.equal(G.evaluate(f,'implementation').status,'failed');
+ }
+});
 test('official query references must be successful, relevant, and version checked',()=>{
  const f=fixture();assert.equal(G.evaluate(f,'design').status,'passed');
  f.proof.official.queries[0].quote='invented';assert.equal(G.evaluate(f,'design').status,'failed');

package/scripts/ui-prototype-execution-policy-test.js

@@ -6,9 +6,18 @@ const P = require(prototypeScripts+'/execution-policy.cjs');
 test('CodeBuddy policy defaults never confuse a PRD scope file with project/global installation scope',()=>{
  const options={host:'codebuddy',scope:'/work/prototypes/.preparation/orders/scope.json'};
  const result=P.creationOptions(options,{name:'i3-composer-agent',scope:'global',agents:['codebuddy']});
- assert.equal(result.scope,options.scope);assert.equal(result.executionPolicy,P.ID);
+ assert.equal(result.scope,options.scope);assert.equal(result.executionPolicy,P.AUTO_ID);
  assert.equal(P.creationOptions({host:'codex'},{name:'i3-composer-agent'}).executionPolicy,undefined);
  assert.equal(P.creationOptions({},null).executionPolicy,undefined);
+ assert.equal(P.creationOptions({},{name:'i3-composer-agent',agents:['workbuddy']}).executionPolicy,P.AUTO_ID);
+ assert.throws(()=>P.creationOptions({},{name:'i3-composer-agent',agents:['codebuddy','workbuddy']}),/actual --host/);
+});
+test('new Buddy policy supports WorkBuddy without changing the legacy policy',()=>{
+ const old=P.create();assert.equal(old.id,'codebuddy-ab-v1');assert.equal(old.schemaVersion,1);
+ const policy=P.create({host:'workbuddy',id:P.AUTO_ID});assert.equal(policy.host,'workbuddy');
+ assert.equal(P.validate(policy).id,'buddy-ab-v2');assert.deepEqual(policy.recovery,{perMissing:2,total:6});
+ assert.ok(P.requirements(policy,'implementation').includes('antdv'));
+ assert.throws(()=>P.create({host:'workbuddy',id:P.ID}),/legacy|CodeBuddy/);
 });
 
 test('analysis and inspection never acquire implementation requirements', () => {
@@ -31,6 +40,8 @@ test('official framework fallback is explicit and cannot invent a native invocat
   assert.ok(P.requirements(P.create({ officialCallable: false }), 'design').includes('official-source'));
   assert.equal(P.skillKey('fake-i3-frontend-ui-engineering'), null);
   assert.equal(P.skillKey('i3-frontend-ui-engineering'), 'frontend');
+  assert.equal(P.skillKey('ui-ux-pro-max:ui-ux-pro-max'),'uiux');
+  assert.equal(P.skillKey('arbitrary:ui-ux-pro-max'),null);
 });
 test('policy changes are detected and unsupported hosts cannot silently acquire CodeBuddy support', () => {
   const policy = P.create({ mode: 'template' });

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

@@ -0,0 +1,72 @@
+'use strict';
+const test=require('node:test'),assert=require('node:assert/strict'),path=require('node:path'),fs=require('node:fs');
+const installation=path.join(__dirname,'lib/installation.js');
+const scripts=path.join(fs.existsSync(installation)?require(installation).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');
+const E=require(path.join(scripts,'execution-evidence.cjs')),P=require(path.join(scripts,'execution-policy.cjs'));
+const R=()=>require(path.join(scripts,'execution-recovery.cjs'));
+const source=()=>({prompts:[{line:1,digest:'actual-user-task',text:'实现原型'}],calls:[],contextLine:0});
+test('missing frontend returns the actual Skill and concrete retry instruction',()=>{
+ const missing=R().missing({source:source(),binding:{sessionId:'s1',entryLine:1,contextLine:0},policy:P.create({id:P.AUTO_ID,mode:'template'})});
+ assert.ok(missing.includes('frontend'));assert.ok(missing.includes('antdv'));
+ const message=R().instruction(missing);assert.match(message,/i3-frontend-ui-engineering/);assert.match(message,/成功|success/);assert.match(message,/重试|retry/);
+});
+test('recovery correlates a later successful native Skill and a successful retry',()=>{
+ const index={bindings:{}},s=source(),context={source:s,sessionId:'s1',directory:'/p/prototypes/a',event:'PreToolUse',eventKey:'denied-write-1'};
+ const denied={deny:true,missing:['frontend'],reason:'missing frontend'};
+ const first=R().record(index,context,denied);assert.equal(first.recovery.status,'required');
+ R().record(index,context,denied);assert.equal(Object.values(index.recoveries)[0].total,1,'Duplicate callbacks do not spend another attempt');
+ const rows=[{type:'user',sessionId:'s1',message:{content:'实现原型'}},{type:'assistant',sessionId:'s1',message:{content:[{type:'tool_use',id:'real-front',name:'Skill',input:{skill:'i3-frontend-ui-engineering'}}]}},{type:'user',sessionId:'s1',message:{content:[{type:'tool_result',tool_use_id:'real-front',content:'Skill loaded successfully'}]}}];
+ s.calls=E.parse(rows.map(row=>JSON.stringify(row)).join('\n'));
+ const ready=R().record(index,{...context,eventKey:'retry-2'},{continue:true});assert.equal(ready.recovery.status,'ready-to-retry');
+ const recovered=R().record(index,{...context,event:'PostToolUse',eventKey:'retry-2-result',retrySucceeded:true,retry:{toolCallId:'retry-write',requestLine:4,resultLine:5}},{continue:true});
+ assert.equal(recovered.recovery.status,'recovered');assert.equal(recovered.recovery.invocations[0].toolCallId,'real-front');
+});
+test('failed and stale Skill results do not recover and Stop correction is bounded across begin calls',()=>{
+ const index={bindings:{}},s=source(),context={source:s,sessionId:'s1',directory:'/p/prototypes/a',event:'Stop'};
+ s.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:false}];
+ const feedback={feedback:true,missing:['frontend'],reason:'load frontend'};
+ for(let n=1;n<=2;n++)assert.equal(R().record(index,{...context,eventKey:'stop-'+n},feedback).feedback,true);
+ index.bindings={};
+ const exhausted=R().record(index,{...context,eventKey:'stop-3'},feedback);assert.equal(exhausted.feedback,undefined);assert.equal(exhausted.recovery.status,'blocked');assert.match(exhausted.context,/阻塞/);
+ const denied=R().record(index,{...context,event:'PreToolUse',eventKey:'write-3'},{deny:true,missing:['frontend'],reason:'load frontend'});assert.equal(denied.deny,true);
+ s.contextLine=10;s.calls=[{skill:'frontend',sessionId:'s1',requestLine:2,resultLine:3,success:true}];
+ assert.notEqual(R().record(index,{...context,eventKey:'old-load'},{continue:true}).recovery.status,'recovered');
+});
+test('flat native Hook feedback remains metadata and cannot reset the human task or recovery budget',()=>{
+ const rows=[{type:'message',role:'user',sessionId:'s1',content:[{type:'input_text',text:'实现原型'}]},{type:'message',role:'user',sessionId:'s1',providerData:{isMeta:true},content:[{type:'input_text',text:'补调 frontend 后继续'}]}];
+ const text=rows.map(row=>JSON.stringify(row)).join('\n');
+ assert.equal(E.describe(text).prompts.length,1);assert.equal(E.describe(text).prompts[0].text,'实现原型');
+});
+test('a missing Skill has one budget even when the set of other missing Skills changes',()=>{
+ const index={},context={source:source(),sessionId:'s1',directory:'/p/prototypes/a',event:'Stop'};
+ for(const [n,missing] of [['1',['frontend','antdv']],['2',['frontend']]])assert.equal(R().record(index,{...context,eventKey:n},{feedback:true,missing}).feedback,true);
+ const third=R().record(index,{...context,eventKey:'3'},{feedback:true,missing:['frontend','uiux']});
+ assert.equal(third.recovery.status,'blocked');assert.equal(third.feedback,undefined);assert.equal(third.recovery.counts.frontend,2);
+});
+test('native output resumes Stop for recovery and shows the user an exhausted-budget warning',()=>{
+ const format=require(path.join(scripts,'hosts/codebuddy.cjs')).format;
+ assert.deepEqual(format({feedback:true,reason:'补调'},'Stop').output,{continue:false,reason:'补调'});
+ const blocked=format({context:'当前仍被阻塞',recovery:{status:'blocked'}},'Stop').output;
+ assert.equal(blocked.continue,true);assert.equal(blocked.systemMessage,'当前仍被阻塞');
+ assert.equal(format({deny:true,reason:'缺 Skill'},'PreToolUse').output.hookSpecificOutput.permissionDecision,'deny');
+ assert.equal(format({continue:true,context:'实施前加载'},'UserPromptSubmit').output.hookSpecificOutput.additionalContext,'实施前加载');
+});
+test('a stage evidence recovery requires the same verified stage and its successful native retry',()=>{
+ const index={},context={source:source(),sessionId:'s1',directory:'/p/prototypes/a',event:'PreToolUse',eventKey:'denied-build',stage:'implementation'};
+ R().record(index,context,{deny:true,missing:['execution-evidence']});
+ const other=R().record(index,{...context,eventKey:'another-stage',stage:'browser-entry',resolved:['execution-evidence'],retrySucceeded:true,event:'PostToolUse'},{continue:true});
+ assert.equal(other.recovery.status,'required');
+ const ready=R().record(index,{...context,eventKey:'verified-build',resolved:['execution-evidence']},{continue:true});
+ assert.equal(ready.recovery.status,'ready-to-retry');
+ const retry=R().record(index,{...context,eventKey:'successful-build',resolved:['execution-evidence'],retrySucceeded:true,event:'PostToolUse',retry:{toolCallId:'actual-build-result',requestLine:4,resultLine:5}},{continue:true});
+ assert.equal(retry.recovery.status,'recovered');assert.equal(retry.recovery.retry.toolCallId,'actual-build-result');
+});
+test('an old successful callback cannot recover a later stage denial',()=>{
+ const s=source();s.calls=[{toolCallId:'old',requestLine:2,resultLine:3,success:true}];
+ const index={},context={source:s,sessionId:'s1',directory:'/p/prototypes/a',stage:'implementation'};
+ R().record(index,{...context,event:'PreToolUse',eventKey:'deny'},{deny:true,missing:['execution-evidence']});
+ const stale=R().record(index,{...context,event:'PostToolUse',eventKey:'old-result',resolved:['execution-evidence'],retrySucceeded:true,retry:s.calls[0]},{continue:true});
+ assert.equal(stale.recovery.status,'ready-to-retry');
+ const current=R().record(index,{...context,event:'PostToolUse',eventKey:'new-result',resolved:['execution-evidence'],retrySucceeded:true,retry:{toolCallId:'new',requestLine:4,resultLine:5}},{continue:true});
+ assert.equal(current.recovery.status,'recovered');assert.equal(current.recovery.retry.feedbackLine,3);
+});

package/skills/i3-ui-prototype/SKILL.md

@@ -61,9 +61,9 @@ CodeBuddy 新建原型采用 A＋B 执行合同，实际接口见 [execution-evi
 
 项目／全局 IDE／CLI 新启用默认从真实 Hook 的 `transcript_path` 自动取得当前会话文件；不让模型搜索／填写日志、不选择最近文件。`transcript.status=awaiting-native-event` 表示尚未观察，不阻止启动已授权任务及 `execution-begin`；进入制作和交付仍必须有可解析的原生证据。已有手动目录限制保持，可由用户显式切回 auto；缺字段、不可读、格式不支持或会话不符时报告未核验，不能用手写记录补齐。
 
-CodeBuddy create 前，用 `native-pilot.cjs execution-assertions-template --scope <scope-file>` 取得完整场景，按本次 PRD 与能力参数填充每项预期 JSON 事实，存于该原型 `.preparation` 目录。create 增加 `--host codebuddy --execution-policy codebuddy-ab-v1 --execution-assertions <assertions-file>`；官方 Skill 真实不可用时才显式 `--official-source-fallback`，保留其失败调用定位。随后在实际 CodeBuddy 主会话执行 `execution-begin <prototype-root>`，以原生 Skill 工具加载当前上下文需要的前端 Skill 后再写业务界面。其他宿主尚未适配此 Hook 合同，按原流程披露调用核验边界。
+CodeBuddy／WorkBuddy 新 create 前，用 `native-pilot.cjs execution-assertions-template --scope <scope-file>` 取得完整场景，按本次 PRD 与能力参数填充每项预期 JSON 事实，存于该原型 `.preparation` 目录。create 增加 `--host <codebuddy|workbuddy> --execution-policy buddy-ab-v2 --execution-assertions <assertions-file>`；官方 Skill 真实不可用时才显式 `--official-source-fallback`，保留其失败调用定位。随后在实际所选宿主主会话执行 `execution-begin <prototype-root>`，以原生 Skill 工具加载当前上下文需要的前端 Skill 后再写业务界面。旧 codebuddy-ab-v1 及未采用 executionPolicy 的实例保留原合同。其他宿主尚未适配此 Hook 合同，按原流程披露调用核验边界。
 
-`execution-template <prototype-root>` 返回当前身份与已观察到的真实加载引用；以实际查询、实现复核及浏览器结果补齐 `qa/execution-evidence.json`，不能补造调用 ID。构建、record-run、record-devtools-review、finalize 与 `execution-check --stage <stage>` 共用 A；B 在可识别的写入前检查，在 Stop 对可观察的完成声明给一次缺项反馈。只读分析、进度、阻塞及用户停止可正常结束。未通过门禁时交付候选和缺项；新收据的 `native-source-correlated` 不代表不可篡改认证或用户认可。
+`execution-template <prototype-root>` 返回当前身份与已观察到的真实加载引用；以实际查询、实现复核及浏览器结果补齐 `qa/execution-evidence.json`，不能补造调用 ID。构建、record-run、record-devtools-review、finalize 与 `execution-check --stage <stage>` 共用 A；B 在可识别的写入前检查，反馈明确 Skill 名与下一动作，成功补调后重试；Stop 按同缺项两次、当前原生任务总计六次的预算继续纠正，到上限如实报告阻塞，反复 begin 不清零。只读分析、进度、阻塞及用户停止可正常结束。未通过门禁时交付候选和缺项；新收据的 `native-source-correlated` 不代表不可篡改认证或用户认可。
 
 ### 2. 完整内容模板与需求能力
 
@@ -102,6 +102,8 @@ UIUX 和框架官方 Skill 独立可选安装，不随本技能默认复制。cr
 
 加载框架官方 Skill 或对应版本官方文档、类型和源码，先查 API、读示例、再实现。先完成上文工具预检，使用已准备的固定本地 CLI；缺项不因官方 Skill 的安装建议而扩大权限。固定项目依赖锁，记录请求与实际知识版本。映射与官方来源见 [framework-contract.md](references/framework-contract.md)。
 
+antDv Skill 成功加载后，优先使用只读命令 `node <skill-root>/scripts/prototype-dependencies.cjs query --host <host> --scope project --project <project-root> --kind info --component <Component> --version <knowledge-version>`，它解析当前宿主本地 Node／CLI 入口，不依赖全局 `antdv` PATH。也可使用检测返回的绝对 Node 和 CLI 入口执行官方只读查询。query 返回不代表 Skill 调用；组件版本与知识版本分别记录，不足时核对目标包类型／源码。官方 Skill 的 allowed-tools／原生权限若不允许实际入口，按原生权限流程处理，不编辑官方正文绕过。
+
 宿主已发现可调用的官方框架 Skill 时，先通过真实 Skill 工具加载它；读取 SKILL.md 或运行 CLI 查询不能冒充宿主 Skill 调用。只有该 Skill 在当前执行者中不可调用时，才使用版本匹配的官方文档／类型／源码等效渠道，并明确记录官方 Skill 未唤醒及实际资料来源。UIUX 的 Skill 调用、真实查询、建议采纳与效果验证也分别记录，查询成功不自动记 used。
 
 ```sh
@@ -110,7 +112,7 @@ node <skill-root>/scripts/native-pilot.cjs create --project <project-root> --id
 node <skill-root>/scripts/native-pilot.cjs create --project <project-root> --id business-demo --scope <project-root>/prototypes/.preparation/business-demo/scope.json --expert-mode template
 ```
 
-目标存在则 revise，不重新初始化。Follow the `i3-frontend-ui-engineering` skill，使用真实 Table／Form／Drawer／反馈组件及 ConfigProvider。初始化只产生需求对应的框架骨架和四主题，business.status 为 needs-adaptation；这不是已完成业务。实现固定输入中的实际字段、列表和流程，逐个填写 `design-system/implementation.json` 的实际组件、源文件／定位符和固定场景，再核对需求映射、模拟数据并更新 business.status 为 adapted。UIUX 采用规则落实到 design-system、主题和页面；模板样式不锁定生成外观。
+目标存在则 revise，不重新初始化。首次业务 UI 写入前必须通过宿主 Skill 工具成功调用 `i3-frontend-ui-engineering`；不得仅凭当前 Skill 中的摘要直接实现。收到门禁反馈时立即补调、等待成功返回并重试原操作，失败则报告具体阻塞，不能推迟到下次修订。Follow the `i3-frontend-ui-engineering` skill，使用真实 Table／Form／Drawer／反馈组件及 ConfigProvider。初始化只产生需求对应的框架骨架和四主题，business.status 为 needs-adaptation；这不是已完成业务。实现固定输入中的实际字段、列表和流程，逐个填写 `design-system/implementation.json` 的实际组件、源文件／定位符和固定场景，再核对需求映射、模拟数据并更新 business.status 为 adapted。UIUX 采用规则落实到 design-system、主题和页面；模板样式不锁定生成外观。
 
 目标存在但没有 prototype.json 时属于未识别的准备目录，不能当作有效实例执行 revise。先核对来源并保留文件；只有从本次工具记录确认整个目标目录均由当前任务的准备操作产生，才可将该整个目录移到独立准备位置，确保目标路径不存在后重试原子 create。仅移动查询文件仍会留下空目录并阻止 create。来源不明或包含用户已有文件时保留原目录并报告冲突，不得覆盖或清空。
 

package/skills/i3-ui-prototype/assets/hosts/codebuddy/profile.json

@@ -1,13 +1,17 @@
 {
-  "schemaVersion": 1,
-  "id": "codebuddy-command-v1",
+  "schemaVersion": 2,
+  "id": "buddy-command-auto-v2",
   "nativeValidation": "pending-user",
   "platforms": ["darwin", "linux"],
+  "hosts": ["codebuddy", "workbuddy"],
   "events": ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"],
-  "transcriptFormat": "assistant-user-tool-use-jsonl-v1",
+  "transcriptFormat": ["assistant-user-tool-use-jsonl-v1", "flat-message-function-call-jsonl", "codebuddy-ide-index-v1"],
   "products": {
-    "ide": {"settings": "settings.json", "configuration": "project-overrides-global", "transcriptRoot": "native-hook-transcript-path", "manualTranscriptRoot": true, "nativeReview": "reload-and-verify"},
-    "cli": {"settings": "settings.json", "configuration": "merged-project-first-binding", "transcriptRoot": "native-hook-transcript-path", "manualTranscriptRoot": true, "configRootEnvironment": "CODEBUDDY_CONFIG_DIR", "nativeReview": "/hooks"}
+    "ide": {"settings": "settings.json", "configuration": "codebuddy-project-overrides-global; workbuddy-merged", "transcriptRoot": "native-hook-transcript-path", "nativeReview": "reload-and-verify"},
+    "cli": {"settings": "settings.json", "configuration": "merged-project-first-binding", "transcriptRoot": "native-hook-transcript-path", "nativeReview": "/hooks"}
   },
-  "sources": ["https://www.codebuddy.cn/docs/ide/Features/Hooks", "https://www.codebuddy.cn/docs/cli/hooks", "https://www.codebuddy.cn/docs/cli/env-vars"]
+  "identification": "Explicit native client, or a callback log in a configured native host projects directory; unknown/conflicting identity remains unverified.",
+  "recovery": {"perMissing": 2, "total": 6, "doesNotForceNextTool": true},
+  "sources": ["https://www.codebuddy.cn/docs/ide/Features/Hooks", "https://www.codebuddy.cn/docs/cli/hooks", "https://www.codebuddy.cn/docs/workbuddy/From-Beginner-to-Expert-Guide/Function-Description/Plug-In"],
+  "localSourceInspection": {"workbuddy": "5.8.3 bundled CLI: shared command Hook protocol, config/projects/session JSONL, providerData.isMeta; native runtime acceptance pending"}
 }

package/skills/i3-ui-prototype/references/entry-contract.md

@@ -50,7 +50,7 @@
 
 原生 create／revise 仍按工作流程完成业务适配、设计取舍、构建、全部适用的真实验收和 finalize。交付前只读核对 state 中 `delivery.current`、revision、candidateDigest 与实际 `qa/delivery.json` 收据一致。旧构建、旧 QA 或过期收据不能作为当前成功证据。
 
-本轮 CodeBuddy 新原生流程仍要求主会话实际调用 `i3-browser-testing-with-devtools`，通过 Chrome DevTools MCP 取得当前候选／构建的 DOM／计算样式、截图、console、network、可访问性和性能观测，并执行原型 Playwright 专项补充回归。缺 Skill、MCP 或必需观测时整链未完成。脚本收据和 state 不证明真实调用；原始宿主记录与实际观测另核。其他宿主结果及旧 v1／已有 v2 的固定合同按事实单列，不隐式扩展历史验收。
+本轮 CodeBuddy 新原生流程仍要求主会话实际调用 `i3-browser-testing-with-devtools`，通过 Chrome DevTools MCP 取得当前候选／构建的 DOM／计算样式、截图、console、network、可访问性和性能观测，历史设备合同另外执行其固定 Playwright 专项回归；新完整业务按固定场景执行并 record-run。缺 Skill、MCP 或必需观测时整链未完成。脚本收据和 state 不证明真实调用；原始宿主记录与实际观测另核。其他宿主结果及旧 v1／已有 v2 的固定合同按事实单列，不隐式扩展历史验收。
 
 通过本地验证的候选保持 pending-review。只有真实用户对同一 revision／digest 的明确认可，且适用验收仍当前有效，才能确认基线。原型认可不自动批准工程 Plan、生产开发或发布。Legacy HTML 保留原摘要与运行合同。
 

package/skills/i3-ui-prototype/references/execution-evidence.md

@@ -1,4 +1,4 @@
-# CodeBuddy A＋B 执行合同
+# Buddy A＋B 执行与补调合同
 
 <!-- i3:zh-guide:start -->
 ## 中文使用说明
@@ -8,17 +8,19 @@
 默认使用简体中文解释、追问及生成报告；用户明确要求其他语言时可切换。原方法正文、引用、阈值和审批条件完整保留。代码标识、路径、命令、工具参数、JSON 键/枚举与原文引用保持原样。
 <!-- i3:zh-guide:end -->
 
-本合同首期支持 CodeBuddy 的 command Hooks；IDE、Code CLI 的原生安装与实际日志格式仍须用户手测。不是新增专责 Agent，不改 using 的发现／路由、上游前端／浏览器方法或上游 Hooks。A 是确定性门禁，B 采集与绑定原生来源；没有 C 提示词对照表方案。
+本合同适配 CodeBuddy IDE／CLI 和 WorkBuddy 桌面 command Hooks；各宿主项目／全局的真实调用、补调及业务效果仍须逐项手测，profile 保持 pending-user。不是新增专责 Agent，不改 using 的发现／路由、上游前端／浏览器方法或上游 Hooks。A 是确定性门禁，B 采集与绑定原生来源；没有 C 提示词对照表方案。
 
 ## 安装范围与原生生效
 
-安装器统一使用 `--hooks keep|enable|list|check|disable` 与 `--hook-groups session-start,sdd-cache,simplify-ignore,prototype|all`；默认 keep，启停不指定组时沿用旧用法仅针对 prototype。`--prototype-hooks keep|enable|check|disable` 作为原型组兼容参数保留，`--yes` 不隐含 enable。启用时选择 `--codebuddy-product ide|cli`；记录 `--codebuddy-version` 的实际版本。项目／全局 IDE／CLI 新启用默认 `transcriptMode=auto`，每次从原生 Hook 的 `transcript_path` 取得具体会话文件，不扫描目录或挑选最新日志。`--codebuddy-transcript-root <实际日志绝对目录>` 是可选手动限制；原有 transcriptRoots 注册继续按 manual 限制，不被升级放宽，显式传 `auto` 可切回自动。不能用业务 QA 或人为导出的会话文件；路径自动识别也不证明格式已支持。不把 IDE 示例后缀当成实际格式；协议不支持时来源未核验，不猜工具 ID。
+安装器对 CodeBuddy／WorkBuddy 默认注册 prototype 组，不再询问是否启用、组或 IDE／CLI；非交互同默认。其他原版组仍交付脚本，但不新增注册。已有启用组保留，明确禁用由 state/i3-composer-agent/hooks.json 的 prototypeDisabledHosts 记忆；只有显式 enable 撤销禁用。显式 --hooks keep 保留状态，--hooks enable|list|check|disable 和 --hook-groups 继续作为管理参数；旧 --prototype-hooks 仅管理原型组。新注册 product=auto、schemaVersion=2；旧 ide/cli 注册和参数兼容，可安全升级到 auto，手改和未知归属不接管。
 
-原型 Hook 的新注册入口是 `<host-base>/i3-composer-agent/hooks/i3-prototype.cjs`，委托本 Skill 的 `scripts/hosts/codebuddy.cjs`；旧入口继续兼容。统一管理入口为同目录 `manage.cjs`，原版三组由 `codebuddy-upstream.cjs` 包装，原脚本不改。设置在所选范围 `.codebuddy/settings.json`；原型归属记录继续在 `.codebuddy/state/i3-prototype/installation.json`，通用归属在 `.codebuddy/state/i3-composer-agent/hooks.json`。项目注册引用项目副本，全局注册引用全局副本。保留原设置、权限和其他 Hook；无效 JSON、被手改的自有注册、共享 WorkBuddy 目标或未知配置归属拒绝合并。Windows 命令引用尚未验证，此 B profile 不宣称支持。
+每次仅使用原生 Hook 的 transcript_path 具体文件，校验 session_id、实际项目和工具请求／结果，不扫描最新日志。真实 client 或已配置宿主原生日志位置用于身份识别，身份缺失／冲突不能默认 CLI。WorkBuddy 5.8.3 安装程序源代码表明其桌面使用 CLI 后端协议和原生项目会话 JSONL；本地源代码核对不替代实际回调。--codebuddy-transcript-root／--transcript-root 可设置手动限制，已有 manual roots 不被默认升级放宽；显式 auto 才切回自动。
 
-独立统一管理可调用 `node <host-base>/i3-composer-agent/hooks/manage.cjs list|check|enable|disable --host codebuddy --scope project|global --project <project-root> --groups prototype`。旧 `node <skill-root>/scripts/prototype-hooks.cjs check|enable|disable` 参数保持且只针对 prototype。启用增加 `--product ide|cli`、`--product-version <实际版本>`；可选 `--transcript-root <目录|auto>`。全局配置根遵循绝对 `CODEBUDDY_CONFIG_DIR`，未设置时为 `~/.codebuddy`，工具、注册、状态和运行时选择使用同一根。check 不执行安装、不写配置或缓存。首次没有实际日志时 `transcript.status=awaiting-native-event`，配置可注册但证据尚未核验；不是安装失败，也不算 active。CLI 注册后需用户在原生 `/hooks` 审核，然后新建会话；IDE 需重载。状态为 files-present／registered／pending-host-review／active／failed 等，active 只指展示的项目／会话和当前注册／脚本字节的近期事件。它不代表所有项目已激活或业务已通过。原版三组的 triggered 仅表示包装回调观察，仍是未核验等级。
+原型 Hook 的新注册入口是 `<host-base>/i3-composer-agent/hooks/i3-prototype.cjs`，委托本 Skill 的 `scripts/hosts/codebuddy.cjs`；旧入口继续兼容。统一管理入口为同目录 `manage.cjs`，原版三组由 `codebuddy-upstream.cjs` 包装，原脚本不改。项目设置在 `.codebuddy/settings.json`；全局 CodeBuddy 为 CODEBUDDY_CONFIG_DIR 或 ~/.codebuddy，全局 WorkBuddy 为 WORKBUDDY_CONFIG_DIR 或 ~/.workbuddy。原型归属在 <host-base>/state/i3-prototype/installation.json，通用归属在 <host-base>/state/i3-composer-agent/hooks.json。项目注册引用项目副本，全局注册引用全局副本。保留原设置、权限和其他 Hook；无效 JSON、被手改的自有注册或未知配置归属拒绝合并；共享 Buddy 项目只注册一个入口，hosts 分别记录与禁用。Windows 命令引用尚未验证，此 B profile 不宣称支持。
 
-IDE 对存在的项目设置保守按覆盖处理，不能穿透到全局冒称生效；CLI 在项目／全局合并来源中优先选自有项目绑定，否则全局。未选中的回调退出，选中状态用锁和原生来源游标去重。配置、脚本或 profile 改动使旧观察失效；重复启用不增加注册。disable 仅撤销自有配置，不删除原型与 QA。卸载核心前先 disable，避免悬空自有命令。
+独立统一管理可调用 `node <host-base>/i3-composer-agent/hooks/manage.cjs list|check|enable|disable --host codebuddy|workbuddy --scope project|global --project <project-root> --groups prototype`。旧 `node <skill-root>/scripts/prototype-hooks.cjs check|enable|disable` 参数保持且只针对 prototype。无需指定 product；旧 `--product ide|cli` 兼容，`--product-version <实际版本>` 可记录安装信息；可选 `--transcript-root <目录|auto>`。全局配置根按所选宿主遵循绝对 CODEBUDDY_CONFIG_DIR／WORKBUDDY_CONFIG_DIR，默认 ~/.codebuddy／~/.workbuddy，工具、注册、状态和运行时选择使用同一根。check 不执行安装、不写配置或缓存。首次没有实际日志时 `transcript.status=awaiting-native-event`，配置可注册但证据尚未核验；不是安装失败，也不算 active。CLI 注册后需用户在原生 `/hooks` 审核，然后新建会话；IDE 需重载。状态为 files-present／registered／pending-host-review／active／failed 等，active 只指展示的项目／会话和当前注册／脚本字节的近期事件。它不代表所有项目已激活或业务已通过。原版三组的 triggered 仅表示包装回调观察，仍是未核验等级。
+
+CodeBuddy IDE 对存在的项目设置保守按覆盖处理，不能穿透到全局冒称生效；CodeBuddy CLI／WorkBuddy 在项目／全局合并来源中优先选自有项目绑定，否则全局。未选中的回调退出，选中状态用锁和原生来源游标去重。配置、脚本或 profile 改动使旧观察失效；重复启用不增加注册。disable 仅撤销自有配置，不删除原型与 QA。卸载核心前先 disable，避免悬空自有命令。
 
 ## 新实例的固定预期
 
@@ -28,7 +30,7 @@ IDE 对存在的项目设置保守按覆盖处理，不能穿透到全局冒称
 node <skill-root>/scripts/native-pilot.cjs execution-assertions-template --scope <scope-file>
 ```
 
-返回所有适用业务／框架场景及 `checks: []`。依据 PRD、绑定参数、框架场景填写每项检查，再传 `create --host codebuddy --execution-policy codebuddy-ab-v1 --execution-assertions <file>`。这个读取命令没有写入副作用。文件置于 `prototypes/.preparation/<id>/`；不更改随包 HTML 模板。每个场景至少一条，不能漏场景或用 `passed` 作实际事实；预期随其他 inputs 固定，不在验收后改到与结果一致。
+返回所有适用业务／框架场景及 `checks: []`。依据 PRD、绑定参数、框架场景填写每项检查，再传 `create --host <codebuddy|workbuddy> --execution-policy buddy-ab-v2 --execution-assertions <file>`。这个读取命令没有写入副作用。文件置于 `prototypes/.preparation/<id>/`；不更改随包 HTML 模板。每个场景至少一条，不能漏场景或用 `passed` 作实际事实；预期随其他 inputs 固定，不在验收后改到与结果一致。
 
 ```json
 {"scenarioId":"orders/list/form-validation","checks":[
@@ -59,8 +61,23 @@ node <skill-root>/scripts/native-pilot.cjs execution-assertions-template --scope
 
 `execution-check --stage design|implementation-entry|implementation|build|browser-entry|browser|delivery`、build、record-run、record-devtools-review、finalize 使用同一谓词。state 展示 execution 缺项及恢复命令，finalize 成功收据包含 runId／policyDigest、证据摘要和调用等级；HANDOFF 显示同一结果。修改源码／输入／设计／QA 会使相应检查失效，旧收据不能复用。
 
-B 的 PreToolUse 只拒绝可识别的缺前置 UI 写入或明确阶段命令，不返回强制 allow，不替换原生结果。它不是通用 Shell 文件隔离器；未知 Shell 写法和所有自然语言完成方式不保证被拦截。Stop 对已纳管当前任务、可识别的完成声明且缺有效收据时反馈一次；进度、blocked、awaiting-input、用户停止正常结束，不能无限循环。崩溃／超时不生成成功记录，A 拒绝无有效来源的严格完成。
+B 的 PreToolUse 只拒绝可识别的缺前置 UI 写入或明确阶段命令，不返回强制 allow，不替换原生结果。它不是通用 Shell 文件隔离器；未知 Shell 写法和所有自然语言完成方式不保证被拦截。新 buddy-ab-v2 的 Stop 对已纳管当前任务、可识别的完成声明且缺有效收据时按有限预算反馈；旧 codebuddy-ab-v1 保留原单次反馈合同。进度、blocked、awaiting-input、用户停止正常结束，不能无限循环。崩溃／超时不生成成功记录，A 拒绝无有效来源的严格完成。
 
 本地原文、索引与配置同属用户权限域，`native-source-correlated` 表示受配置来源的逐项回查，不是防篡改签名。文件摘要、chmod、机器落盘或模型自述均不能单独证明可信。若日志本身缺独立可信来源，结果继续披露 unverified，需用户检查真实宿主调用。本测试包原生 profile 状态 pending-user；源码／合成／打包通过不改变它。
 
 旧 HTML／未采用 executionPolicy 的原生实例继续原摘要、输入、场景与基线，不自动迁移，新等级为 unverified。四主题、完整离线 HTML、业务共享索引和 moduleIds→appliesTo 不变；跨宿主可读共享原型，不继承 CodeBuddy 的调用证明。
+
+
+## 补调与恢复验收
+
+首次业务 UI 写入前，当前有效上下文须成功加载前端 Skill；新 buddy-ab-v2 还检查可调用的 antDv Skill 和专业模式 UIUX。阶段命令使用同一 A 谓词，缺 Skill 时反馈准确名称，已有加载但证据缺项时要求 execution-check 和真实引用，不要求重复加载全部 Skill。
+
+B 拒绝后主会话立即补调，等待成功返回，再重试被拒操作；普通 Read 或另开会话不算本主会话 Skill 调用。缺项、反馈事件、后续成功 toolCallId/resultDigest 及重试结果在宿主会话状态落盘。required → ready-to-retry → recovered 分别表示缺项、已可重试、观察到成功重试；recovered 不表示业务验收通过。A 再回查补调及重试的原生引用和时序。
+
+重试按 kind 区分 ui-write 和 stage；阶段重试绑定实际 operation、stage 与同一原型目录。两类新记录都以 feedbackLine 核对请求发生在反馈之后，旧成功回调不能恢复后续拒绝；旧无 kind 的记录继续仅按页面写入合同核验。
+
+默认同一缺项两次、单原生任务总计六次，重复回调不增加预算，反复 begin 和内部 providerData.isMeta 的 Hook 消息不重置任务。达到上限时保持受管操作拒绝，允许真实 blocked 报告正常结束；不无限驱动 Stop。用户只读／暂停优先。入口、Skill 发现、加载成功、CLI 查询、重试成功、交付和用户认可分开记录。
+
+每宿主／范围实测：故意漏调 → 写入被拒且文件未被该操作修改 → 本主会话实际 Skill 成功 → 原操作重试成功；失败调用、旧上下文、假 ID、旧会话及当前构建缺项不能放行。持续缺项须在预算耗尽后报告阻塞。源测试里的合成日志只能验证解析和门禁逻辑，不证明模型会补调。原生 Hooks 没有指定下一工具的执行接口，不能承诺必然调用，也不是任意 Shell 安全隔离。
+
+antDv 加载与本地 CLI 查询分别留证：`prototype-deps query --host <host> --scope project --project <project> --kind info --component Table --version 1.5.2` 经解析的绝对 Node／入口执行，仅引用知识 1.5.2；目标 1.5.3 仍核对包类型／源码。probe 不是业务查询，退出零的错误内容仍失败，不自动安装。

package/skills/i3-ui-prototype/references/interaction-acceptance.md

@@ -39,7 +39,7 @@
 
 固定工具的输入事件也须实际验证：本轮 Chrome DevTools MCP 1.11.0 内捆的短文本 fill 路径对空字符串直接设置 DOM value 后结束，没有发送 input／change，可能使界面为空而查询或校验仍使用旧绑定值。保存原始失败观测。独立真实 MCP 实测可用原生 fill 单个空格使输入活跃，再只读取得实际 value 长度和 selectionStart／selectionEnd；空格可能追加到恢复的旧值，不能假定只有一字。确认光标位于末尾后，按实际文本长度逐次原生 press_key Backspace，核对空值，再查询／保存并核对绑定结果。本轮 headless 的 Meta+A／Control+A 未全选，快捷键须按实际结果核对。不能只看 DOM value 或工具成功文本，也不修改组件库或用 evaluate_script 修补事件。其他版本按实际行为判断。该工具事件限制、宿主 PreToolUse 参数兼容、原型业务缺陷分别诊断，不以其中一项通过代替其他项。
 
-`native-pilot.cjs browser` 的 Playwright 执行器保留原型专项回归，包括确定性能力、故障与隔离检查；它是补充证据，不能代替浏览器 Skill、MCP 调用或上述实际观测。指定的 CodeBuddy 完整链必须同时满足 Skill、DevTools 和专项回归，缺可调用 Skill 或 MCP 时明确 blocked／not-run，最终结果为 partial／blocked。只有补充回归通过时，不将整链写为 complete。
+`native-pilot.cjs browser` 的 Playwright 执行器保留原型专项回归，包括确定性能力、故障与隔离检查；它是补充证据，不能代替浏览器 Skill、MCP 调用或上述实际观测。新完整业务的 CodeBuddy／WorkBuddy 严格链必须满足 Skill、DevTools 和固定业务场景实测；Playwright 执行器仅适用于原设备列表固定合同，缺可调用 Skill 或 MCP 时明确 blocked／not-run，最终结果为 partial／blocked。只有补充回归通过时，不将整链写为 complete。
 
 新 create 将 `browserReview` 要求固定到 inputs/acceptance.json；字段缺失的旧 v2 维持原行为，v1 不迁移。现有实例需明确接受完整验收输入变更后才启用，不在 inspect 中追随全局策略。其他宿主的等效真实浏览器渠道如实单列，不能借其结果宣称这条 CodeBuddy 指定链已通过。
 

package/skills/i3-ui-prototype/references/project-layout.md

@@ -36,7 +36,7 @@ paths 返回的 scope 是安装范围，scopeFile 是准备区 scope.json 的完
 
 ## scope.moduleIds 与 appliesTo
 
-新原生 scope 使用 schemaVersion=2，moduleIds 为数组，例如 `["asset-management", "work-order-management"]`。标识须来自实际 PRD 或已确定项目模块：小写字母开头，使用字母、数字和单个连字符分隔，总长不超过 128；不把文档名、需求全文、代码路径或通配符当模块标识。模块身份不清楚时填 []，不编造标识。
+新原生 scope 使用 schemaVersion=3，moduleIds 为数组，例如 `["asset-management", "work-order-management"]`。标识须来自实际 PRD 或已确定项目模块：小写字母开头，使用字母、数字和单个连字符分隔，总长不超过 128；不把文档名、需求全文、代码路径或通配符当模块标识。模块身份不清楚时填 []，不编造标识。
 
 需求的 source.reference 保留具体 PRD、版本与需求编号，statement 保留真实依据。多个 PRD 同模块去重；不同模块取本原型 scope 范围内并集。需求 ID 在本 scope 内唯一，文档冲突明确留作待确认项；模块关联不能代替需求覆盖或完成证明。
 

package/skills/i3-ui-prototype/scripts/buddy-host.cjs

@@ -0,0 +1,40 @@
+'use strict';
+// Identification never treats absence of an IDE marker as proof of CLI identity.
+const path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
+const HOSTS=['codebuddy','workbuddy'];
+function globalBase({host='codebuddy',home=os.homedir(),env=process.env}={}){
+ assert.ok(HOSTS.includes(host),'Unsupported Buddy host');
+ const key=host==='workbuddy'?'WORKBUDDY_CONFIG_DIR':'CODEBUDDY_CONFIG_DIR';
+ const base=env[key]?.trim()||path.join(home,`.${host}`);
+ assert.ok(path.isAbsolute(base)&&!/[\x00\r\n]/.test(base),`${key} must be an absolute safe directory`);
+ return path.normalize(base);
+}
+function identify(payload,record,{home=os.homedir(),env=process.env}={}){
+ const clients={CodeBuddyIDE:['codebuddy','ide'],CodeBuddyCLI:['codebuddy','cli'],CodeBuddyCode:['codebuddy','cli'],WorkBuddy:['workbuddy','ide'],WorkBuddyIDE:['workbuddy','ide'],WorkBuddyDesktop:['workbuddy','ide']};
+ const client=clients[payload.client];
+ const declared=typeof payload.host==='string'?payload.host.toLowerCase():null;
+ let found=client&&{host:client[0],product:client[1],identitySource:'native-client'};
+ if(found&&declared)assert.equal(declared,found.host,'Conflicting native host identity');
+ const candidates=[];
+ if(typeof payload.transcript_path==='string'&&path.isAbsolute(payload.transcript_path)){
+  const file=path.normalize(payload.transcript_path);
+  for(const host of HOSTS){
+   const parent=path.join(globalBase({host,home,env}),'projects')+path.sep;
+   if(file.startsWith(parent)&&file.endsWith('.jsonl'))candidates.push(host);
+  }
+ }
+ if(found&&candidates.length)assert.ok(candidates.includes(found.host),'Conflicting client and native host log location');
+ if(!found&&candidates.length){
+  const host=candidates.length===1?candidates[0]:env.WORKBUDDY_CONFIG_DIR&&candidates.includes('workbuddy')?'workbuddy':null;
+  assert.ok(host,'Conflicting native host log locations');
+  found={host,product:host==='codebuddy'?'cli':'ide',identitySource:'native-host-log-location'};
+ }
+ // A legacy installation retains its original, explicitly weaker contract.
+ if(!found&&record.schemaVersion===1&&['ide','cli'].includes(record.product))found={host:'codebuddy',product:record.product,identitySource:'legacy-profile'};
+ assert.ok(found,'Native host/product identity is unavailable; keep invocation unverified');
+ if(declared)assert.equal(declared,found.host,'Conflicting native host identity');
+ assert.ok((record.hosts||['codebuddy']).includes(found.host),'Native host is outside the registered scope');
+ return {...found,productVersion:payload.client_version||payload.product_version||(found.host==='workbuddy'?(env.WORKBUDDY_APP_VERSION||env.CLIENT_INFO_PRODUCT_VERSION):null)||(record.product==='auto'?null:record.productVersion)||'unreported'};
+}
+function isIDE(payload){return ['CodeBuddyIDE','WorkBuddy','WorkBuddyIDE','WorkBuddyDesktop'].includes(payload.client);}
+module.exports={HOSTS,globalBase,identify,isIDE};

package/skills/i3-ui-prototype/scripts/codebuddy-context.cjs

@@ -1,7 +1,7 @@
 'use strict';
 const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
-const R=require('./codebuddy-registration.cjs'),E=require('./execution-evidence.cjs');
-const FILES=['execution-policy.cjs','execution-evidence.cjs','codebuddy-ide-source.cjs','execution-gates.cjs','execution-assertions.cjs','execution-runtime.cjs','codebuddy-context.cjs','codebuddy-registration.cjs','codebuddy-hook.cjs','prototype-hooks.cjs','hosts/codebuddy.cjs','native-pilot.cjs','native-pilot-lib.cjs','native-delivery.cjs','native-devtools.cjs','native-files.cjs','native-build.cjs'];
+const R=require('./codebuddy-registration.cjs'),E=require('./execution-evidence.cjs'),H=require('./buddy-host.cjs');
+const FILES=['native-command.cjs','buddy-host.cjs','execution-recovery.cjs','execution-policy.cjs','execution-evidence.cjs','codebuddy-ide-source.cjs','execution-gates.cjs','execution-assertions.cjs','execution-runtime.cjs','codebuddy-context.cjs','codebuddy-registration.cjs','codebuddy-hook.cjs','prototype-hooks.cjs','hosts/codebuddy.cjs','native-pilot.cjs','native-pilot-lib.cjs','native-delivery.cjs','native-devtools.cjs','native-files.cjs','native-build.cjs'];
 const read=file=>R.fileIO.read(file);
 function scriptsForEntry(scriptPath) {
  if(path.basename(scriptPath)!=='i3-prototype.cjs')return path.dirname(path.dirname(scriptPath));
@@ -21,37 +21,37 @@ function bundle(scriptPath) {
 }
 function registration(base) {
  const raw=read(path.join(base,'state/i3-prototype/installation.json'));if(!raw)return null;
- const record=JSON.parse(raw);assert.equal(record.owner,R.OWNER,'Unknown Hook ownership');assert.equal(record.schemaVersion,1,'Unsupported Hook ownership');assert.equal(record.base,base,'Hook base differs');
+ const record=JSON.parse(raw);assert.equal(record.owner,R.OWNER,'Unknown Hook ownership');assert.ok([1,2].includes(record.schemaVersion),'Unsupported Hook ownership');assert.equal(record.base,base,'Hook base differs');
+ if(record.schemaVersion===2)assert.ok(record.product==='auto'&&Array.isArray(record.hosts)&&record.hosts.length&&record.hosts.every(host=>H.HOSTS.includes(host)),'Invalid automatic Hook identity');
  const settingsText=read(path.join(base,'settings.json')),settings=R.config(settingsText);
  for(const event of R.EVENTS)assert.equal((settings.hooks?.[event]||[]).filter(group=>JSON.stringify(group)===JSON.stringify(record.groups[event])).length,1,'Registered Hook was removed, duplicated, or edited');
  assert.equal(bundle(record.scriptPath),record.scriptDigest,'Audit adapter bytes changed; refresh owned registration');
  assert.ok(fs.existsSync(record.nodePath),'Registered Node executable is missing');
  return {...record,settingsDigest:E.sha(settingsText),registrationDigest:E.sha(JSON.stringify(record))};
 }
-function globalBase({home=os.homedir(),env=process.env}={}) {
- const configured=env.CODEBUDDY_CONFIG_DIR?.trim();
- if(!configured)return path.join(home,'.codebuddy');
- assert.ok(path.isAbsolute(configured)&&!/[\x00\r\n]/.test(configured),'CODEBUDDY_CONFIG_DIR must be an absolute safe directory');
- return path.normalize(configured);
-}
-function select({project,product,home=os.homedir(),env=process.env,readText=read,loadRegistration=registration}) {
- const projectBase=path.join(project,'.codebuddy'),userBase=globalBase({home,env});
+const globalBase=H.globalBase;
+function select({project,product,host='codebuddy',home=os.homedir(),env=process.env,readText=read,loadRegistration=registration}) {
+ assert.ok(['ide','cli'].includes(product),'Actual native product identity required');
+ const projectBase=path.join(project,'.codebuddy'),userBase=globalBase({host,home,env});
  const projectText=readText(path.join(projectBase,'settings.json')),localText=readText(path.join(projectBase,'settings.local.json'));
  if(localText){const local=R.config(localText);assert.ok(!local.hooks&&!local.disableAllHooks&&!local.allowManagedHooksOnly,'Local Hook overrides are not supported by this profile');}
  const projectSettings=R.config(projectText);assert.ok(!projectSettings.disableAllHooks&&!projectSettings.allowManagedHooksOnly,'Project Hook policy prevents automatic auditing');
  const globalText=readText(path.join(userBase,'settings.json')),globalSettings=R.config(globalText);assert.ok(!globalSettings.disableAllHooks&&!globalSettings.allowManagedHooksOnly,'Global Hook policy prevents automatic auditing');
  // IDE documents project settings as an override. Do not silently fall back through a shadowing file.
- const bases=product==='ide'&&projectText!==null?[projectBase]:[projectBase,userBase];
+ const bases=host==='codebuddy'&&product==='ide'&&projectText!==null?[projectBase]:[projectBase,userBase];
  for(const base of [...new Set(bases)]) {
   const record=loadRegistration(base);if(!record)continue;
-  assert.equal(record.product,product,'Conflicting CodeBuddy product profiles');return record;
+  if(record.product==='auto'){
+   if(!(record.hosts||[]).includes(host))continue;
+  }else {assert.equal(host,'codebuddy','Legacy profile is CodeBuddy only');assert.equal(record.product,product,'Conflicting CodeBuddy product profiles');}
+  return {...record,host,product};
  }
  return null;
 }
 function projectKey(project){return `${path.basename(project).replace(/[^a-zA-Z0-9_-]/g,'-').slice(0,32)||'project'}-${E.sha(project).slice(0,16)}`;}
 function sessionDirectory(record,project,sessionId) {
  assert.ok(typeof sessionId==='string'&&sessionId,'Native session ID required');
- return path.join(record.base,'state/i3-prototype',projectKey(project),E.sha(sessionId).slice(0,24));
+ return path.join(record.base,'state/i3-prototype',projectKey(project),E.sha(record.schemaVersion===2?`${record.host}:${record.product}:${sessionId}`:sessionId).slice(0,24));
 }
 function source(payload,record,project) {
  assert.ok(typeof payload.transcript_path==='string'&&typeof payload.session_id==='string','Native transcript and session fields required');