@givolt/i3-composer-agent 3.2.1 → 4.0.1

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

@@ -1,216 +0,0 @@
-'use strict';
-// A: deterministic predicates shared by command gates, receipts, and Hook feedback.
-// A successful predicate correlates native source and current bytes; it is not a signature.
-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) {
- if(!['Write','Edit','MultiEdit','write_to_file','replace_in_file'].includes(call.name))return false;
- const file=call.input.file_path||call.input.filePath||call.input.path||call.input.TargetFile;
- if(typeof file!=='string')return false;
- const rel=path.relative(directory,path.resolve(call.cwd||directory,file));
- return /^(?:app[\\/](?:src|public)[\\/]|mocks[\\/]|design-system[\\/])/.test(rel);
-}
-function nativeRef(data,ref) {
- const call=E.reference(data.source.calls,ref);
- if(data.source.stableThroughLine!==undefined)assert.ok(call.resultLine<=data.source.stableThroughLine,'Native result is outside the completed evidence prefix');
- same(call.sessionId,data.binding.sessionId,'Native call belongs to another or unknown session');
- assert.ok(call.requestLine>=data.binding.entryLine,'Native call predates this task');return call;
-}
-function skill(data,ref,key,before=Infinity) {
- // Loading may be reused within this session/context, including before task binding.
- const call=E.reference(data.source.calls,ref);
- if(data.source.stableThroughLine!==undefined)assert.ok(call.resultLine<=data.source.stableThroughLine,'Skill result is outside the completed evidence prefix');
- same(call.sessionId,data.binding.sessionId,'Skill session differs or is unknown');same(call.skill,key,`Actual ${key} Skill load required`);
- assert.ok(call.requestLine>(data.source.contextLine||0),'Skill must be reloaded in the current context');
- assert.ok(call.resultLine<before,'Skill must load before implementation or execution');return call;
-}
-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.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');
- for(const key of ['runId','sessionId','projectKey','policyDigest'])same(d.proof[key],d.binding[key],`Execution ${key} differs`);
- 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');
- if(d.binding.association==='automatic'){
-  const prompt=d.source.prompts.find(p=>p.line===d.binding.entryLine);
-  same(prompt?.digest,d.binding.promptDigest,'Automatic execution context belongs to a different native task');
-  same(d.binding.contextLine,d.source.contextLine,'Automatic execution context changed');
- }else 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;
-  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&&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');
- const required=Object.keys(d.files||{}).filter(file=>/^(?:app\/src\/|mocks\/)/.test(file));
- for(const binding of d.implementation?.bindings||[])for(const file of binding.files||[])required.push(file.path);
- assert.ok(required.length,'Actual UI source review required');
- exact((d.proof.frontend.files||[]).map(f=>f.path),required,'Frontend review file coverage differs');
- for(const file of d.proof.frontend.files)same(file.sha256,E.sha(d.files[file.path]),'Frontend reviewed source bytes changed');
- exact(d.proof.frontend.requirementIds||[],(d.scope?.requirements||[]).map(r=>r.id),'Frontend requirement review coverage differs');
-}
-function design(d) {
- const queries=d.proof.official?.queries;assert.ok(Array.isArray(queries)&&queries.length,'Business framework queries required');
- if(d.policy.officialCallable)skill(d,d.proof.official.skill,'antdv',Math.min(...queries.map(q=>nativeRef(d,q).requestLine)));
- else {
-  assert.equal(d.proof.official.channel,'official-source','Disclose the equivalent official source channel');
-  const failed=d.source.calls.find(c=>c.toolCallId===d.proof.official.unavailable?.toolCallId);
-  assert.ok(failed?.skill==='antdv'&&!failed.success&&failed.resultLine&&failed.sessionId===d.binding.sessionId&&failed.requestLine>=d.binding.entryLine&&failed.requestLine>(d.source.contextLine||0)&&/not found|unavailable|not available|unknown skill|not in.*list|未找到|不可用/i.test(E.contentText(failed.result)),'Actual unavailable official Skill result required for fallback');
- }
- const version=quote(d,d.proof.official.version);
- assert.ok(/(?:Read|read_file|Bash|WebFetch|mcp__)/.test(version.name),'Version must come from an actual source tool');
- assert.ok(JSON.stringify(version.input).includes('antdv-next'),'Target package version source required');
- assert.ok(d.frameworkVersion&&d.proof.official.version.quote.includes(d.frameworkVersion),'Target framework version was not verified');
- const components=[...new Set((d.implementation?.bindings||[]).flatMap(b=>b.components||[]).filter(c=>!c.startsWith('application:')))];
- for(const component of components)assert.ok(queries.some(q=>q.component===component),`Actual API query missing: ${component}`);
- for(const query of queries) {
-  assert.ok(query.component&&(!components.length||components.includes(query.component)),'Unrelated framework query');
-  const call=quote(d,query),input=JSON.stringify(call.input);
-  assert.ok(!call.skill&&input.includes(query.component),'Probe or Skill load is not a business API query');
-  if(!d.policy.officialCallable)assert.ok(/https:\/\/(?:www\.)?(?:antdv-next\.com|github\.com\/antdv-next)|node_modules[\\/]antdv-next/.test(input),'Fallback must use official docs, types, or source');
- }
- if(d.policy.mode==='template') {
-  const chosen=d.proof.templateChoice?.quote;
-  const explicit=typeof chosen==='string'&&/template\s*(?:mode|模式)|模板模式|基础(?:生成|模式)|(?:选择|使用|采用)\s*template/i.test(chosen);
-  const promptChoice=typeof chosen==='string'&&d.source.prompts.some(p=>p.line<=d.binding.entryLine&&p.text.includes(chosen)&&(explicit||p.text.trim()==='template'&&chosen==='template'));
-  let answerChoice=false;
-  if(d.proof.templateChoice?.toolCallId){const answer=nativeRef(d,d.proof.templateChoice);assert.ok(/^(?:AskUserQuestion|ask_followup_question)$/.test(answer.name),'Actual native user question result required');const selected=A.extract(A.resultData(answer.result),d.proof.templateChoice.answerPointer);answerChoice=['template','模板模式','基础生成','基础模式'].includes(selected);}
-  assert.ok(promptChoice||answerChoice,'Explicit native user template choice required');return;
- }
- assert.ok(d.proof.uiux?.queries?.length,'Actual UIUX queries required in professional mode');
- skill(d,d.proof.uiux.skill,'uiux',Math.min(...d.proof.uiux.queries.map(q=>nativeRef(d,q).requestLine)));
- for(const query of d.proof.uiux.queries) {
-  const call=quote(d,query);assert.ok(!call.skill&&query.query&&JSON.stringify(call.input).includes(query.query),'UIUX probe is not a task query');
-  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.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');
-  }
- }
- assert.ok(d.designReview?.records?.length,'Current design review required');
- for(const record of d.designReview.records)assert.ok(d.proof.uiux.queries.some(q=>q.query===record.query&&q.decisions.some(r=>r.identity===record.resultIdentity&&r.decision===record.decision&&r.rationale===record.rationale)),'Design review differs from actual UIUX query decisions');
-}
-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.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;
-}
-function browser(d) {
- const built=build(d);assert.ok(d.business&&d.devtools,'Actual business and DevTools reports required');
- const loaded=skill(d,d.devtools.skill,'browser');
- const calls=d.devtools.mcp?.calls;assert.ok(calls?.length,'Actual DevTools calls required');
- for(const ref of calls) {
-  const call=nativeRef(d,ref);same(call.name,ref.tool,'DevTools native tool name differs');
-  assert.ok(/^mcp__.*chrome.*devtools.*__/.test(call.name),'CodeBuddy requires Chrome DevTools MCP');
-  assert.ok(call.requestLine>loaded.resultLine&&call.requestLine>built.resultLine,'Browser calls must follow Skill loading and the current build');
- }
- const preview=nativeRef(d,d.proof.browser?.preview);
- assert.ok(/^mcp__.*chrome.*devtools.*__(?:navigate_page|new_page)$/.test(preview.name)&&JSON.stringify(preview.input).includes(d.business.previewBaseURL),'Actual current preview navigation required');
- assert.ok(preview.requestLine>built.resultLine&&preview.requestLine>loaded.resultLine,'Preview must follow the current build and browser Skill');
- const identityCall=quote(d,d.proof.browser?.identity);
- assert.ok(calls.some(c=>c.toolCallId===identityCall.toolCallId)&&d.proof.browser.identity.quote.includes(d.current.digest),'Actual browser candidate identity missing');
- for(const kind of ['dom','screenshot','console','network','accessibility','performance']) {
-  const fact=d.proof.browser.observations?.[kind],call=quote(d,fact);
-  assert.ok(calls.some(c=>c.toolCallId===call.toolCallId),`${kind} observation is not from reviewed MCP calls`);
-  assert.ok(({dom:['evaluate_script'],screenshot:['take_screenshot'],console:['list_console_messages'],network:['list_network_requests'],accessibility:['take_snapshot'],performance:['performance_stop_trace']})[kind].some(method=>call.name.endsWith(`__${method}`)),`${kind} fact uses the wrong native method`);
- }
- for(const journey of d.business.journeys||[]) {
-  const facts=(d.proof.browser.facts||[]).filter(f=>f.scenarioId===journey.id);assert.ok(facts.length,`Native scenario facts missing: ${journey.id}`);
-  const observation=d.business.generationObservations?.find(o=>o.scenarioId===journey.id);
-  for(const fact of facts) {
-   const call=quote(d,fact);assert.ok(/^mcp__.*chrome.*devtools.*__/.test(call.name)&&call.requestLine>preview.resultLine,'Scenario facts must follow actual preview navigation');
-   if(observation)assert.ok(observation.toolCallIds.includes(call.toolCallId)&&observation.steps.some(s=>s.observed.includes(fact.quote)),'Scenario fact differs from actual observation');
-  }
- }
- const fixed=A.validate(d.assertions,d.business.journeys.map(j=>j.id));
- for(const scenario of fixed.scenarios)for(const [checkIndex,check] of scenario.checks.entries()) {
-  const fact=d.proof.browser.facts.find(f=>f.scenarioId===scenario.scenarioId&&f.checkIndex===checkIndex);assert.ok(fact,'Fixed scenario assertion has no actual native fact');
-  const call=nativeRef(d,fact);assert.ok(call.name.endsWith(`__${check.method}`),'Native fact method differs from fixed check');
-  A.compare(A.extract(A.resultData(call.result),check.pointer),check);
- }
-}
-function automatic(d,stage){
- P.validate(d.policy);
- const prompt=d.source.prompts.find(item=>item.line===d.binding.entryLine);
- assert.ok(prompt,'Original prototype request is missing');same(d.binding.promptDigest,prompt.digest,'Original prototype request changed');
- same(d.binding.inputDigest,d.current.inputDigest,'Prototype inputs changed');same(d.binding.contextLine,d.source.contextLine,'Native context changed');
- const needs=P.requirements(d.policy,stage),calls=d.source.calls.filter(c=>c.sessionId===d.binding.sessionId&&c.success&&c.resultLine&&c.requestLine>d.source.contextLine);
- const refs={},required=needs.filter(k=>['frontend','antdv','uiux','browser'].includes(k));
- if(needs.includes('implementation'))required.push('frontend',...(d.policy.officialCallable?['antdv']:[]),...(d.policy.mode==='professional'?['uiux']:[]));
- const writes=calls.filter(c=>c.requestLine>=d.binding.entryLine&&uiWrite({...c,cwd:c.cwd||d.binding.project},d.binding.directory));
- for(const key of [...new Set(required)]){
-  const loaded=calls.filter(c=>c.skill===key),firstWrite=writes.length?Math.min(...writes.map(c=>c.requestLine)):Infinity;
-  const call=['frontend','antdv','uiux'].includes(key)?loaded.find(c=>c.resultLine<firstWrite):loaded.at(-1);
-  assert.ok(call,`Actual ${key} Skill invocation required before UI implementation; invoke it and retry this operation`);
-  if(['frontend','antdv','uiux'].includes(key)&&writes.length)assert.ok(call.resultLine<Math.min(...writes.map(c=>c.requestLine)),`${key} Skill must precede business UI writes`);
-  refs[key]={toolCallId:call.toolCallId,resultDigest:call.resultDigest};
- }
- if(needs.includes('implementation'))assert.ok(writes.length,'Actual business UI implementation write required');
- if(needs.includes('build')){
-  assert.ok(d.build&&d.build.candidateDigest===d.current.digest,'Current prototype build required');
-  const built=calls.find(c=>{const commandInfo=command.nativeCommand(c.name,c.input,c.cwd||d.binding.project);const result=E.resultValue(c.result);return commandInfo?.operation==='build'&&commandInfo.root===d.binding.directory&&result?.buildId===d.build.buildId&&result?.buildDigest===d.build.buildDigest;});
-  assert.ok(built,'Actual current build result required');refs.build={toolCallId:built.toolCallId,resultDigest:built.resultDigest};
- }
- if(needs.includes('browser-results')){
-  const loaded=calls.filter(c=>c.skill==='browser').at(-1),built=calls.find(c=>c.toolCallId===refs.build?.toolCallId);
-  const observed=calls.filter(c=>/^mcp__.*chrome.*devtools.*__/.test(c.name)&&c.requestLine>Math.max(loaded.resultLine,built.resultLine));
-  assert.ok(observed.some(c=>/__(?:new_page|navigate_page)$/.test(c.name)),'Actual browser navigation required');
-  assert.ok(observed.some(c=>c.name.endsWith('__evaluate_script')&&E.resultText(c.result).includes(d.current.digest)),'Actual browser candidate identity required');
-  for(const method of ['take_screenshot','list_console_messages','list_network_requests','take_snapshot','performance_stop_trace'])assert.ok(observed.some(c=>c.name.endsWith('__'+method)),`Actual browser ${method} required`);
-  assert.ok(d.business&&d.business.candidateDigest===d.current.digest&&d.business.buildId===d.build.buildId,'Current business browser report required');
-  const fixed=A.validate(d.assertions,d.business.journeys.map(j=>j.id));
-  for(const scenario of fixed.scenarios)for(const check of scenario.checks){
-   const observation=d.business.generationObservations?.find(o=>o.scenarioId===scenario.scenarioId);
-   const results=observed.filter(c=>c.name.endsWith('__'+check.method)&&(!observation||observation.toolCallIds.includes(c.toolCallId)));
-   assert.ok(results.some(c=>{try{A.compare(A.extract(A.resultData(c.result),check.pointer),check);return true;}catch{return false;}}),`Actual browser assertion missing: ${scenario.scenarioId} ${check.pointer}`);
-  }
- }
- return {status:'passed',stage,policyDigest:d.policy.digest,runId:d.binding.runId,sessionId:d.binding.sessionId,projectKey:d.binding.projectKey,host:d.policy.host,productForm:d.binding.product,productVersion:d.binding.productVersion,installationScope:d.binding.scope,
-  operation:d.binding.operation,mode:d.policy.mode,inputDigest:d.current.inputDigest,candidateDigest:d.current.digest,revision:d.current.revision,association:'automatic',skills:refs,source:{path:d.source.path,bytes:d.source.bytes,digest:d.source.digest},
-  ...(d.source.callbackJournal?{callbackJournal:d.source.callbackJournal}:{}),...(d.binding.recovery?{recovery:d.binding.recovery}:{}),invocationVerification:'native-source-correlated',tamperProof:false};
-}
-function evaluate(data,stage) {
- try {
-  if(data.binding?.association==='automatic')return automatic(data,stage);
-  identity(data);const needs=P.requirements(data.policy,stage);
-  if(needs.includes('frontend')||needs.includes('implementation'))frontend(data,needs.includes('implementation'));
-  if(needs.some(n=>['antdv','official-source','uiux'].includes(n)))design(data);
-  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: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

@@ -1,62 +0,0 @@
-'use strict';
-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'],
-  prototype: [['ui','prototype'].join('-'), 'i3-ui-prototype'],
-  antdv: ['antdv'], uiux: ['ui-ux-pro-max'],
-});
-const STAGES = ['design', 'implementation-entry', 'implementation', 'build', 'browser-entry', 'browser', 'delivery'];
-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;
-  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: 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 && [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;
-}
-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',...(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) {
- 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) {
-  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, AUTO_ID, SKILLS, STAGES, digest, create, validate, requirements, skillKey, creationOptions };

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

@@ -1,58 +0,0 @@
-'use strict';
-// Reminder/audit records do not authorize operations. The current native Skill
-// results and stage predicates decide whether an operation can proceed.
-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=binding?.association!=='automatic'&&!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,automatic=false}={}){
- 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')?(automatic?'按本次构建或交互验收返回的具体缺项修正原型后重试；调用记录由 Hooks 自动采集，不检查或修复 Hooks。':'执行 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,source.contextLine,directory,index.bindings?.[directory]?.runId||null]));
- 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]&&(answer.deny||answer.feedback))return remember({...answer});
- 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);
-   const afterSkills=state.invocations.every(call=>context.retry?.requestLine>call.resultLine);
-   state.status=context.retrySucceeded&&matchingRetry&&afterSkills&&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,69 +0,0 @@
-'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');
- if(!value&&!fs.existsSync(metaFile))return null; // Standalone legacy evidence validators have no artifact metadata.
- const meta=json(metaFile);
- if(!value){assert.ok(!meta.runtime.executionPolicy&&!fs.existsSync(inside(directory,'qa/execution-context.json')),'Fixed execution policy was removed');return null;}
- P.validate(value);assert.equal(meta.runtime.executionPolicy,value.id,'Execution runtime identity differs');assert.equal(meta.expertMode,value.mode,'Execution mode changed');
- 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 metadata=inside(directory,'prototype.json');
- const automaticExpected=fs.existsSync(metadata)&&json(metadata).runtime?.executionPolicy===P.AUTO_ID;
- const recover=automaticExpected?'Prototype audit Hooks are retired. Normal prototype commands no longer require this historical audit binding.':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');
- assert.equal(entry.runId,pointer.runId,'Native run pointer differs');assert.equal(entry.directory,directory);assert.equal(entry.project,project);
- assert.equal(entry.instanceId,json(inside(directory,'prototype.json')).instanceId,'Prototype instance differs');
- assert.equal(entry.registrationDigest,selected.registrationDigest,'Hook registration changed');assert.equal(entry.settingsDigest,selected.settingsDigest,'Hook settings changed');
- C.prefix(entry.source.path,entry.source.bytes,entry.source.digest);
- 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.restriction(source.prompts).blocked,'The user requested read-only work or stopped implementation');
- assert.equal(entry.contextLine,source.contextLine,'Native context changed; '+recover);
- return {entry,source,selected};
-}
-function data(directory,lib,options={}) {
- directory=fs.realpathSync(directory);const fixed=policy(directory);if(!fixed)return null;
- const {entry,source,selected}=binding(directory),current=lib.manifest(directory);
- const proof=options.proof||optional(directory,'qa/execution-evidence.json');
- const files={};for(const file of Object.keys(current.files))if(/^(?:app\/src\/|app\/public\/|mocks\/|design-system\/)/.test(file))files[file]=fs.readFileSync(inside(directory,file));
- 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?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};
-}
-function check(directory,stage,lib,options={}) {
- try {const value=data(directory,lib,options);if(!value)return {status:'not-required',policy:'legacy',invocationVerification:'unverified',tamperProof:false};return G.evaluate(value,stage);}
- catch(error){return {status:'failed',stage,errors:[error.message],invocationVerification:'unverified'};}
-}
-function requireStage(directory,stage,lib,options={}) {
- assert.ok(P.STAGES.includes(stage),'Unknown execution stage');
- // Only the automatic callback audit is retired. Existing fixed inputs,
- // framework/build checks and business/DevTools evidence are checked by their owners.
- return {status:'not-required',stage,auditHook:'retired',invocationVerification:'unverified',tamperProof:false};
-}
-function template(directory,lib) {
- const fixed=policy(directory);assert.ok(fixed,'This existing prototype retains its original execution contract');
- const {entry,source}=binding(fs.realpathSync(directory)),current=lib.manifest(directory);
- const ref=key=>{const call=E.loaded(source.calls,key).filter(c=>c.requestLine>source.contextLine).at(-1);return call?{toolCallId:call.toolCallId,resultDigest:call.resultDigest}:null;};
- return {schemaVersion:1,runId:entry.runId,sessionId:entry.sessionId,projectKey:entry.projectKey,policyDigest:fixed.digest,inputDigest:current.inputDigest,candidateDigest:current.digest,revision:current.revision,
-  frontend:{...ref('frontend'),files:[],requirementIds:[]},official:{skill:ref('antdv'),channel:fixed.officialCallable?'native-skill':'official-source',version:null,queries:[]},
-  ...(fixed.mode==='professional'?{uiux:{skill:ref('uiux'),queries:[]}}:{templateChoice:{quote:null}}),build:null,browser:{skill:ref('browser'),report:'qa/business-browser-input.json',preview:null,identity:null,observations:{},facts:[]}};
-}
-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.'};
-}
-module.exports={policy,binding,data,check,requireStage,template,begin};

package/skills/i3-ui-prototype/scripts/generation-assets.cjs

@@ -1,18 +0,0 @@
-'use strict';
-// Maintainer-only derived assets. Runtime analysis never invokes write mode.
-const {fs,path,assert,json,write,inside}=require('./native-files.cjs');
-function refresh(skillRoot,options={}){
- const templates=path.join(skillRoot,'assets/templates'),catalog=json(path.join(templates,'catalog.json')),inventory=require('./template-inventory.cjs');const choices=[];const summaries=[];
- for(const entry of catalog.templates.filter(item=>item.availability==='available'&&item.contentRoot)){
-  assert.ok(/^[a-z][a-z0-9-]{0,63}$/.test(entry.contentRoot),'Unsafe template content root');const root=inside(templates,entry.contentRoot),meta=json(path.join(root,'generation.json'));
-  assert.equal(meta.templateId,entry.id,'Generation template identity differs');
-  const current=inventory.scan(root),file=path.join(root,'template-inventory.json');
-  if(options.check)inventory.verify(root,json(file));else write(root,'template-inventory.json',current);
-  choices.push({id:entry.id,name:entry.name,defaults:meta.defaults,choices:meta.choices,patterns:meta.patterns});
-  summaries.push({id:entry.id,files:Object.keys(current.files).length,pages:current.pages.length,components:Object.keys(current.components).length,events:current.eventCount});
- }
- const script=`// Generated from registered template metadata; refresh with sync-generation-assets.\nglobalThis.I3_GENERATION_OPTIONS = ${JSON.stringify(choices,null,2)};\n`,file=path.join(templates,'generation-options.js');
- if(options.check)assert.equal(fs.readFileSync(file,'utf8'),script,'Offline customer choices differ from registered template metadata');else write(templates,'generation-options.js',script);
- return {status:'passed',readOnly:!!options.check,templates:summaries};
-}
-module.exports={refresh};