@givolt/i3-composer-agent 2.3.3 → 2.3.5

package/skills/i3-ui-prototype/scripts/execution-gates.cjs

@@ -4,6 +4,7 @@
 const assert=require('node:assert/strict'),path=require('node:path');
 const P=require('./execution-policy.cjs'),E=require('./execution-evidence.cjs');
 const A=require('./execution-assertions.cjs');
+const command=require('./native-command.cjs');
 const same=(a,b,label)=>assert.deepEqual(a,b,label);
 const exact=(a,b,label)=>same([...new Set(a)].sort(),[...new Set(b)].sort(),label);
 function uiWrite(call,directory) {
@@ -29,7 +30,7 @@ function skill(data,ref,key,before=Infinity) {
 }
 function quote(data,ref) {
  const call=nativeRef(data,ref);assert.ok(typeof ref.quote==='string'&&ref.quote.trim(),'Actual native result quote required');
- assert.ok(E.contentText(call.result).includes(ref.quote),'Quoted finding absent from native result');return call;
+ assert.ok(E.resultText(call.result).includes(ref.quote),'Quoted finding absent from native result');return call;
 }
 function identity(d) {
  P.validate(d.policy);assert.equal(d.binding?.schemaVersion,1,'Hook task binding required');assert.equal(d.proof?.schemaVersion,1,'Execution evidence required');
@@ -37,9 +38,33 @@ function identity(d) {
  same(d.binding.policyDigest,d.policy.digest,'Execution policy differs');same(d.binding.inputDigest,d.current.inputDigest,'Inputs changed; begin a new execution run');
  for(const key of ['inputDigest','candidateDigest','revision'])same(d.proof[key],key==='candidateDigest'?d.current.digest:d.current[key],`Current ${key} differs`);
  assert.ok(d.source.prompts.some(p=>p.line===d.binding.entryLine),'Native user task source missing');
+ assert.ok(command.completedBegin(d.source,d.binding),'Successful execution-begin for the current native task/context is required');
+ if(d.policy.id===P.AUTO_ID){same(d.binding.host,d.policy.host,'Actual native host differs from the fixed policy');assert.ok(d.binding.identitySource&&d.binding.identitySource!=='legacy-profile','Automatic policy requires actual native host identity');}
+ if(d.binding.recovery){
+  const recovery=d.binding.recovery;
+  assert.notEqual(recovery.status,'blocked','Recovery budget exhausted; a new human task is required');
+  for(const ref of recovery.invocations||[]){const call=nativeRef(d,ref);same(call.skill,ref.skill,'Recovery Skill differs');same(call.requestLine,ref.requestLine,'Recovery request cursor differs');same(call.resultLine,ref.resultLine,'Recovery result cursor differs');assert.ok(call.requestLine>ref.feedbackLine,'Recovery invocation must follow its feedback');}
+  if(recovery.status==='recovered'){
+   const retry=nativeRef(d,recovery.retry);
+   if(recovery.expectedRetry)for(const [key,value] of Object.entries(recovery.expectedRetry))same(recovery.retry[key],value,'Recovery retry differs from the denied operation');
+   if(recovery.retry.kind!==undefined)assert.ok(Number.isFinite(recovery.retry.feedbackLine)&&recovery.retry.feedbackLine>=d.binding.entryLine&&retry.requestLine>recovery.retry.feedbackLine,'Recovery retry must follow its feedback');
+   if(recovery.retry.kind==='stage'){
+    const parsed=command.nativeCommand(retry.name,retry.input,retry.cwd||d.binding.project||d.binding.directory);
+    assert.ok(parsed&&command.stageFor[parsed.operation],'Recovery retry is not a supported native stage command');
+    same(parsed.root,d.binding.directory,'Recovery stage belongs to another prototype');
+    same(parsed.operation,recovery.retry.operation,'Recovery stage operation differs');
+    same(command.stageFor[parsed.operation],recovery.retry.stage,'Recovery stage differs');
+   }else {
+    assert.ok(recovery.retry.kind===undefined||recovery.retry.kind==='ui-write','Unknown recovery retry kind');
+    assert.ok(uiWrite({...retry,cwd:retry.cwd||d.binding.project},d.binding.directory),'Recovery retry is not a native UI write');
+    if(recovery.expectedRetry?.file){const input=retry.input,file=input.file_path||input.filePath||input.path||input.TargetFile;same(path.resolve(retry.cwd||d.binding.project,file),recovery.expectedRetry.file,'Recovery wrote a different UI file');}
+   }
+   for(const ref of recovery.invocations||[])assert.ok(retry.requestLine>ref.resultLine,'Retry must follow successful Skill results');
+  }
+ }
 }
 function frontend(d,complete) {
- const writes=d.source.calls.filter(c=>c.success&&c.requestLine>=d.binding.entryLine&&uiWrite({...c,cwd:c.cwd||(d.source.format==='codebuddy-ide-index-v1'?d.binding.project:undefined)},d.binding.directory));
+ const writes=d.source.calls.filter(c=>c.success&&c.requestLine>=d.binding.entryLine&&c.requestLine>(d.binding.contextLine||0)&&uiWrite({...c,cwd:c.cwd||(d.source.format==='codebuddy-ide-index-v1'?d.binding.project:undefined)},d.binding.directory));
  skill(d,d.proof.frontend,'frontend',writes.length?Math.min(...writes.map(c=>c.requestLine)):Infinity);
  if(!complete)return;
  assert.ok(writes.length,'Actual implementation write missing; metadata is not implementation');
@@ -85,7 +110,7 @@ function design(d) {
   assert.ok(query.decisions?.length,'UIUX result decisions required');
   for(const decision of query.decisions) {
    assert.ok(['adopted','adjusted','rejected','no-match'].includes(decision.decision)&&decision.rationale&&decision.identity,'UIUX decision identity and rationale required');
-   assert.ok(E.contentText(call.result).includes(decision.identity),'UIUX identity absent from actual result');
+   assert.ok(E.resultText(call.result).includes(decision.identity),'UIUX identity absent from actual result');
    if(['adopted','adjusted'].includes(decision.decision))assert.ok(Object.hasOwn(d.files||{},decision.implementation)&&decision.scenarioId,'Adopted UIUX result needs source and verification scenario');
   }
  }
@@ -94,7 +119,7 @@ function design(d) {
 }
 function build(d) {
  assert.ok(d.build?.buildId&&d.build?.buildDigest,'Current checked build required');
- const call=nativeRef(d,d.proof.build),input=JSON.stringify(call.input),output=E.contentText(call.result);
+ const call=nativeRef(d,d.proof.build),input=JSON.stringify(call.input),output=E.resultText(call.result);
  assert.ok(['Bash','execute_command','run_terminal_command'].includes(call.name)&&input.includes('native-pilot.cjs')&&/\bbuild\b/.test(input)&&input.includes(d.binding.directory),'Actual current build command required');
  assert.ok(output.includes(d.build.buildId)&&output.includes(d.build.buildDigest),'Native build result differs from current build');
  same(d.build.candidateDigest,d.current.digest,'Build candidate is stale');return call;
@@ -141,7 +166,7 @@ function evaluate(data,stage) {
   if(needs.includes('build'))build(data);
   if(needs.includes('browser'))skill(data,data.proof.browser?.skill||data.devtools?.skill,'browser');
   if(needs.includes('browser-results'))browser(data);
-  return {status:'passed',stage,policyDigest:data.policy.digest,runId:data.binding.runId,sessionId:data.binding.sessionId,projectKey:data.binding.projectKey,host:'codebuddy',productForm:data.binding.product||'unreported',productVersion:data.binding.productVersion||'unreported',installationScope:data.binding.scope||'unreported',operation:data.binding.operation||data.policy.operation,mode:data.policy.mode,inputDigest:data.current.inputDigest,candidateDigest:data.current.digest,revision:data.current.revision,source:data.source.path?{path:data.source.path,bytes:data.source.bytes,digest:data.source.digest}:undefined,invocationVerification:'native-source-correlated',tamperProof:false};
+  return {status:'passed',stage,policyDigest:data.policy.digest,runId:data.binding.runId,sessionId:data.binding.sessionId,projectKey:data.binding.projectKey,host:data.policy.host,productForm:data.binding.product||'unreported',productVersion:data.binding.productVersion||'unreported',installationScope:data.binding.scope||'unreported',operation:data.binding.operation||data.policy.operation,mode:data.policy.mode,inputDigest:data.current.inputDigest,candidateDigest:data.current.digest,revision:data.current.revision,source:data.source.path?{path:data.source.path,bytes:data.source.bytes,digest:data.source.digest}:undefined,...(data.binding.recovery?{recovery:data.binding.recovery}:{}),invocationVerification:'native-source-correlated',tamperProof:false};
  } catch(error){return {status:'failed',stage,errors:[error.message],invocationVerification:'unverified'};}
 }
 module.exports={evaluate,uiWrite};

package/skills/i3-ui-prototype/scripts/execution-policy.cjs

@@ -2,6 +2,7 @@
 const assert = require('node:assert/strict');
 const crypto = require('node:crypto');
 const ID = 'codebuddy-ab-v1';
+const AUTO_ID = 'buddy-ab-v2';
 const SKILLS = Object.freeze({
   frontend: [['frontend','ui','engineering'].join('-'), 'i3-frontend-ui-engineering'],
   browser: [['browser','testing','with','devtools'].join('-'), 'i3-browser-testing-with-devtools'],
@@ -12,16 +13,20 @@ const STAGES = ['design', 'implementation-entry', 'implementation', 'build', 'br
 function digest(value) { return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex'); }
 function create(options = {}) {
   const { host = 'codebuddy', operation = 'create', mode = 'professional', officialCallable = true } = options;
-  assert.equal(host, 'codebuddy', 'This execution policy supports CodeBuddy only');
+  const policyId=options.id||(host==='workbuddy'?AUTO_ID:ID);
+  assert.ok([ID,AUTO_ID].includes(policyId),'Unsupported execution policy');
+  assert.ok(['codebuddy','workbuddy'].includes(host),'This execution policy supports CodeBuddy and WorkBuddy only');
+  if(policyId===ID)assert.equal(host,'codebuddy','The legacy policy is CodeBuddy only');
   assert.ok(['analyze', 'create', 'revise', 'inspect', 'confirm-baseline'].includes(operation), 'Invalid execution operation');
   assert.ok(['professional', 'template'].includes(mode), 'Invalid execution mode');
   assert.equal(typeof officialCallable, 'boolean');
-  const value = { schemaVersion: 1, id: ID, host, operation, mode, officialCallable,
+  const value = { schemaVersion: policyId===AUTO_ID?2:1, id: policyId, host, operation, mode, officialCallable,
+    ...(policyId===AUTO_ID?{recovery:{perMissing:2,total:6}}:{}),
     readOnly: !['create', 'revise'].includes(operation), skills: SKILLS, stages: STAGES };
   return { ...value, digest: digest(value) };
 }
 function validate(policy) {
-  assert.ok(policy && policy.id === ID, 'Unsupported execution policy');
+  assert.ok(policy && [ID,AUTO_ID].includes(policy.id), 'Unsupported execution policy');
   const expected = create(policy);
   assert.deepEqual(policy, expected, 'Execution policy was changed or is invalid');
   return policy;
@@ -30,12 +35,28 @@ function requirements(policy, stage) {
   validate(policy); assert.ok(STAGES.includes(stage), 'Unknown execution stage');
   if (policy.readOnly) return [];
   const design = [policy.officialCallable ? 'antdv' : 'official-source', ...(policy.mode === 'professional' ? ['uiux'] : [])];
-  return ({ design, 'implementation-entry': ['frontend'], implementation: ['frontend', 'implementation'],
+  return ({ design, 'implementation-entry': ['frontend'], implementation: ['frontend', 'implementation',...(policy.id===AUTO_ID?design:[])],
     build: ['implementation', 'build'], 'browser-entry': ['browser', 'build'],
     browser: ['browser', 'build', 'browser-results'], delivery: [...design, 'frontend', 'implementation', 'build', 'browser', 'browser-results'] })[stage];
 }
-function skillKey(name) { return Object.keys(SKILLS).find(key => SKILLS[key].includes(name)) || null; }
+function skillKey(name) {
+ if(typeof name!=='string')return null;
+ const [namespace,leaf,...rest]=name.split(':');
+ if(leaf!==undefined){
+  if(rest.length)return null;
+  const allowed={'i3-composer-agent':['frontend','browser','prototype'],'i3-composer-agent':['frontend','browser'],'ui-ux-pro-max':['uiux'],'antdv':['antdv'],'antdv-next':['antdv']};
+  return (allowed[namespace]||[]).find(key=>SKILLS[key].includes(leaf))||null;
+ }
+ return Object.keys(SKILLS).find(key => SKILLS[key].includes(name)) || null;
+}
 function creationOptions(options,installed) {
-  return installed?.name==='i3-composer-agent'&&options.host==='codebuddy'?{...options,executionPolicy:options.executionPolicy||ID}:options;
+  if(installed?.name!=='i3-composer-agent')return options;
+  let host=options.host;
+  if(!host&&installed.agents?.length){
+    const hosts=installed.agents.filter(value=>['codebuddy','workbuddy'].includes(value));
+    assert.ok(hosts.length<2,'Shared Buddy installation requires the actual --host');
+    if(hosts.length===1)host=hosts[0];
+  }
+  return ['codebuddy','workbuddy'].includes(host)?{...options,host,executionPolicy:options.executionPolicy||AUTO_ID}:options;
 }
-module.exports = { ID, SKILLS, STAGES, digest, create, validate, requirements, skillKey, creationOptions };
+module.exports = { ID, AUTO_ID, SKILLS, STAGES, digest, create, validate, requirements, skillKey, creationOptions };

package/skills/i3-ui-prototype/scripts/execution-recovery.cjs

@@ -0,0 +1,57 @@
+'use strict';
+// Deterministic recovery state; only native source results can resolve a Skill.
+const E=require('./execution-evidence.cjs'),P=require('./execution-policy.cjs');
+const N=require('./native-command.cjs');
+const names={frontend:'i3-frontend-ui-engineering',antdv:'antdv',uiux:'ui-ux-pro-max',browser:'i3-browser-testing-with-devtools'};
+const blockedReason='原型补调已达到自动恢复上限，当前任务仍被阻塞。请如实报告缺项及失败原因；修复依赖、权限或宿主后由用户发起继续。不能取得合格交付回执。';
+function missing({source,binding,policy,stage}){
+ const unbound=!N.completedBegin(source,binding);
+ const required=stage&&policy?P.requirements(policy,stage).filter(key=>Object.hasOwn(names,key)):['frontend',...(policy?.id===P.AUTO_ID?[...(policy.officialCallable?['antdv']:[]),...(policy.mode==='professional'?['uiux']:[])]:[])];
+ const sessionId=binding?.sessionId||source.calls.find(call=>call.sessionId)?.sessionId;
+ return [...(unbound?['execution-begin']:[]),...required.filter(key=>!E.loaded(source.calls,key).some(call=>call.sessionId===sessionId&&call.requestLine>source.contextLine&&(source.stableThroughLine===undefined||call.resultLine<=source.stableThroughLine)))];
+}
+function instruction(keys,{directory}={}){
+ const skills=keys.filter(key=>names[key]).map(key=>names[key]);
+ const begin=keys.includes('execution-begin')?`先为当前任务独立执行 execution-begin${directory?'：\n'+N.beginCommand(directory)+'\n':'。'}不得拼接 cd &&、管道、重定向或 head；等待 status=bound 且退出码为 0，再重试原操作。`:'';
+ return `${begin}${skills.length?'请立即通过当前宿主的 Skill 工具调用 '+skills.join('、')+'（插件安装使用宿主显示的完整名称），等待成功返回后重试原操作。':''}${keys.includes('execution-evidence')?'执行 execution-check，按实际原生请求和结果补齐当前阶段证据后重试。':''}读取 SKILL.md、自动补全提示、手填调用记录不能代替实际调用。外层工具 success 不代表原型阶段成功；内层 status=failed 或非零退出必须保持阻塞。失败时报告具体原因，不得自动安装依赖或宣称完成。`;
+}
+function record(index,context,answer){
+ const {source,sessionId,directory,eventKey,event}=context,prompt=source.prompts.at(-1);
+ const taskKey=E.sha(JSON.stringify([sessionId,prompt.line,prompt.digest,directory]));
+ if(!answer.deny&&!answer.feedback&&!index.recoveries?.[taskKey])return answer;
+ index.recoveries||={};
+ const state=index.recoveries[taskKey]||={schemaVersion:1,total:0,counts:{},events:{},pending:{},invocations:[],status:'required'};
+ state.feedbackLine??=Math.max(prompt.line,...Object.values(state.pending).map(item=>item.line));
+ const summary=()=>({taskKey,status:state.status,total:state.total,counts:state.counts,invocations:state.invocations,...(state.expectedRetry?{expectedRetry:state.expectedRetry}:{}),...(state.retry?{retry:state.retry}:{})});
+ const remember=result=>{state.events[eventKey]=result;for(const key of Object.keys(state.events).slice(0,-128))delete state.events[key];return {...result,recovery:summary()};};
+ if(state.events[eventKey])return {...state.events[eventKey],recovery:summary()};
+ if(state.status==='blocked'&&!answer.deny&&!answer.feedback)return remember(event==='PreToolUse'&&context.expectedRetry?{deny:true,reason:blockedReason}:{...answer,context:blockedReason});
+ if(answer.deny||answer.feedback){
+  if(context.expectedRetry&&(!state.expectedRetry||state.status==='recovered'))state.expectedRetry=context.expectedRetry;
+  const keys=[...new Set(answer.missing?.length?answer.missing:['execution-evidence'])];
+  const limits=context.policy?.recovery||{perMissing:2,total:6};
+  if(state.total>=limits.total||keys.some(key=>(state.counts[key]||0)>=limits.perMissing)){
+   state.status='blocked';
+   const result=answer.deny?{deny:true,reason:blockedReason,missing:keys}:{continue:true,context:blockedReason};return remember(result);
+  }
+  state.total++;for(const key of keys)state.counts[key]=(state.counts[key]||0)+1;state.status='required';
+  const line=Math.max(prompt.line,...source.calls.map(call=>call.resultLine||call.requestLine));
+  state.feedbackLine=Math.max(state.feedbackLine,line);
+  for(const item of keys)state.pending[item]||={line,eventKey,...(item==='execution-evidence'&&context.stage?{stage:context.stage}:{})};
+ }else{
+  for(const [key,pending] of Object.entries(state.pending)){
+   if(names[key]){
+    const call=E.loaded(source.calls,key).find(call=>call.sessionId===sessionId&&call.requestLine>Math.max(pending.line,source.contextLine)&&(source.stableThroughLine===undefined||call.resultLine<=source.stableThroughLine));
+    if(!call)continue;
+    if(!state.invocations.some(item=>item.toolCallId===call.toolCallId))state.invocations.push({skill:key,toolCallId:call.toolCallId,resultDigest:call.resultDigest,requestLine:call.requestLine,resultLine:call.resultLine,feedbackLine:pending.line,afterFeedback:pending.eventKey});
+   }else if(!(context.resolved||[]).includes(key)||pending.stage&&pending.stage!==context.stage)continue;
+   delete state.pending[key];
+  }
+  if(!Object.keys(state.pending).length&&state.status!=='recovered'){
+   const matchingRetry=!state.expectedRetry||Object.entries(state.expectedRetry).every(([key,value])=>context.retry?.[key]===value);
+   state.status=context.retrySucceeded&&matchingRetry&&event==='PostToolUse'&&context.retry?.requestLine>state.feedbackLine?'recovered':'ready-to-retry';if(state.status==='recovered')state.retry={...context.retry,feedbackLine:state.feedbackLine};
+  }
+ }
+ return remember({...answer});
+}
+module.exports={missing,instruction,record};

package/skills/i3-ui-prototype/scripts/execution-runtime.cjs

@@ -1,6 +1,7 @@
 'use strict';
 const F=require('./native-files.cjs'),{fs,path,assert,json,inside}=F;
 const P=require('./execution-policy.cjs'),E=require('./execution-evidence.cjs'),G=require('./execution-gates.cjs'),C=require('./codebuddy-context.cjs');
+const Recovery=require('./execution-recovery.cjs');
 const optional=(root,file)=>fs.existsSync(inside(root,file))?json(inside(root,file)):null;
 function policy(directory) {
  const value=optional(directory,'inputs/execution-policy.json'),metaFile=inside(directory,'prototype.json');
@@ -11,8 +12,9 @@ function policy(directory) {
  const acceptance=json(inside(directory,'inputs/acceptance.json'));require('./execution-assertions.cjs').validate(json(inside(directory,'inputs/execution-assertions.json')),[...acceptance.requiredScenarios,...acceptance.frameworkScenarios]);return value;
 }
 function binding(directory) {
- const pointer=optional(directory,'qa/execution-context.json');assert.ok(pointer?.schemaVersion===1,'No native Hook task binding; run execution-begin inside enabled CodeBuddy');
- const project=fs.realpathSync(pointer.project),selected=C.select({project,product:pointer.product});assert.ok(selected,'Hooks are not enabled or are shadowed');
+ const recover=Recovery.instruction(['execution-begin'],{directory});
+ const pointer=optional(directory,'qa/execution-context.json');assert.ok(pointer?.schemaVersion===1,'No native Hook task binding; '+recover);
+ const project=fs.realpathSync(pointer.project),selected=C.select({project,product:pointer.product,host:pointer.host||'codebuddy'});assert.ok(selected,'Hooks are not enabled or are shadowed');
  assert.equal(selected.base,pointer.base,'Effective Hook scope changed');
  const stateDirectory=C.sessionDirectory(selected,project,pointer.sessionId),indexFile=path.join(stateDirectory,'session.json');
  const index=JSON.parse(C.read(indexFile)||'null'),entry=index?.bindings?.[directory];assert.ok(entry,'Native Hook run is missing');
@@ -23,6 +25,8 @@ function binding(directory) {
  const source=C.source({session_id:entry.sessionId,transcript_path:entry.source.path},selected,project);
  const prompt=source.prompts.find(p=>p.line===entry.entryLine);assert.equal(prompt?.digest,entry.promptDigest,'Original user task changed');
  assert.ok(!C.readOnly(source.prompts.at(-1).text),'Latest user request is read-only or stopped');
+ assert.equal(entry.entryLine,source.prompts.at(-1).line,'Native task changed; '+recover);
+ assert.equal(entry.contextLine,source.contextLine,'Native context changed; '+recover);
  return {entry,source,selected};
 }
 function data(directory,lib,options={}) {
@@ -33,7 +37,7 @@ function data(directory,lib,options={}) {
  const pointer=optional(directory,'last-build.json');let build=null;
  if(pointer)try{build=lib.verifyBuild(directory,pointer.buildId);}catch{/* A changed candidate must be allowed to rebuild; build/browser gates reject null. */}
  const latest=optional(directory,'qa/latest.json');
- const business=options.businessReport||(latest?json(inside(directory,latest.report)):proof?.browser?.report?json(inside(directory,proof.browser.report)):null);
+ const business=options.businessReport||(latest?json(inside(directory,latest.report)):proof?.browser?.report?optional(directory,proof.browser.report):null);
  const framework=json(inside(directory,'inputs/framework.json'));
  return {policy:fixed,current,binding:entry,source,proof,assertions:json(inside(directory,'inputs/execution-assertions.json')),designReview:optional(directory,'qa/design-advice.json'),scope:json(inside(directory,'inputs/scope.json')),implementation:optional(directory,'design-system/implementation.json'),files,frameworkVersion:framework.profile?.versions?.['antdv-next']||json(inside(directory,'app/package.json')).dependencies['antdv-next'].replace(/^[~^]/,''),build,business,devtools:options.devtoolsReport||optional(directory,'qa/devtools-review.json'),selected};
 }
@@ -54,6 +58,7 @@ function template(directory,lib) {
 }
 function begin(directory,lib) {
  directory=fs.realpathSync(directory);const {entry}=binding(directory);
+ assert.equal(entry.inputDigest,lib.manifest(directory).inputDigest,'Inputs changed; '+Recovery.instruction(['execution-begin'],{directory}));
  return {status:'bound',operation:'execution-begin',directory,runId:entry.runId,sessionId:entry.sessionId,policyDigest:entry.policyDigest,evidenceTemplate:template(directory,lib),
   next:'Load applicable Skills through CodeBuddy, implement the current scope, and bind actual native result IDs in qa/execution-evidence.json. Binding is not completion.'};
 }

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

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
 'use strict';
 const fs=require('node:fs'),path=require('node:path');
+function format(result,event){
+ if(result.deny)return {code:0,output:{hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason:result.reason}}};
+ if(result.feedback)return {code:0,output:event==='Stop'?{continue:false,reason:result.reason}:{continue:true,hookSpecificOutput:{hookEventName:event,additionalContext:result.reason}}};
+ if(result.context)return {code:0,output:{continue:true,...(result.recovery?.status==='blocked'?{systemMessage:result.context}:{}),...(['SessionStart','UserPromptSubmit','PostToolUse'].includes(event)?{hookSpecificOutput:{hookEventName:event,additionalContext:result.context}}:{})}};
+ return {code:0,output:{continue:true}};
+}
 function main(argv=process.argv.slice(2),raw=fs.readFileSync(0,'utf8')) {
  if(Buffer.byteLength(raw)>4*1024*1024)throw new Error('Hook input too large');
  const options={};while(argv.length){const key=argv.shift();if(!key.startsWith('--')||!argv.length)throw new Error('Invalid Hook arguments');options[key.slice(2)]=argv.shift();}
  const {OWNER,EVENTS}=require('../codebuddy-registration.cjs');
- if(options.registration!==OWNER||!path.isAbsolute(options.base||'')||!EVENTS.includes(options.event)||!['ide','cli'].includes(options.product))throw new Error('Invalid Hook registration');
+ if(options.registration!==OWNER||!path.isAbsolute(options.base||'')||!EVENTS.includes(options.event)||!['auto','ide','cli'].includes(options.product))throw new Error('Invalid Hook registration');
  const result=require('../codebuddy-hook.cjs').handle(JSON.parse(raw),options);
- if(result.deny)return {code:0,output:{hookSpecificOutput:{hookEventName:'PreToolUse',permissionDecision:'deny',permissionDecisionReason:result.reason}}};
- if(result.feedback)return {code:2,output:{decision:'block',reason:result.reason}};
- return {code:0,output:{continue:true}};
+ return format(result,options.event);
 }
 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;}
-module.exports={main};
+module.exports={main,format};

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

@@ -0,0 +1,35 @@
+'use strict';
+// One non-executing parser shared by Hook dispatch and A receipt verification.
+const path=require('node:path'),assert=require('node:assert/strict');
+const {quote}=require('./codebuddy-registration.cjs');
+const E=require('./execution-evidence.cjs');
+function tokens(command) {
+ if(typeof command!=='string'||/[\x00\r\n]|\$\(|`/.test(command))return null;
+ const values=[];let value='',quote=null,started=false;
+ for(let i=0;i<command.length;i++) {const c=command[i];if(quote){if(c===quote){quote=null;started=true;}else if(c==='\\'&&quote==='"'&&i+1<command.length)value+=command[++i];else value+=c;}
+ else if(c==='"'||c==="'"){quote=c;started=true;}else if(c==='\\'&&i+1<command.length){value+=command[++i];started=true;}else if(/\s/.test(c)){if(started){values.push(value);value='';started=false;}}else if(/[;&|<>]/.test(c))return null;else {value+=c;started=true;}}
+ if(quote)return null;if(started)values.push(value);return values;
+}
+function nativeCommand(tool,input,cwd) {
+ if(!['Bash','execute_command','run_terminal_command'].includes(tool))return null;
+ const argv=tokens(input?.command);if(!argv)return null;const index=argv.findIndex(arg=>path.basename(arg)==='native-pilot.cjs');if(index<1)return null;
+ const operation=argv[index+1],root=argv[index+2]&&!argv[index+2].startsWith('--')?path.resolve(cwd,argv[index+2]):null;
+ return {operation,root,argv};
+}
+const stageFor=Object.freeze({build:'implementation','record-run':'browser-entry','record-devtools-review':'browser-entry',finalize:'delivery'});
+function beginCommand(directory){
+ assert.ok(typeof directory==='string'&&path.isAbsolute(directory),'Absolute prototype directory required');
+ return [process.execPath,path.join(__dirname,'native-pilot.cjs'),'execution-begin',directory].map(quote).join(' ');
+}
+function completedBegin(source,binding){
+ if(!binding||binding.entryLine!==source.prompts.at(-1)?.line||(binding.contextLine||0)!==source.contextLine)return null;
+ const calls=source.calls.filter(call=>call.sessionId===binding.sessionId&&call.requestLine>=binding.entryLine&&call.requestLine>source.contextLine&&(()=>{
+  const command=nativeCommand(call.name,call.input,call.cwd||binding.project||binding.directory);
+  return command?.operation==='execution-begin'&&command.root===binding.directory;
+ })());
+ const latest=calls.at(-1);
+ if(!latest?.success||!latest.resultLine||source.stableThroughLine!==undefined&&latest.resultLine>source.stableThroughLine)return null;
+ const result=E.resultValue(latest.result);
+ return result?.status==='bound'&&result.runId===binding.runId&&result.sessionId===binding.sessionId&&result.directory===binding.directory?latest:null;
+}
+module.exports={tokens,nativeCommand,stageFor,beginCommand,completedBegin};

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

@@ -33,9 +33,7 @@ function defaultScope() {
   ],exemptions:[],openQuestions:[]};
 }
 function createPrototype(options) {
-  const installedFile=path.resolve(__dirname,'../../../.i3-composer-agent.json');
-  if(fs.existsSync(installedFile))options=require('./execution-policy.cjs').creationOptions(options,json(installedFile));
-  if(options.executionPolicy!==undefined){assert.equal(options.executionPolicy,require('./execution-policy.cjs').ID,'Unsupported execution policy');assert.equal(options.host,'codebuddy','Explicit CodeBuddy host required for A+B');}
+  if(options.executionPolicy!==undefined){const policy=require('./execution-policy.cjs');assert.ok([policy.ID,policy.AUTO_ID].includes(options.executionPolicy),'Unsupported execution policy');assert.ok(['codebuddy','workbuddy'].includes(options.host),'Explicit Buddy host required for A+B');if(options.executionPolicy===policy.ID)assert.equal(options.host,'codebuddy','Legacy policy is CodeBuddy only');}
   assert.ok(options.framework===undefined||options.framework==='vue-antdv-next','Unsupported framework / 不支持的框架');
   assert.ok(options.title===undefined||(typeof options.title==='string'&&options.title.trim()),'Title must be a nonempty string');
   const project=path.resolve(options.project||'.'); assert.ok(fs.statSync(project).isDirectory(),'Project must exist'); id(options.id);
@@ -67,7 +65,7 @@ function createPrototype(options) {
     const instanceId=crypto.randomUUID();
     const data={schemaVersion:2,id:options.id,title:options.title||content.pageTitle||'设备清单原型',revision:'r001',artifactKind:'framework-prototype',runtime:{kind:'vue-antdv-next',version:'1',...(reference?{contentReference:true}:{})},...(reference?{business:{status:'needs-adaptation',source:'inputs/scope.json'}}:{}),template:{id:template.id,version:template.version,digest:template.digest},framework:{id:'vue-antdv-next',version:profile.version||'1',digest:hash(JSON.stringify(frameworkFiles))},expertMode:mode,expert:{status:provider?'pending':'skipped',provider},verification:{status:'not-run'},review:{status:'pending-review'},instanceId};
     if(generation)data.runtime.generationContract=1;
-    if(options.executionPolicy){data.runtime.executionPolicy=options.executionPolicy;write(stage,'inputs/execution-policy.json',require('./execution-policy.cjs').create({host:options.host,mode,officialCallable:!options.officialSourceFallback}));}
+    if(options.executionPolicy){data.runtime.executionPolicy=options.executionPolicy;write(stage,'inputs/execution-policy.json',require('./execution-policy.cjs').create({id:options.executionPolicy,host:options.host,mode,officialCallable:!options.officialSourceFallback}));}
     write(stage,'prototype.json',data);
     for(const file of template.files) {
       assert.equal(file.encoding,'base64');

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

@@ -23,7 +23,11 @@ async function main(argv=process.argv.slice(2)) {
     case 'generation-plan': { const templates=require('./template-contract.cjs'),snapshot=root?templates.loadTemplate(root):templates.loadBundledTemplate(options.template);const contract=require('./generation-contract.cjs');return contract.view(contract.compile(snapshot,JSON.parse(fs.readFileSync(path.resolve(options.scope),'utf8'))),options); }
     case 'inventory': { const templates=require('./template-contract.cjs'),snapshot=root?templates.loadTemplate(root):templates.loadBundledTemplate(options.template),value=require('./template-inventory.cjs').verifySnapshot(snapshot);return options.details?value:{status:'passed',readOnly:true,template:snapshot.id,files:Object.keys(value.files).length,routes:value.routes.length,pages:value.pages.length,fragments:value.fragments.length,components:Object.keys(value.components).length,events:value.eventCount}; }
     case 'sync-generation-assets': return require('./generation-assets.cjs').refresh(path.resolve(__dirname,'..'),{check:!!options.check});
-    case 'create': return lib.createPrototype(options);
+    case 'create': {
+      const installedFile=path.resolve(__dirname,'../../../.i3-composer-agent.json');
+      const effective=fs.existsSync(installedFile)?require('./execution-policy.cjs').creationOptions(options,JSON.parse(fs.readFileSync(installedFile,'utf8'))):options;
+      return lib.createPrototype(effective);
+    }
     case 'execution-begin': return require('./execution-runtime.cjs').begin(root,lib);
     case 'execution-assertions-template': return require('./execution-assertions.cjs').template(options);
     case 'execution-template': return require('./execution-runtime.cjs').template(root,lib);

package/skills/i3-ui-prototype/scripts/native-tool-name.cjs

@@ -0,0 +1,5 @@
+'use strict';
+// Observed Buddy tool aliases only. Preserve original blocks for digest checks.
+const aliases=Object.freeze({use_skill:'Skill',skill:'Skill',execute_command:'Bash',write_to_file:'Write',read_file:'Read',replace_in_file:'Edit'});
+const toolName=name=>Object.hasOwn(aliases,name)?aliases[name]:name;
+module.exports={toolName};

package/skills/i3-ui-prototype/scripts/prototype-dependencies.cjs

@@ -31,10 +31,32 @@ function antdvTool(project, options = {}) {
     if (result.status !== 0) throw new Error(result.error?.message || result.stderr || 'CLI query failed');
     const data = JSON.parse(result.stdout);
     if (!data || data.name !== 'Table' || !Array.isArray(data.props) || data.error) throw new Error('CLI returned no Table knowledge');
-    return { availability: 'available', root, source, entry, version: pkg.version, command: [process.execPath, ...args], knowledgeVersion: '1.5.2', componentVersion: '1.5.3', exactKnowledgeMatch: false,
+    return { availability: 'available', root, source, entry, nodePath:process.execPath, version: pkg.version, command: [process.execPath, ...args], invocationVerified:false, knowledgeProbe:'Table-only', knowledgeVersion: '1.5.2', componentVersion: '1.5.3', exactKnowledgeMatch: false,
       limitation: 'CLI knowledge 1.5.2 is reference only; verify target 1.5.3 package types/source.' };
   } catch (error) { return { availability: 'unusable', root, source, reason: error.message }; }
 }
+function query(options={}) {
+  const kinds=['info','demo','token','semantic','doc','list','design.md'];
+  assertQuery(kinds.includes(options.kind),'Choose a read-only antDv query: '+kinds.join(', '));
+  const locations=resolveLocations(options),tool=antdvTool(locations.project,{...options,host:locations.host,scope:locations.scope});
+  assertQuery(tool.availability==='available',`Local antDv CLI ${tool.availability}: ${tool.reason||'use prototype-deps check; installation requires separate authorization'}`);
+  const component=options.component,version=options.version||tool.knowledgeVersion;
+  assertQuery(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(version),'Explicit safe knowledge version required');
+  const args=[tool.entry,options.kind];
+  if(!['list','design.md'].includes(options.kind)){
+    assertQuery(typeof component==='string'&&/^[A-Za-z][A-Za-z0-9-]{0,99}$/.test(component),'Component name required');args.push(component);
+  }
+  if(options.demo!==undefined){assertQuery(options.kind==='demo'&&/^[A-Za-z0-9_-]{1,100}$/.test(options.demo),'Safe demo name required');args.push(options.demo);}
+  args.push('--ver',version,'--format','json');
+  const result=spawnSync(tool.nodePath,args,{cwd:locations.project,env:{...(options.env||process.env),ANTDV_NO_AUTO_REPORT:'1'},encoding:'utf8',timeout:15000,maxBuffer:5*1024*1024});
+  let data=null;try{data=JSON.parse(result.stdout);}catch{/* Some official doc/demo commands return text. */}
+  const stdout=result.stdout||'',stderr=result.stderr||'';
+  const invalid=result.status!==0||!stdout.trim()||/^\s*(?:Error\b|错误[:：])/i.test(stdout)||data?.error||data?.success===false||data?.status==='failed'||options.kind==='info'&&(!data||data.name!==component||!Array.isArray(data.props));
+  return {status:invalid?'failed':'queried',host:locations.host,scope:locations.scope,command:[tool.nodePath,...args],source:tool.source,cliVersion:tool.version,knowledgeVersion:version,componentVersion:tool.componentVersion,exactKnowledgeMatch:version===tool.componentVersion,
+    component:component||null,kind:options.kind,exitCode:result.status,stdout,stderr,...(data?{data}:{}),...(result.error?{error:result.error.message}:{}),skillInvocationVerified:false,
+    note:'This is a CLI query only. Load the official Skill through the host before business queries; native Hooks must correlate the actual request/result. Verify target package types/source when knowledge versions differ.'};
+}
+function assertQuery(condition,message){if(!condition)throw new Error(message);}
 function check(options = {}) {
   const locations = resolveLocations(options), { project, host, scope } = locations;
   const roots = scopeBases(locations).map(([base]) => path.join(base, 'skills/ui-ux-pro-max'));
@@ -62,8 +84,8 @@ function check(options = {}) {
 }
 function parse(argv) {
   const operation = argv.shift() || 'check', options = {};
-  if (!['check', 'install'].includes(operation)) throw new Error('Use check or install');
-  const flags = new Set(['project', 'host', 'scope', 'skills', 'provider', 'python', 'tool']);
+  if (!['check', 'install','query'].includes(operation)) throw new Error('Use check or install or query');
+  const flags = new Set(['project', 'host', 'scope', 'skills', 'provider', 'python', 'tool',...(operation==='query'?['kind','component','version','demo']:[])]);
   while (argv.length) {
     const key = argv.shift();
     if (key === '--migrate-tools' && operation === 'install') { options.migrateTools = true; continue; }
@@ -74,8 +96,8 @@ function parse(argv) {
 }
 async function main(argv = process.argv.slice(2)) {
   const { operation, options } = parse([...argv]);
-  return operation === 'check' ? check(options) : require('./optional-skill-install.cjs').install(options);
+  return operation === 'check' ? check(options) : operation==='query'?query(options):require('./optional-skill-install.cjs').install(options);
 }
-module.exports = { check, skillAt, antdvTool, parse, main };
-if (require.main === module) main().then(result => process.stdout.write(JSON.stringify(result, null, 2) + '\n'))
+module.exports = { check, skillAt, antdvTool, query, parse, main };
+if (require.main === module) main().then(result => {process.stdout.write(JSON.stringify(result, null, 2) + '\n');if(result.status==='failed')process.exitCode=1;})
   .catch(error => { process.stderr.write(JSON.stringify({ status: 'failed', errors: [error.message] }) + '\n'); process.exitCode = 1; });

package/skills/i3-ui-prototype/scripts/prototype-hooks.cjs

@@ -4,7 +4,7 @@
 const fs=require('node:fs'),path=require('node:path'),os=require('node:os'),assert=require('node:assert/strict');
 const R=require('./codebuddy-registration.cjs'),C=require('./codebuddy-context.cjs'),E=require('./execution-evidence.cjs');
 function context(options) {
- assert.equal(options.host||'codebuddy','codebuddy','A+B supports CodeBuddy only');
+ const host=options.host||'codebuddy';assert.ok(['codebuddy','workbuddy'].includes(host),'A+B supports CodeBuddy and WorkBuddy');
  const project=fs.realpathSync(path.resolve(options.project||'.')),scope=options.scope;
  assert.ok(['project','global'].includes(scope),'Specify project or global installation scope');
  const base=scope==='project'?path.join(project,'.codebuddy'):C.globalBase(options);
@@ -12,7 +12,7 @@ function context(options) {
  const record=recordText?JSON.parse(recordText):null;
  const unified=path.join(base,'i3-composer-agent/hooks/i3-prototype.cjs');
  const scriptPath=options.entryPath||(fs.existsSync(unified)?unified:path.join(base,'skills/i3-ui-prototype/scripts/hosts/codebuddy.cjs'));
- return {project,scope,base,record,scriptPath};
+ return {project,scope,base,record,scriptPath,host};
 }
 function prepare(options,runtime={}) {
  const current=runtime.current||context(options),readText=runtime.readText||R.fileIO.read,action=options.action||'keep';
@@ -21,12 +21,8 @@ function prepare(options,runtime={}) {
   if(action==='disable'){const settings=R.config(readText(path.join(current.base,'settings.json')));assert.ok(!Object.values(settings.hooks||{}).flat().some(g=>g.hooks.some(h=>h.command?.includes(R.OWNER))),'Unknown owned-looking Hook has no ownership record; preserve it for review');}
   return {summary:{status:'not-enabled',scope:current.scope,changed:false},unchanged:true};
  }
- const product=options.product||current.record?.product;assert.ok(['ide','cli'].includes(product),'Use --codebuddy-product ide or cli when enabling Hooks');
- if(action!=='disable') {
-  const manifest=readText(path.join(current.base,'.i3-composer-agent.json'));
-  if(manifest)assert.ok(!JSON.parse(manifest).agents?.includes('workbuddy'),'Shared CodeBuddy/WorkBuddy registration cannot safely identify the product; preserve settings and use an exclusive CodeBuddy scope');
-  assert.ok(!options.agents?.includes('workbuddy')||current.scope!=='project','Do not enable CodeBuddy audit in a shared WorkBuddy project target');
- }
+ assert.ok(options.product===undefined||['auto','ide','cli'].includes(options.product),'Invalid Buddy product profile');
+ const product='auto'; // Legacy product arguments are hints, never a second new registration.
  const explicit=options.transcriptRoot,roots=explicit==='auto'?[]:explicit?[path.resolve(explicit)]:current.record?.transcriptRoots||[];
  const mode=explicit?(explicit==='auto'?'auto':'manual'):current.record?.transcriptMode||(roots.length?'manual':'auto');
  if(action!=='disable') {
@@ -34,7 +30,7 @@ function prepare(options,runtime={}) {
  }
  const settingsText=readText(path.join(current.base,'settings.json')),settings=R.config(settingsText);
  if(action!=='disable')assert.ok(!settings.disableAllHooks&&!settings.allowManagedHooksOnly,'Host policy prevents automatic auditing; preserve the existing policy');
- return R.plan({action,...current,product,nodePath:process.execPath,scriptDigest:runtime.scriptDigest||C.bundle(options.entrySource||(path.basename(current.scriptPath)==='i3-prototype.cjs'?current.scriptPath:path.join(__dirname,'hosts/codebuddy.cjs'))),currentText:settingsText,
+ return R.plan({action,...current,product,hosts:options.hosts,agents:options.agents,nodePath:process.execPath,scriptDigest:runtime.scriptDigest||C.bundle(options.entrySource||(path.basename(current.scriptPath)==='i3-prototype.cjs'?current.scriptPath:path.join(__dirname,'hosts/codebuddy.cjs'))),currentText:settingsText,
   transcriptMode:mode,transcriptRoots:roots,productVersion:options.productVersion||current.record?.productVersion||'unreported'});
 }
 function configure(options) {
@@ -51,8 +47,9 @@ function check(options,runtime={}) {
   return {...result,status:result.filesPresent?'files-present':'not-enabled'};
  }
  try {
-  const record=(runtime.registration||C.registration)(current.base),effective=(runtime.select||C.select)({project:current.project,product:record.product,home:options.home,env:options.env});
-  Object.assign(result,{product:record.product,productVersion:record.productVersion,registrationDigest:record.registrationDigest,effective:effective?.base===current.base,transcriptRoots:record.transcriptRoots,
+  const record=(runtime.registration||C.registration)(current.base),host=options.host||'codebuddy',products=record.product==='auto'?(host==='workbuddy'?['ide']:['ide','cli']):[record.product];
+  const effectiveByProduct=Object.fromEntries(products.map(product=>[product,(runtime.select||C.select)({project:current.project,product,host,home:options.home,env:options.env})?.base===current.base]));
+  Object.assign(result,{host,product:record.product,productVersion:record.productVersion,registrationDigest:record.registrationDigest,effective:Object.values(effectiveByProduct).every(Boolean),effectiveByProduct,transcriptRoots:record.transcriptRoots,
    transcript:{mode:record.transcriptMode||(record.transcriptRoots?.length?'manual':'auto'),status:'awaiting-native-event',invocationVerified:false}});
   let observation=null;
   const parent=path.join(current.base,'state/i3-prototype',C.projectKey(current.project));
@@ -62,18 +59,21 @@ function check(options,runtime={}) {
    const raw=R.fileIO.read(path.join(parent,name,'session.json'));if(!raw)continue;
    entries.push(...Object.values(JSON.parse(raw).bindings||{}));
   }
-  for(const entry of entries)if(entry.project===current.project&&entry.registrationDigest===record.registrationDigest&&entry.settingsDigest===record.settingsDigest&&(!observation||entry.lastHook.at>observation.lastHook.at))observation=entry;
+  for(const entry of entries)if((entry.host||'codebuddy')===host&&entry.project===current.project&&entry.registrationDigest===record.registrationDigest&&entry.settingsDigest===record.settingsDigest&&(!observation||entry.lastHook.at>observation.lastHook.at))observation=entry;
   if(observation) {
    result.transcript.path=observation.source.path;
    C.prefix(observation.source.path,observation.source.bytes,observation.source.digest);
    C.source({session_id:observation.sessionId,transcript_path:observation.source.path},record,current.project);
    Object.assign(result.transcript,{status:'verified',invocationVerified:true});
    result.observation={sessionId:observation.sessionId,projectKey:observation.projectKey,runId:observation.runId,event:observation.lastHook.event,at:observation.lastHook.at};
+   const observedProduct=observation.product||(record.product!=='auto'?record.product:null);
+   assert.ok(['ide','cli'].includes(observedProduct),'Observed native product identity missing');
+   Object.assign(result,{product:observedProduct,productVersion:observation.productVersion||'unreported',effective:effectiveByProduct[observedProduct]===true,identitySource:observation.identitySource||'legacy-profile',recovery:observation.recovery||null});
   }
   const recent=observation&&Date.now()-Date.parse(observation.lastHook.at)>=0&&Date.now()-Date.parse(observation.lastHook.at)<30*60*1000;
   return {...result,status:result.effective&&recent?'active':record.product==='cli'?'pending-host-review':'registered',
    activationScope:'Only the displayed project/session/configuration and adapter bytes; not all projects or business acceptance',
-   next:record.product==='cli'?'Review /hooks in CodeBuddy Code, then use a new session.':'Reload CodeBuddy and verify a real prototype write task.'};
+   next:'CLI: review /hooks; desktop: reload. Verify an actual Skill invocation and missing-Skill recovery in the chosen host.'};
  }catch(error){if(result.transcript)Object.assign(result.transcript,{status:'unverified',invocationVerified:false});return {...result,status:'failed',errors:[error.message]};}
 }
 function main(argv=process.argv.slice(2)) {

package/skills/i3-ui-prototype/scripts/prototype-locations.cjs

@@ -12,7 +12,7 @@ function globalSkillsDir(agent, home, env) {
   let base = home;
   if (config.base === 'config') base = env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path.join(home, '.config');
   if (config.base === 'env') base = env[config.env]?.trim() || path.join(home, config.fallback);
-  if (config.env === 'CODEBUDDY_CONFIG_DIR' && (!path.isAbsolute(base) || /[\x00\r\n]/.test(base))) throw new Error('CODEBUDDY_CONFIG_DIR must be an absolute safe directory');
+  if (['CODEBUDDY_CONFIG_DIR','WORKBUDDY_CONFIG_DIR'].includes(config.env) && (!path.isAbsolute(base) || /[\x00\r\n]/.test(base))) throw new Error(`${config.env} must be an absolute safe directory`);
   if (config.alternatives && !fs.existsSync(path.join(home, path.dirname(config.path)))) {
     const alternative = config.alternatives.find(relative => fs.existsSync(path.join(home, path.dirname(relative))));
     if (alternative) return path.join(home, alternative);