@givolt/i3-composer-agent 2.3.6 → 3.0.0

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

@@ -57,7 +57,7 @@ analyze 的交付是需求／能力覆盖、模板与框架选型、交互验收
 
 已有 v2 实例先运行一次 `node <skill-root>/scripts/native-pilot.cjs state <prototype-root>`，从聚合结果恢复身份、固定需求、设计／构建／实际QA、负责人和下一步的精确命令。不要为寻找参数反复遍历全仓库、node_modules或阅读控制器内部实现。这里只读检查，不安装、启动浏览器或更新状态。
 
-制作前实际调用所需的前端／框架／设计 Skill，真实浏览器验收使用浏览器 Skill；不能以读取 SKILL.md 代替调用。安装器注册的 Hooks 自动运行。收到缺少 Skill 的反馈时，补调该 Skill、等待成功后重试原操作；基础设施异常只简要报告未验收项，由独立维护入口处理，不在原型任务中排查。
+制作前实际调用所需的前端／框架／设计 Skill，真实浏览器验收使用浏览器 Skill；不能以读取 SKILL.md 代替调用。安装器注册的 Hooks 自动运行。收到缺少 Skill 的反馈时，补调该 Skill、等待成功后重试原操作。同一有效上下文内的成功加载可复用，普通追问后继续原任务，不重新绑定或重复加载全部 Skill；基础设施异常只简要报告未验收项，由独立维护入口处理，不在原型任务中排查。
 
 新 create 使用实际 `--host <codebuddy|workbuddy>`。按 PRD 和固定能力制定交互验收场景，使用 `native-pilot.cjs execution-assertions-template --scope <scope-file>` 取得场景骨架，填充预期 JSON 事实并传 `--execution-assertions <assertions-file>`。这是原型交互验收，不要求手动绑定会话或填写 Hook 调用记录。旧 HTML 和既有 execution-* 入口保持兼容。
 

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

@@ -48,7 +48,7 @@ node <skill-root>/scripts/native-pilot.cjs execution-assertions-template --scope
 
 ## 会话绑定与阶段
 
-通过自然语言／using 选到工作 Skill，或实际 `/i3-prototype` 快捷入口后，新实例执行 `execution-begin <prototype-root>`。B 回查原生用户请求和工作 Skill／快捷命令，绑定规范化 projectKey、sessionId、runId、实例、输入、模式、策略与注册。只读或停止请求不能启动写任务。新会话／新请求／压缩后的上下文在恢复实施前重新 begin 并加载适用 Skill；用户手改保留。初建骨架不等于实际实施。
+以下显式入口仅供已有使用者兼容：通过自然语言／using 选到工作 Skill，或实际 `/i3-prototype` 快捷入口后，执行 `execution-begin <prototype-root>`。B 回查原生来源，关联 projectKey、sessionId、runId、实例、输入、模式、策略与注册。只读或停止请求不能启动写任务。新会话／压缩后的上下文需重新核验适用 Skill；普通追问延续原运行，不要求重新 begin。用户手改保留。初建骨架不等于实际实施。
 
 使用 `state` 中的 `commands.executionBegin.shell` 或拒绝反馈中的绝对路径命令，作为一次独立 Shell 调用；不加 `cd &&`、管道、重定向或 `head`。严格解析器不解释组合 Shell。成功须同时满足进程退出 0 和内层 `status=bound`；外层 `status=success`／`success:true` 不足以证明阶段成功。缺绑定、任务切换、上下文变化或输入变化时重新执行，不能由 CLI 自行写入原生绑定；A 和写入门禁回查当前任务最新一次 begin 的成功结果，失败／待返回不可复用旧成功。
 
@@ -88,7 +88,7 @@ PostToolUse 观察到已落盘的 begin／阶段失败时，通过该事件的 a
 
 重试按 kind 区分 ui-write 和 stage；阶段重试绑定实际 operation、stage 与同一原型目录。两类新记录都以 feedbackLine 核对请求发生在反馈之后，旧成功回调不能恢复后续拒绝；旧无 kind 的记录继续仅按页面写入合同核验。
 
-默认同一缺项两次、单原生任务总计六次，重复回调不增加预算，反复 begin 和内部 providerData.isMeta 的 Hook 消息不重置任务。达到上限时保持受管操作拒绝，允许真实 blocked 报告正常结束；不无限驱动 Stop。用户只读／暂停优先。入口、Skill 发现、加载成功、CLI 查询、重试成功、交付和用户认可分开记录。
+同一会话／有效上下文／原型运行默认同一缺项提示两次、累计六次；重复回调、普通追问、反复 begin 和内部 providerData.isMeta 消息不重置计数。达到上限只停止重复催调，仍缺项则拒绝当前操作，取得真实成功结果后重新按事实放行。required／ready-to-retry／recovered／blocked 保留为兼容审计显示，不构成额外许可或永久锁。允许如实报告阻塞，不无限驱动 Stop。用户只读／暂停优先。入口、Skill 发现、加载成功、CLI 查询、重试成功、交付和用户认可分开记录。
 
 每宿主／范围实测：故意漏调 → 写入被拒且文件未被该操作修改 → 本主会话实际 Skill 成功 → 原操作重试成功；失败调用、旧上下文、假 ID、旧会话及当前构建缺项不能放行。持续缺项须在预算耗尽后报告阻塞。源测试里的合成日志只能验证解析和门禁逻辑，不证明模型会补调。原生 Hooks 没有指定下一工具的执行接口，不能承诺必然调用，也不是任意 Shell 安全隔离。
 

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

@@ -68,8 +68,25 @@ function readOnly(prompt) {
  if(/先.{0,4}(?:分析|讨论|梳理|检查|解释)/.test(prompt)&&!/(?:然后|再|后).{0,8}(?:实现|实施|修改|继续)/.test(prompt))return true;
  return /^\s*(?:请|先)?(?:暂停|停止|取消)(?:[，。！\s]|(?:这|当前|实施|工作|修改|生成))|^\s*(?:stop|cancel|pause)\b/i.test(prompt);
 }
+function userRestriction(prompt) {
+ if(readOnly(prompt))return true;
+ // Only an explicit request to resume implementation releases a restriction.
+ // Ordinary questions never turn a pause into permission to write.
+ if(typeof prompt!=='string'||/[?？]|(?:为什么|如何|是否|哪些|什么|是不是|能不能|吗)/.test(prompt))return null;
+ const text=prompt.trim().replace(/^(?:(?:那就|好的?|现在|请|可以)[，,\s]*)+/,'').replace(/^please\s+/i,'');
+ const resume=/^(?:继续|恢复)(?:[。！!\s]*$|吧[。！!\s]*$|实施|实现|开发|修改|执行|生成|修订|(?:当前|本次)?原型(?:的)?(?:实施|实现|开发|修改|制作|生成|修订))/.test(text)||/^(?:开始实施|开始实现|实施吧|执行吧)/.test(text)||/^(?:按|按照|依照)[^\n]{0,40}(?:方案|计划)[，,\s]*(?:开始)?(?:实施|实现|执行)(?:吧)?(?:[，,。！!\s]|$)/.test(text)||/^(?:帮我)?(?:生成|创建|实现|修订|修改|制作)[^\n]{0,20}原型/.test(text)||/^\/i3-prototype\b[^\n]*(?:生成|实现|创建|修订|修改|继续)/.test(text)||/^(?:continue|resume)(?:[.!\s]*$|\s+(?:the prototype\s+)?(?:implementation|implementing|development|coding)\b)|^(?:proceed|start implementation)[.!\s]*$/i.test(text);
+ return resume?false:null;
+}
+function restriction(prompts=[],previous) {
+ const value={blocked:previous?.blocked===true,throughLine:previous?.throughLine||0};
+ for(const prompt of prompts)if(prompt.line>value.throughLine){
+  const control=userRestriction(prompt.text);if(control!==null)value.blocked=control;
+  value.throughLine=prompt.line;
+ }
+ return value;
+}
 function prefix(file,bytes,digest) {
  assert.ok(Number.isSafeInteger(bytes)&&bytes>0&&bytes<=64*1024*1024,'Invalid source cursor');
  const raw=E.cursorBytes(file);assert.ok(raw.length>=bytes,'Native transcript was truncated');assert.equal(E.sha(raw.subarray(0,bytes)),digest,'Native transcript prefix changed');
 }
-module.exports={FILES:Object.freeze(FILES),read,scriptsForEntry,bundle,registration,globalBase,select,projectKey,sessionDirectory,source,readOnly,prefix};
+module.exports={FILES:Object.freeze(FILES),read,scriptsForEntry,bundle,registration,globalBase,select,projectKey,sessionDirectory,source,readOnly,userRestriction,restriction,prefix};

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

@@ -52,8 +52,8 @@ function eventSource(payload,record,project,{readSource=C.source,pause=milliseco
   }catch(error){if(attempt===attempts)throw error;pause(100);}
  }
 }
-function decision({event,source,binding,tool,input,directory,cwd,deliveryCurrent,stopHookActive=false,policy}) {
- if(C.readOnly(source.prompts.at(-1)?.text||''))return {continue:true,reason:'latest-user-read-only'};
+function decision({event,source,binding,tool,input,directory,cwd,deliveryCurrent,stopHookActive=false,policy,restricted}) {
+ if(restricted??C.restriction(source.prompts).blocked)return {continue:true,reason:'user-read-only-or-stopped'};
  if(event==='PreToolUse'&&G.uiWrite({name:tool,input:input||{},cwd},directory)) {
   const missing=Recovery.missing({source,binding,policy});
   if(missing.length)return {deny:true,missing,reason:'原型 UI 写入已被阻止。'+Recovery.instruction(missing,{directory,automatic:binding?.association==='automatic'})};
@@ -92,7 +92,7 @@ function settleNativeRetries(index,source,{project,sessionId}) {
  let changed=false;
  for(const entry of Object.values(index.bindings)) {
   const repair=entry.recovery,expected=repair?.expectedRetry;
-  if(!expected||!['required','ready-to-retry'].includes(repair.status)||entry.entryLine!==source.prompts.at(-1)?.line||entry.contextLine!==source.contextLine)continue;
+  if(!expected||!['required','ready-to-retry'].includes(repair.status)||entry.contextLine!==source.contextLine)continue;
   const matches=source.calls.filter(call=>{
    if(!call.success||!call.resultLine||call.sessionId!==sessionId||call.requestLine<=entry.entryLine||source.stableThroughLine!==undefined&&call.resultLine>source.stableThroughLine)return false;
    if(expected.kind==='ui-write') {
@@ -117,11 +117,7 @@ function dispatch(payload,options) {
  payload={...payload,tool_name:toolName(payload.tool_name)};
  assert.equal(payload.hook_event_name,options.event,'Hook event mismatch');
  if(options.event==='SessionStart')return {continue:true};
- if(options.event==='UserPromptSubmit'){
-  const prompt=payload.prompt||'';
-  if(!C.readOnly(prompt)&&(/\/i3-prototype\b(?!\s+(?:analyze|inspect|confirm-baseline))/.test(prompt)||/(?:生成|实现|创建|修订|修改|继续).{0,16}原型|(?:create|revise|implement).{0,20}prototype/i.test(prompt)))return {continue:true,context:'原型实施：界面实现前实际调用 i3-frontend-ui-engineering；使用 antDv 时加载 antdv 并查询实际组件。专业模式还须调用 UIUX。真实浏览器验收使用浏览器 Skill。缺少必要 Skill 时立即补调，成功返回后重试原操作。'};
-  return {continue:true};
- }
+ if(options.event==='UserPromptSubmit')return {continue:true};
  let identity,installed;
  try{installed=options.product==='auto'?C.registration(options.base):null;identity=H.identify(payload,installed||{schemaVersion:1,product:options.product},options);}catch(error){
   const project=options.scope==='project'?path.dirname(options.base):payload.cwd;
@@ -144,7 +140,7 @@ function dispatch(payload,options) {
   throw error;
  }
  const latest=source.prompts.at(-1);
- if(C.readOnly(latest.text)) {
+ if(options.restricted??C.restriction(source.prompts).blocked) {
   const native=nativeCommand(payload.tool_name,payload.tool_input,cwd),root=native?.root||prototypeForWrite(project,payload.tool_name,payload.tool_input,cwd);
   if(options.event==='PreToolUse'&&(native&&['create','execution-begin','build','revise','replan','record-run','record-devtools-review','finalize'].includes(native.operation)||root&&X.policy(root)&&G.uiWrite({name:payload.tool_name,input:payload.tool_input,cwd},root)))return {deny:true,reason:'The latest user request is read-only or stopped; no prototype mutation is authorized.'};
   return {continue:true};
@@ -185,16 +181,17 @@ function dispatch(payload,options) {
  };
  const automatic=options.event==='PreToolUse'&&directory&&fs.existsSync(path.join(directory,'prototype.json'))&&X.policy(directory)&&
   (command||G.uiWrite({name:payload.tool_name,input:payload.tool_input||{},cwd},directory))&&command?.operation!=='execution-begin'&&
-  (!existing||existing.entryLine!==latest.line||existing.contextLine!==source.contextLine||existing.inputDigest!==require('./native-pilot-lib.cjs').manifest(directory).inputDigest);
+  (!existing||existing.contextLine!==source.contextLine||existing.registrationDigest!==record.registrationDigest||existing.settingsDigest!==record.settingsDigest||existing.inputDigest!==require('./native-pilot-lib.cjs').manifest(directory).inputDigest);
  if(options.event==='PreToolUse'&&command?.operation==='execution-begin'||automatic) {
   assert.ok(directory&&directory.startsWith(path.join(project,'prototypes')+path.sep),'Prototype must be in this project');
   const fixed=X.policy(directory);assert.ok(fixed,'Existing prototype retains its original contract; do not rewrite it implicitly');
   assert.equal(fixed.host,identity.host,'This prototype has a fixed contract for another host; inspect it or explicitly migrate and revalidate, do not inherit its invocation proof');
   const loaded=E.loaded(source.calls,'prototype').some(c=>c.requestLine>source.contextLine);
-  assert.ok(loaded||/^\s*\/i3-prototype\b/.test(latest.text)||automatic&&require('./execution-diagnostics.cjs').intent(latest.text),'Native prototype Skill or actual shortcut entry required');
+  assert.ok(automatic||loaded||/^\s*\/i3-prototype\b/.test(latest.text),'Native prototype Skill or actual shortcut entry required');
   const meta=F.json(path.join(directory,'prototype.json')),lib=require('./native-pilot-lib.cjs'),current=lib.manifest(directory);
-  const runId=existing&&existing.entryLine===latest.line&&existing.inputDigest===current.inputDigest&&existing.contextLine===source.contextLine?existing.runId:crypto.randomUUID();
-  index.bindings[directory]={schemaVersion:1,...(automatic?{association:'automatic'}:{}),runId,sessionId:payload.session_id,project,projectKey:C.projectKey(project),directory,instanceId:meta.instanceId,policyDigest:fixed.digest,inputDigest:current.inputDigest,entryLine:latest.line,promptDigest:latest.digest,contextLine:source.contextLine,
+  const reuse=existing&&existing.inputDigest===current.inputDigest&&existing.contextLine===source.contextLine&&existing.registrationDigest===record.registrationDigest&&existing.settingsDigest===record.settingsDigest;
+  const runId=reuse?existing.runId:crypto.randomUUID();
+  index.bindings[directory]={schemaVersion:1,...(automatic?{association:'automatic'}:{}),runId,sessionId:payload.session_id,project,projectKey:C.projectKey(project),directory,instanceId:meta.instanceId,policyDigest:fixed.digest,inputDigest:current.inputDigest,entryLine:reuse?existing.entryLine:latest.line,promptDigest:reuse?existing.promptDigest:latest.digest,contextLine:source.contextLine,
    operation:meta.revision==='r001'?'create':'revise',host:identity.host,identitySource:identity.identitySource,product:record.product,productVersion:identity.productVersion,scope:record.scope,registrationDigest:record.registrationDigest,settingsDigest:record.settingsDigest,source:{path:source.path,bytes:source.bytes,digest:source.digest},lastHook:{event:options.event,at:new Date().toISOString(),nativeReadAttempts:source.nativeReadAttempts,nativeRequestStatus:source.nativeRequestStatus}};
   const lock=path.join(stateDirectory,'.audit.lock');fs.mkdirSync(stateDirectory,{recursive:true});
   try{fs.mkdirSync(lock);}catch{throw new Error('Concurrent audit callback; retry the original operation');}
@@ -207,7 +204,7 @@ function dispatch(payload,options) {
   if(!automatic)return {continue:true};
  }
  if(directory&&fs.existsSync(path.join(directory,'prototype.json'))&&X.policy(directory)) {
-  const fixed=X.policy(directory),answer=decision({event:options.event,source,binding:existing,tool:payload.tool_name,input:payload.tool_input,directory,cwd,policy:fixed});
+  const fixed=X.policy(directory),answer=decision({event:options.event,source,binding:existing,tool:payload.tool_name,input:payload.tool_input,directory,cwd,policy:fixed,restricted:options.restricted});
   if(answer.deny)return respond(answer);
   if(options.event==='PostToolUse'&&command&&(command.operation==='execution-begin'||stage)){
    // IDE may not have persisted a callback's result yet. Only observed native
@@ -236,13 +233,23 @@ function dispatch(payload,options) {
  try {
   const fresh=JSON.parse(C.read(file));let changed=false;
   for(const entry of Object.values(fresh.bindings)) {
-   if(entry.entryLine!==latest.line)continue;
+   if(entry.contextLine!==source.contextLine)continue;
    if(entry.lastEventKey===eventKey)continue;
    entry.source={path:source.path,bytes:source.bytes,digest:source.digest};entry.lastEventKey=eventKey;entry.lastHook={event:options.event,at:new Date().toISOString(),nativeReadAttempts:source.nativeReadAttempts,nativeRequestStatus:source.nativeRequestStatus};changed=true;
    if(options.event==='Stop') {
+    // Completion of an unrelated task must not trigger delivery of every
+    // prototype previously visited in the session. Inspect actual operations
+    // in this response, without another task lifecycle or activation flag.
+    const workedOn=source.calls.some(call=>{
+     if(call.requestLine<=latest.line)return false;
+     if(G.uiWrite({...call,cwd:call.cwd||project},entry.directory))return true;
+     const native=nativeCommand(call.name,call.input,call.cwd||project);
+     return native?.root===entry.directory&&Object.hasOwn(stageFor,native.operation);
+    });
+    if(!workedOn)continue;
     const lib=require('./native-pilot-lib.cjs'),state=lib.state(entry.directory);
     const complete=state.execution.status==='passed'&&state.delivery?.status==='current'&&state.delivery.result.runId===entry.runId;
-    const fixed=X.policy(entry.directory),feedback=decision({event:'Stop',source,binding:entry,directory:entry.directory,deliveryCurrent:complete,policy:fixed,stopHookActive:payload.stop_hook_active||entry.stopFeedbackPrompt===latest.digest});
+    const fixed=X.policy(entry.directory),feedback=decision({event:'Stop',source,binding:entry,directory:entry.directory,deliveryCurrent:complete,policy:fixed,restricted:options.restricted,stopHookActive:payload.stop_hook_active||entry.stopFeedbackPrompt===latest.digest});
     if(feedback.feedback){const result=Recovery.record(fresh,{...recoveryContext(entry.directory),policy:fixed},feedback);entry.recovery=result.recovery;if(fixed.id!==P.AUTO_ID)entry.stopFeedbackPrompt=latest.digest;saveIndex(stateDirectory,fresh);return result;}
    }
   }
@@ -264,22 +271,13 @@ function handle(payload,options){
  const root=diagnostic&&(command?.root||prototypeForWrite(diagnostic.project,payload.tool_name,payload.tool_input,cwd));
  const mutation=command&&['create','execution-begin','build','revise','replan','record-run','record-devtools-review','finalize'].includes(command.operation)||root&&G.uiWrite({name:payload.tool_name,input:payload.tool_input||{},cwd},root);
  if(diagnostic&&toolEvent&&['Write','Edit','MultiEdit'].includes(payload.tool_name)&&!mutation)return {continue:true};
- if(diagnostic?.task.readOnly&&toolEvent)return options.event==='PreToolUse'&&mutation?{deny:true,reason:'The latest user request is read-only or stopped; no prototype mutation is authorized.'}:{continue:true};
- if(diagnostic&&!diagnostic.task.active&&toolEvent&&!mutation)return {continue:true};
- if(diagnostic&&mutation&&!diagnostic.task.active)diagnostic.task={...diagnostic.task,active:true};
- const guarded=mutation?D.guard(diagnostic,payload):null;if(guarded)return guarded;
- if(D.blocked(diagnostic)&&toolEvent&&!mutation)return {continue:true};
+ if(diagnostic?.task.restriction.blocked&&toolEvent&&mutation)return options.event==='PreToolUse'?{deny:true,reason:'The user explicitly requested read-only work or stopped implementation; no prototype mutation is authorized.'}:{continue:true};
  try{
-  const answer=dispatch(payload,diagnostic?{...options,nativeProject:diagnostic.project}:options);
-  if(toolEvent&&!answer.deny&&!answer.feedback)D.observed(diagnostic,payload);
-  if(options.event==='PostToolUse'&&command?.operation==='execution-begin'&&!answer.deny&&root&&fs.existsSync(path.join(root,'qa/execution-context.json'))){
-   const pointer=F.json(path.join(root,'qa/execution-context.json'));
-   const source=diagnostic&&C.source(payload,diagnostic.record,diagnostic.project);
-   if(pointer&&completedBegin(source,{...pointer,entryLine:source.prompts.at(-1).line,contextLine:source.contextLine,directory:root}))D.recover(diagnostic);
-  }
+  const answer=dispatch(payload,diagnostic?{...options,nativeProject:diagnostic.project,restricted:diagnostic.task.restriction.blocked}:options);
+  if(toolEvent&&!answer.deny&&!answer.feedback){if(mutation)D.recover(diagnostic);D.observed(diagnostic,payload);}
   return answer;
  }catch(error){
-  if(diagnostic){const failure=D.failure(diagnostic,payload,error);if(!mutation&&failure.deny){const {deny,reason,...rest}=failure;return {...rest,continue:true,context:reason};}return failure;}
+  if(diagnostic)return mutation?D.failure(diagnostic,payload,error):{continue:true};
   if(options.event==='PreToolUse') {
    // A damaged/absent task source must not turn a protected write into exit 1
    // (which CodeBuddy treats as non-blocking). This is a failure-only fallback,

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

@@ -2,7 +2,6 @@
 // Protocol failures exist before a run binding. Never turn them into invocation proof.
 const fs=require('node:fs'),path=require('node:path');
 const F=require('./native-files.cjs'),C=require('./codebuddy-context.cjs'),E=require('./execution-evidence.cjs'),H=require('./buddy-host.cjs');
-const intent=text=>typeof text==='string'&&!C.readOnly(text)&&(/\/i3-prototype\b(?!\s+(?:analyze|inspect|confirm-baseline))/.test(text)||/(?:生成|实现|创建|修订|修改|继续).{0,16}原型|(?:create|revise|implement).{0,20}prototype/i.test(text));
 const read=file=>fs.existsSync(file)?JSON.parse(C.read(file)):null;
 function location(payload,options){
  if(!payload.session_id||!path.isAbsolute(options.base||''))return null;
@@ -18,28 +17,35 @@ function location(payload,options){
  const record={...installation,...identity,base:options.base,registrationDigest:E.sha(JSON.stringify(installation)),settingsDigest:E.sha(C.read(path.join(options.base,'settings.json')))};
  return {project,record,identity,pointer,previous,directory:C.sessionDirectory(record,project,payload.session_id)};
 }
-function context(payload,options,{source,prompt}={}){
+function context(payload,options,{source}={}){
  const where=location(payload,options);if(!where)return null;
  let native=source;if(!native)try{native=C.source(payload,where.record,where.project);}catch{/* Failure diagnostics must survive unreadable native history. */}
- const latest=native?.prompts.at(-1),text=prompt??latest?.text??where.previous?.text;
- if(typeof text!=='string')return null;
- const digest=latest?.digest||E.sha(text),entryLine=latest?.line||where.previous?.entryLine||null;
- const taskKey=E.sha(JSON.stringify([payload.session_id,payload.prompt_id||null,entryLine,digest]));
- // A callback without prompt_id reuses only the exact observed native task.
- const task=payload.hook_event_name!=='UserPromptSubmit'&&where.previous&&where.previous.digest===digest&&where.previous.entryLine===entryLine?where.previous:
-  {schemaVersion:1,taskKey,sessionId:payload.session_id,project:where.project,host:where.identity.host,product:where.identity.product,text,digest,entryLine,active:intent(text),readOnly:C.readOnly(text),at:new Date().toISOString()};
+ // Diagnostics identify a session/context, never the wording of the last user
+ // message. UserPromptSubmit can precede persistence: do not combine its text
+ // with the preceding native prompt's cursor or digest.
+ const contextLine=native?.contextLine??where.previous?.contextLine??0;
+ const taskKey=E.sha(JSON.stringify([where.project,where.identity.host,where.identity.product,payload.session_id,contextLine]));
+ const task={schemaVersion:2,taskKey,sessionId:payload.session_id,project:where.project,host:where.identity.host,product:where.identity.product,contextLine,
+  restriction:C.restriction(native?.prompts,where.previous?.restriction)};
  return {...where,source:native,task};
 }
 function remember(payload,options){
- const value=context(payload,options,{prompt:payload.prompt});if(!value)return;
+ const value=context(payload,options);if(!value)return;
+ const id=payload.prompt_id||payload.generation_id;
+ const submission=id?E.sha(JSON.stringify([id,payload.prompt||''])):null;
+ const previous=value.previous?.submissions||[];
+ if(submission&&previous.includes(submission))return;
+ const control=C.userRestriction(payload.prompt||'');
+ // Restrict immediately. Releasing permission waits for the corresponding
+ // native user message, so a stale or unpersisted resume cannot grant writes.
+ if(control===true)value.task.restriction.blocked=true;
+ value.task.submissions=submission?[...previous.slice(-63),submission]:previous;
  F.write(options.base,value.pointer,value.task);
 }
 function state(value){return read(path.join(value.directory,'diagnostics.json'))||{schemaVersion:1,tasks:{}};}
-function current(value){return value&&state(value).tasks[value.task.taskKey];}
-function blocked(value){return current(value)?.status==='blocked';}
-function message(failure){return `原型 Hook 运行异常${failure.status==='blocked'?'，已达到自动恢复上限':''}：${failure.reason}。请简要报告当前原型及未验收项，由维护入口处理；不要在原型任务中检查日志、修复 Hook 或重复绑定，也不能宣称已验证。`;}
+function message(failure){return `原型 Hook 无法核验当前操作${failure.status==='blocked'?'，已停止重复提示':''}：${failure.reason}。请简要报告未验收项，由维护入口处理；不要在原型任务中修复 Hook 或重复绑定，也不能宣称已验证。`;}
 function failure(value,payload,error){
- if(!value?.task.active)return {continue:true};
+ if(!value)return {continue:true};
  return F.withLock(value.directory,'.diagnostics.lock',()=>{
  const store=state(value),key=value.task.taskKey;
  const phase=/JSON|transcript|source|history|日志/i.test(error.message)?'native-source':'native-request';
@@ -54,26 +60,17 @@ function failure(value,payload,error){
   item.events[eventKey]=true;store.tasks[key]=item;F.write(value.directory,'diagnostics.json',store);
  }
  const result={reason:message(item),failure:item};
- return payload.hook_event_name==='PreToolUse'?{...result,deny:true}:payload.hook_event_name==='Stop'?{...result,feedback:true}:{...result,continue:true,context:result.reason};
+ return payload.hook_event_name==='PreToolUse'?{...result,deny:true}:{continue:true,failure:item,...(item.status!=='blocked'?{context:result.reason}:{})};
  });
 }
-function guard(value,payload){
- if(!value?.task.active||!blocked(value))return null;
- const item=current(value),reason=message(item);
- // Do not trap the whole host. Read tools and explicit state/check commands remain available.
- const command=require('./native-command.cjs').nativeCommand(payload.tool_name,payload.tool_input,value.project);
- const managed=command&&['create','execution-begin','revise','replan','build','record-run','record-devtools-review','finalize'].includes(command.operation)||['Write','Edit','MultiEdit','write_to_file','replace_in_file'].includes(payload.tool_name);
- if(payload.hook_event_name==='PreToolUse'&&managed)return {deny:true,reason,failure:item};
- return null;
-}
 function recover(value){
  if(!value)return;
  return F.withLock(value.directory,'.diagnostics.lock',()=>{const store=state(value),item=store.tasks[value.task.taskKey];
-  if(item&&item.status!=='blocked'){item.status='recovered';item.recoveredAt=new Date().toISOString();F.write(value.directory,'diagnostics.json',store);}
+  if(item&&item.status!=='recovered'){item.status='recovered';item.recoveredAt=new Date().toISOString();F.write(value.directory,'diagnostics.json',store);}
  });
 }
 function observed(value,payload){
- if(!value?.task.active)return;
+ if(!value)return;
  const source=C.source(payload,value.record,value.project),at=new Date().toISOString();
  const entry={schemaVersion:1,sessionId:payload.session_id,taskKey:value.task.taskKey,project:value.project,projectKey:C.projectKey(value.project),host:value.identity.host,product:value.identity.product,
   productVersion:value.identity.productVersion,identitySource:value.identity.identitySource,registrationDigest:value.record.registrationDigest,settingsDigest:value.record.settingsDigest,
@@ -91,4 +88,4 @@ function latest({base,project,host,record}){
  }
  if(!found)return null;const {events,...summary}=found;return summary;
 }
-module.exports={intent,context,remember,current,blocked,failure,guard,recover,observed,latest};
+module.exports={context,remember,failure,recover,observed,latest};

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

@@ -46,7 +46,6 @@ function identity(d) {
  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);
@@ -164,9 +163,9 @@ function browser(d) {
 }
 function automatic(d,stage){
  P.validate(d.policy);
- const prompt=d.source.prompts.at(-1);same(d.binding.entryLine,prompt?.line,'Current prototype task differs');same(d.binding.promptDigest,prompt?.digest,'Current prototype task changed');
+ 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');
- assert.notEqual(d.binding.recovery?.status,'blocked','Skill recovery budget exhausted');
  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']:[]));

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

@@ -1,9 +1,10 @@
 'use strict';
-// Deterministic recovery state; only native source results can resolve a Skill.
+// 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='原型补调已达到自动恢复上限，当前任务仍被阻塞。请如实报告缺项及失败原因；修复依赖、权限或宿主后由用户发起继续。不能取得合格交付回执。';
+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']:[])]:[])];
@@ -17,15 +18,14 @@ function instruction(keys,{directory,automatic=false}={}){
 }
 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]));
+ 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])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(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'])];

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

@@ -26,8 +26,7 @@ function binding(directory) {
  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.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.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};
 }

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

@@ -22,7 +22,7 @@ function beginCommand(directory){
  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;
+ if(!binding||!source.prompts.some(prompt=>prompt.line===binding.entryLine)||(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;