@fitlab-ai/agent-infra 0.11.0 → 0.11.1

package/lib/task/review-finalization.ts

@@ -163,7 +163,6 @@ function preflightReviewSummaryUnlocked(
   let taskContent: string;
   let content: string;
   let recovery: ArtifactRecoveryContext | undefined;
-  let existingIntent;
   try {
     taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
     if (request.recoveryId) {
@@ -179,7 +178,6 @@ function preflightReviewSummaryUnlocked(
       if (!validated.ok) return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
       content = fs.readFileSync(validated.artifact.path, 'utf8');
       const intent = readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, spec.family, request.artifact);
-      existingIntent = intent;
       if (intent?.state === 'preflight-ready') recovery = recoveryContextFromIntent(resolved.repoRoot, resolved.taskDir, intent);
       if (intent?.state === 'consumed') return preflightFailed(request, 'REVIEW_PROVENANCE_INVALID', 'review artifact was already finalized', resolved.taskId);
     }
@@ -224,12 +222,6 @@ function preflightReviewSummaryUnlocked(
       ...(recovery ? { recovery: recoveryInfo(recovery) } : {})
     });
   }
-  if (!recovery && existingIntent?.state === 'passed') {
-    return {
-      ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest }),
-      status: 'passed', changed: false, error: null
-    };
-  }
   if (request.dryRun || recovery && readArtifactRecoveryIntent(resolved.repoRoot, resolved.taskId, spec.family, request.artifact)?.state === 'preflight-ready') {
     return {
       ...preflightFailed(request, 'REVIEW_ARTIFACT_CONFLICT', '', resolved.taskId, { artifactSha256, semanticDigest, ...(recovery ? { recovery: recoveryInfo(recovery) } : {}) }),
@@ -385,7 +377,9 @@ function prepareReviewSummaryCandidate(
       ...(recovery ? { recovery } : {})
     };
   }
-  const transformed = finalizeReviewSummaryContent(artifactContent, stageStatus.unresolvedFindingCounts);
+  const transformed = finalizeReviewSummaryContent(artifactContent, stageStatus.unresolvedFindingCounts, {
+    refreshNumericCounts: Boolean(request.recoveryId && recovery)
+  });
   if (!transformed.ok) return reject(transformed.code, transformed.message);
   const finalDigests = { artifactSha256: sha256Content(transformed.content), semanticDigest: canonicalSemanticDigest(transformed.content) };
   if (!recovery && repairIntent?.state === 'commit-started') {

package/lib/task/verification-engine.ts

@@ -44,6 +44,7 @@ import { validateQualificationAudit } from "./qualification-audit.ts";
 import { getArtifactSchema } from "./artifact-schema.ts";
 import { inspectArtifactContract } from "./artifact-operations.ts";
 import type { VerificationShared } from "./verification-types.ts";
+import { normalizeVerificationRecord } from './gate-policy.ts';
 import { manualValidationFinalSummaryProjectionMatches } from "./manual-validation-receipt.ts";
 import { readManualValidationCompletion } from "./manual-validation-completion.ts";
 import { sha256File } from "./artifact-receipts.ts";
@@ -1392,11 +1393,11 @@ function interpolate(template: any, taskDir: any, artifactFile: any): any {
 }
 
 function summarizeGate(checks: any): any {
-  if (checks.some((check: any) => check.status === "blocked")) {
+  if (checks.some((check: any) => check.effectiveStatus === "blocked")) {
     return "blocked";
   }
 
-  if (checks.some((check: any) => check.status === "fail")) {
+  if (checks.some((check: any) => check.effectiveStatus === "fail")) {
     return "fail";
   }
 
@@ -1405,9 +1406,9 @@ function summarizeGate(checks: any): any {
 
 function summarizeChecks(checks: any): any {
   const counts = {
-    pass: checks.filter((check: any) => check.status === "pass").length,
-    fail: checks.filter((check: any) => check.status === "fail").length,
-    blocked: checks.filter((check: any) => check.status === "blocked").length
+    pass: checks.filter((check: any) => check.effectiveStatus === "pass").length,
+    fail: checks.filter((check: any) => check.effectiveStatus === "fail").length,
+    blocked: checks.filter((check: any) => check.effectiveStatus === "blocked").length
   };
 
   if (counts.blocked > 0) {
@@ -1422,7 +1423,7 @@ function buildAction(gate: any, checks: any): any {
     return "All declared checks passed";
   }
 
-  const firstFailure = checks.find((check: any) => check.status !== "pass");
+  const firstFailure = checks.find((check: any) => check.effectiveStatus !== "pass");
   if (!firstFailure) {
     return "Review validation output";
   }
@@ -1484,16 +1485,16 @@ async function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks:
     const checks = [];
     for (const [type, checkConfig] of Object.entries(verifyConfig.checks || {})) {
       if (checkConfig === null) continue;
-      const result = await runCheck(type, {
+      const result = normalizeVerificationRecord(await runCheck(type, {
         mode,
         skillName,
         taskDir: path.resolve(taskDir),
         artifactFile,
         repositoryRoot: repoRoot,
         config: checkConfig
-      }, shared);
-      checks.push(result);
-      if (result.status === "blocked") break;
+      }, shared));
+      checks.push(...(result.subchecks?.map(normalizeVerificationRecord) ?? [result]));
+      if (checks.at(-1)?.effectiveStatus === "blocked") break;
     }
     const gate = summarizeGate(checks);
     return { gate, skill: skillName, checks, summary: summarizeChecks(checks), action: buildAction(gate, checks) };
@@ -1502,15 +1503,24 @@ async function verifyInProcess({ mode, skillName, taskDir, artifactFile, checks:
   const config = (verifyConfig.checks || {})[type];
   if (config === undefined) return { skill: skillName, ...failResult(type, `Unknown check type '${type}' for skill '${skillName}'.`) };
   if (config === null) return { skill: skillName, ...passResult(type, `Check '${type}' is disabled for skill '${skillName}'.`) };
-  return {
-    skill: skillName,
-    ...await runCheck(type, {
+  const result = normalizeVerificationRecord(await runCheck(type, {
       skillName,
       taskDir: path.resolve(taskDir),
       artifactFile,
       repositoryRoot: repoRoot,
       config
-    }, shared)
+    }, shared));
+  if (!result.subchecks?.length) return { skill: skillName, ...result };
+  const checks = result.subchecks.map(normalizeVerificationRecord);
+  const gate = summarizeGate(checks);
+  return {
+    skill: skillName,
+    ...result,
+    status: gate,
+    effectiveStatus: gate,
+    reason: gate === 'pass' ? 'OK' : checks.find((check: any) => check.effectiveStatus !== 'pass')?.reason ?? 'CHECK_FAILED',
+    action: buildAction(gate, checks),
+    checks
   };
 }
 

package/lib/task/verification-types.ts

@@ -20,6 +20,13 @@ type VerificationCheckResult = {
   message: string;
   fail_type?: string;
   warnings?: string[];
+  checkId?: string;
+  classification?: 'hard' | 'soft' | 'info';
+  effectiveStatus?: VerificationStatus;
+  reason?: string;
+  action?: string;
+  dependsOn?: string;
+  subchecks?: VerificationCheckResult[];
 };
 type VerificationContext = {
   skillName: string;

package/lib/task/verification.ts

@@ -126,7 +126,7 @@ async function verifyTaskEvent(request: { taskRef: string; event: string; artifa
   } else {
     for (const check of spec.checks ?? []) {
       const payload = await engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
-      const status = payload.status as 'pass' | 'fail' | 'blocked';
+      const status = (payload.effectiveStatus ?? payload.status) as 'pass' | 'fail' | 'blocked';
       if (status !== 'pass' && allowsManualOverride(options.manualOverride, 'verification-engine', status === 'blocked' ? 'CHECK_BLOCKED' : 'CHECK_FAILED')) {
         invocations.push({ status: 'pass', exitCode: 0, payload: { ...payload, status: 'pass', humanOverride: 'human-approved', originalStatus: status } });
         break;
@@ -150,18 +150,34 @@ function statusLabel(status: unknown): string {
 function renderPayload(payload: Record<string, unknown>): string {
   const lines: string[] = [];
   if (Array.isArray(payload.checks)) {
-    lines.push(`Verification: ${payload.gate} | Skill: ${payload.skill}`, '');
+    const gateMode = typeof payload.gate === 'string';
+    lines.push(gateMode
+      ? `Verification: ${payload.gate} | Skill: ${payload.skill}`
+      : `Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
     for (const check of payload.checks as Array<Record<string, unknown>>) {
-      lines.push(`  [${statusLabel(check.status)}] ${check.type} - ${check.message}`);
+      const raw = statusLabel(check.status);
+      const effective = statusLabel(check.effectiveStatus ?? check.status);
+      const reason = check.reason ?? 'CHECK_FAILED';
+      const message = check.message ?? reason;
+      lines.push(`  [${effective}] ${check.checkId ?? check.type} (${check.classification ?? 'hard'}; raw ${raw}; reason ${reason}) - ${message}; ${check.action ?? 'Review validation output'}`);
     }
-    lines.push('', `Result: ${payload.summary} - ${payload.action}`);
+    const summary = payload.summary ?? (() => {
+      const checks = payload.checks as Array<Record<string, unknown>>;
+      const statuses = checks.map((check) => check.effectiveStatus ?? check.status);
+      return `${statuses.filter((status) => status === 'pass').length} passed, ${statuses.filter((status) => status === 'fail').length} failed${statuses.includes('blocked') ? `, ${statuses.filter((status) => status === 'blocked').length} blocked` : ''}`;
+    })();
+    lines.push('', `Result: ${summary} - ${payload.action}`);
   } else {
     lines.push(`Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
-    lines.push(`  [${statusLabel(payload.status)}] ${payload.type} - ${payload.message}`);
-    const summary = payload.status === 'pass' ? '1 passed, 0 failed'
-      : payload.status === 'blocked' ? '0 passed, 0 failed, 1 blocked' : '0 passed, 1 failed';
-    const action = payload.status === 'pass' ? 'Requested check passed'
-      : payload.status === 'blocked' ? `Resolve blocked ${payload.type} check and re-run check`
+    const raw = statusLabel(payload.status);
+    const effective = statusLabel(payload.effectiveStatus ?? payload.status);
+    const reason = payload.reason ?? 'CHECK_FAILED';
+    lines.push(`  [${effective}] ${payload.checkId ?? payload.type} (${payload.classification ?? 'hard'}; raw ${raw}; reason ${reason}) - ${payload.message ?? reason}; ${payload.action ?? 'Review validation output'}`);
+    const status = payload.effectiveStatus ?? payload.status;
+    const summary = status === 'pass' ? '1 passed, 0 failed'
+      : status === 'blocked' ? '0 passed, 0 failed, 1 blocked' : '0 passed, 1 failed';
+    const action = status === 'pass' ? 'Requested check passed'
+      : status === 'blocked' ? `Resolve blocked ${payload.type} check and re-run check`
         : `Fix ${payload.type} issues and re-run check`;
     lines.push('', `Result: ${summary} - ${action}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Antigravity CLI, and OpenCode",
   "license": "MIT",
   "type": "module",

package/templates/.agents/rules/issue-sync.en.md

@@ -39,6 +39,8 @@ PR event `in:` synchronization uses `agent-infra-internal platform-pr sync-in-la
 
 `planned|applied|no-op|degraded` exit 0; `failed` exits 1; `blocked` exits 2.
 
+Lifecycle verification treats Issue Type, milestones, labels, requirement anchors, and noncritical comments as platform audits. Each audit retains its check id, raw status, reason, and action; missing structure, unavailable optional capability, or a value mismatch does not block a gate. Identity ambiguity, protocol conflicts, actual write failures, and unknown post-write state remain hard failures.
+
 Map material degraded/failed/blocked results to workflow warnings through the structured intent; callers must not edit warning rows directly:
 
 ```bash

package/templates/.agents/rules/issue-sync.zh-CN.md

@@ -13,9 +13,6 @@
 | `artifactChunk` | `<!-- sync-issue:{task-id}:{artifact-stem}:{part}/{total} -->` |
 | `summary` | `<!-- sync-issue:{task-id}:summary -->` |
 | `cancel` | `<!-- sync-issue:{task-id}:cancel -->` |
-| `recoveryAction` | `<!-- sync-issue:{task-id}:recovery-action:{action-id} -->` |
-| `recoveryPrepare` | `<!-- sync-issue:{task-id}:recovery-prepare:{commit-id} -->` |
-| `recoveryCommit` | `<!-- sync-issue:{task-id}:recovery-commit:{commit-id} -->` |
 
 `prSummary` 属于 `.agents/rules/pr-sync.md`，本规则不实现 PR 聚合。
 
@@ -32,15 +29,15 @@ agent-infra-internal platform-comment recover --issue <issue-token> --task-id <T
   --output <.agents/workspace/.restore-staging-*/task.md> [--cwd <path>]
 agent-infra-internal platform-comment owner <task-ref>
 agent-infra-internal platform-comment sync <task-ref> \
-  --kind task|artifact|summary|cancel|recovery-action|recovery-prepare|recovery-commit --agent {standard-agent-token} \
+  --kind task|artifact|summary|cancel --agent {standard-agent-token} \
   [--artifact <canonical.md>] [--body-file <path|->] [--backfill]
 ```
 
 - `applied|no-op|degraded` → exit 0；`failed` → exit 1；`blocked` → exit 2。
-- task 评论保持 `<details>` frontmatter 可逆格式，只同步确定性的当前任务投影；活动日志、产物生命周期收据、失效记录等过程章节由 recovery 事务保存。artifact 原文内联并在超过 profile 上限时使用 `artifactChunk`。
-- 长度预检与 platform verification 使用同一最终渲染正文的 UTF-8 字节数。正文超限时失败关闭；本地 task 文件不会被截断。
-
-恢复评论使用 `recovery-action`、`recovery-prepare` 和 `recovery-commit` marker，并携带稳定 recovery id 和 body file。task 同步按 prepare、action、task snapshot 写入并复读、commit 的顺序发布。相同内容重放返回 `no-op`；已有恢复 marker 的正文不同返回 `RECOVERY_IMMUTABLE_CONFLICT`。restore 只接受作者一致、分片完整、phase/摘要/marker 匹配且绑定当前 task 评论正文 SHA-256 的完整事务。
+- 生命周期验证把 Issue Type、milestone、labels、需求锚点和非关键评论作为平台审计。每条审计保留 check id、原始状态、reason 和 action；缺失、权限不足或值不一致不会阻塞 gate。身份歧义、协议冲突、实际写入失败和写后状态未知仍为硬失败。
+- task 评论保持 `<details>` frontmatter 可逆格式，只同步确定性的当前任务投影，并折叠保留创建任务、人工决策等关联动作。artifact 评论在正文前折叠显示该产物动作及其提交记录；交付摘要保留创建 PR 与完成任务记录。每条评论的元数据可包含多条日志。恢复核心从这些元数据重建活动日志，绝不把完整 `task.md` 作为评论载荷保存。artifact 原文内联并在超过 profile 上限时使用 `artifactChunk`。
+- 长度预检与 platform verification 使用同一最终渲染正文的 UTF-8 字节数。正文超限时失败关闭；本地 `task.md` 不会被截断。
+- 恢复元数据包含动作关联的日志条目和校验摘要。restore 只接受与 task 评论同作者、任务身份匹配且校验通过的元数据；缺失或损坏的记录不得推测。
 - 相同 intent 重放必须收敛为 `no-op`；重复 marker 返回 `COMMENT_MARKER_CONFLICT` 且不写入。
 - 外部贡献者锁定统一使用 `platform-comment owner`；不同作者且无 triage 时返回 `COMMENT_OWNER_CONFLICT`。
 

package/templates/.agents/rules/local-artifact-repair.en.md

@@ -11,6 +11,14 @@ This rule covers the pre-completion gate for `analyze-task`, `plan-task`, and `c
 - Preflight publishes active `R` through `preflight-ready → preflight-commit-started → preflight-passed`; the business finalizer publishes `F` through `full-finalizer-ready → commit-started → passed` and reuses `R` when `F=R`.
 - Candidate-only is a protocol authorization boundary, not OS isolation: a same-UID process with arbitrary host filesystem write access may tamper with recovery internals. Identity, fingerprint, and state checks detect such anomalies and fail closed, but the protocol does not claim an independent security principal or cross-platform isolation.
 
+## Recovery continuation context
+
+Whenever a preflight or finalizer returns `recovery`, bind the complete continuation context from that response for the current execution: `taskRef`, `stage/family`, `artifact`, `recoveryId`, `candidatePath`, baseline digests, and the original entry point. These fields belong to one controlled transaction; do not regenerate, guess, or mix any of them for a later call.
+
+- For a preflight failure, edit only that `candidatePath`, then rerun the same preflight entry point with the same `--recovery-id`. Only the successful response's recovery context may proceed to ledger writes or summary/finalization.
+- For a finalizer failure, edit only that `candidatePath`, then rerun that same finalizer entry point with the same `--recovery-id`.
+- Stop when the context is lost, the tuple differs, or the formal artifact was edited directly. A fresh invocation without `--recovery-id` cannot replace recovery, and a formal artifact is never a candidate.
+
 ## Authorization boundary
 
 - The finalizer and recovery core validate identity, state, permissions, stable reads, complete artifact semantics, and fingerprints. They do not infer repairability or expose a text-operation allow-list.
@@ -45,9 +53,9 @@ The intent is current-only schema version 4. Legacy schemas fail closed; do not
 ## Dynamic convergence loop
 
 1. Run the finalizer with the fixed invocation.
-2. If it fails and the gates pass, read the structured diagnostic and `candidatePath`, then make one minimal, explainable candidate edit.
-3. Confirm byte-level progress and rerun every finalizer check with the same `--recovery-id`.
-4. Stop on repeated diagnostics or fingerprints, no byte progress, unknown recovery state, or the eight-edit limit for the current invocation. Do not publish a completed event or generate a cross-stage next step.
+2. On every failure that passes the gates, read the structured diagnostic and `candidatePath`, then make only one minimal, explainable candidate edit.
+3. Confirm byte-level progress and rerun every finalizer check with the same `--recovery-id`; if it still fails with a new diagnostic and fingerprint, return to step 2.
+4. Stop on repeated diagnostics or fingerprints, no byte progress, unknown recovery state, an unsafe repair, or the eight-edit limit for the current invocation. Do not publish a completed event or generate a cross-stage next step.
 
 ## Shared entry points
 

package/templates/.agents/rules/local-artifact-repair.zh-CN.md

@@ -12,6 +12,14 @@
 - preflight-ready 后 publish 只读取 active/pending generation，绝不再读取可编辑 candidate。
 - candidate-only 是协议授权边界，不是操作系统隔离：拥有同一 UID 且可任意写入宿主文件系统的进程可能篡改 recovery 内部文件；协议会通过身份、指纹和状态校验发现异常并失败关闭，但不承诺独立权限主体或跨平台隔离。
 
+## 恢复续办上下文
+
+任一 preflight 或 finalizer 返回 `recovery` 时，立即在本次执行中绑定该响应的完整续办上下文：`taskRef`、`stage/family`、`artifact`、`recoveryId`、`candidatePath`、baseline digest 和原入口。它们属于同一受控事务，后续调用不得重新生成、猜测或混用其中任一字段。
+
+- 失败来自 preflight：只编辑该 `candidatePath` 后，以相同入口和同一 `--recovery-id` 重跑 preflight；只有成功响应中的 recovery context 才能进入后续账本写入或 summary/finalizer。
+- 失败来自 finalizer：只编辑该 `candidatePath` 后，以相同入口和同一 `--recovery-id` 重跑该 finalizer。
+- 上下文丢失、tuple 不匹配或正式 artifact 已被直接修改时停止；不得以省略 `--recovery-id` 的新调用替代恢复，也不得把正式 artifact 当作 candidate。
+
 ## 授权边界
 
 - finalizer 和 recovery core 只校验身份、状态、权限、稳定读取、完整 artifact 语义和指纹；不根据错误码猜测“可修复”，也不提供文本操作白名单。
@@ -46,9 +54,9 @@ intent 使用 current-only schema version 4。旧 schema 直接失败关闭；
 ## 动态收敛循环
 
 1. 用固定 invocation 运行 finalizer。
-2. 失败且安全门通过时，读取结构化诊断和 `candidatePath`，只作一次最小、可解释的候选编辑。
-3. 确认字节变化后，使用同一 `--recovery-id` 完整重跑全部 finalizer 校验。
-4. 诊断或指纹重复、无字节进展、恢复状态未知或达到当前 invocation 的 8 次编辑上限时停止；不发布 completed，不生成跨阶段 next-step。
+2. 每次失败且安全门通过时，读取结构化诊断和 `candidatePath`，仅作一次最小、可解释的候选编辑。
+3. 确认字节变化后，使用同一 `--recovery-id` 完整重跑全部 finalizer 校验；仍失败但诊断和指纹均未重复时，回到第 2 步。
+4. 诊断或指纹重复、无字节进展、恢复状态未知、无法安全修复或达到当前 invocation 的 8 次编辑上限时停止；不发布 completed，不生成跨阶段 next-step。
 
 ## 共享入口
 

package/templates/.agents/skills/analyze-task/SKILL.en.md

@@ -223,8 +223,8 @@ agent-infra-internal task-artifact {task-id} finalize-local --family analysis --
 ```
 
 - On `status=passed`, save that result's `artifactSha256` and `semanticDigest`; the finalizer has recorded the matching one-shot local provenance intent.
-- On `status=failed` with recovery context, edit only the returned `candidatePath` once after the completion gates pass, then rerun the finalizer completely with the same `recoveryId`; the formal artifact must remain unchanged until commit.
-- The recovery candidate must match the recorded task, round, artifact, baseline, and request identity. On baseline conflict, unknown state, no progress, or repeated failure, stop without publishing a completed event.
+- On `status=failed` with recovery context, after the completion gates pass, edit the returned `candidatePath` only once for this attempt, then rerun the finalizer completely with the same `recoveryId`; if it still fails with a new diagnostic and fingerprint while the gates continue to pass, continue to the next attempt; the formal artifact must remain unchanged until commit.
+- The recovery candidate must match the recorded task, round, artifact, baseline, and request identity. On baseline conflict, unknown state, an unsafe repair, repeated diagnostics or fingerprints, no progress, or the shared edit limit, stop without publishing a completed event.
 
 Use the digests from that same `status=passed` result in `agent-infra-internal task-event {task-id} analyze.completed --agent {standard-agent-token} --initiator {trigger-initiator} --request-id {request-id} --reason-code {reason-code} --artifact {analysis-artifact} --artifact-sha256 {artifact-sha256} --semantic-digest {semantic-digest} {execution-flag}` so the core records the link, stage, agent, metadata, and Activity Log atomically.
   - {YYYY-MM-DD HH:mm:ss±HH:MM} — **Analyze Task (Round {N})** by {agent} — Analysis completed → {analysis-artifact}

package/templates/.agents/skills/analyze-task/SKILL.zh-CN.md

@@ -226,8 +226,8 @@ agent-infra-internal task-artifact {task-id} init --family analysis --artifact {
   agent-infra-internal task-artifact {task-id} finalize-local --family analysis --artifact {analysis-artifact}
   ```
   - `status=passed`：保存本次返回的 `artifactSha256` 和 `semanticDigest`；finalizer 已记录对应的一次性本地 provenance intent。
-  - `status=failed` 且返回 recovery context：完成门禁通过后，只编辑返回的 `candidatePath` 一次，然后使用同一个 `recoveryId` 完整重跑 finalizer；formal artifact 在 commit 前必须保持不变。
-  - recovery candidate 必须与记录的任务、轮次、产物、baseline 和 request identity 匹配；基线冲突、未知状态、无进展或重复失败：停止，不发布 completed 事件。
+  - `status=failed` 且返回 recovery context：完成门禁通过后，本次只编辑返回的 `candidatePath` 一次，然后使用同一个 `recoveryId` 完整重跑 finalizer；若仍失败但诊断和指纹均未重复且安全门继续通过，继续下一轮；formal artifact 在 commit 前必须保持不变。
+  - recovery candidate 必须与记录的任务、轮次、产物、baseline 和 request identity 匹配；基线冲突、未知状态、无法安全修复、诊断或指纹重复、无进展，或达到共享规则的编辑上限时停止，不发布 completed 事件。
 - 使用同一次 `status=passed` 返回的摘要执行 `agent-infra-internal task-event {task-id} analyze.completed --agent {standard-agent-token} --initiator {trigger-initiator} --request-id {request-id} --reason-code {reason-code} --artifact {analysis-artifact} --artifact-sha256 {artifact-sha256} --semantic-digest {semantic-digest} {execution-flag}`，由核心登记链接、阶段、代理、时间、版本和 Activity Log。
 
 如果 task.md 中存在有效的 `platform_issue_identity`，执行以下同步操作（任一失败则跳过并继续）：

package/templates/.agents/skills/analyze-task/config/verify.en.json

@@ -24,16 +24,7 @@
       "expected_action_pattern": "(Analyze Task|Requirement Analysis) \\(Round \\d+\\)"
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_status_label": "status: pending-design-work",
-      "expected_comment_marker": "<!-- sync-issue:{task-id}:{artifact-stem} -->",
-      "verify_comment_content": true,
-      "verify_task_comment_content": true,
-      "verify_issue_type": true,
-      "verify_issue_fields": false,
-      "verify_milestone": true,
-      "expected_status_label_key": "pendingDesignWork",
-      "expected_comment_marker_key": "artifact"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/analyze-task/config/verify.zh-CN.json

@@ -24,16 +24,7 @@
       "expected_action_pattern": "(Analyze Task|Requirement Analysis) \\(Round \\d+\\)"
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_status_label": "status: pending-design-work",
-      "expected_comment_marker": "<!-- sync-issue:{task-id}:{artifact-stem} -->",
-      "verify_comment_content": true,
-      "verify_task_comment_content": true,
-      "verify_issue_type": true,
-      "verify_issue_fields": false,
-      "verify_milestone": true,
-      "expected_status_label_key": "pendingDesignWork",
-      "expected_comment_marker_key": "artifact"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/block-task/config/verify.json

@@ -21,9 +21,7 @@
       "expected_action_pattern": "(Block Task|Blocked)"
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_status_label": "status: blocked",
-      "expected_status_label_key": "blocked"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/cancel-task/config/verify.json

@@ -22,10 +22,7 @@
       "expected_action_pattern": "(Cancel Task|Cancelled)"
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_comment_marker": "<!-- sync-issue:{task-id}:cancel -->",
-      "verify_task_comment_content": true,
-      "expected_comment_marker_key": "cancel"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/code-task/SKILL.en.md

@@ -122,7 +122,7 @@ Before writing this round's `{code-artifact}`, create the controlled report skel
 agent-infra-internal task-artifact {task-id} init --family code --artifact {code-artifact} --locale en
 ```
 
-The skeleton contains identity metadata, stable section markers, and required headings only; real implementation and verification content is required before the completion gate can pass. If the finalizer returns one provably safe structural error, it returns a controlled recovery candidate; edit only its `candidatePath`, then rerun `task-artifact {task-id} finalize-local --family code --artifact {code-artifact} --recovery-id {recovery-id}` with the same `recoveryId`. Candidate-only is a protocol authorization boundary, not OS isolation; arbitrary same-UID host writers are outside the protocol's protection claim, and fingerprint/state checks fail closed on anomalies.
+The skeleton contains identity metadata, stable section markers, and required headings only; real implementation and verification content is required before the completion gate can pass. When preflight or finalization returns one provably safe structural error, it returns a controlled recovery candidate; edit only its `candidatePath`, then retain the same recovery context and rerun the entry point that returned it, as specified by `.agents/rules/local-artifact-repair.md`. Candidate-only is a protocol authorization boundary, not OS isolation; arbitrary same-UID host writers are outside the protocol's protection claim, and fingerprint/state checks fail closed on anomalies.
 
 Create `.agents/workspace/active/{task-id}/{code-artifact}`.
 
@@ -139,8 +139,8 @@ echo "$finalizer"
 ```
 
 - `status=0` with `finalizer.status="passed"`: bind `{artifact-sha256}` and `{semantic-digest}` from this result.
-- `status=1` with recovery context: confirm task, round, artifact, baseline, and request identity are unchanged; edit only the returned `candidatePath` once, confirm the bytes changed, then rerun the same finalizer completely with the same `recoveryId`; `baseline`, `final`, `publish`, and `intent` remain framework-internal state and must not be edited.
-- For any other failure, external formal-artifact change, lack of progress, or recovery identity mismatch, stop without publishing `code.completed`.
+- `status=1` with recovery context: confirm task, round, artifact, baseline, and request identity are unchanged; edit the returned `candidatePath` only once for this attempt, confirm the bytes changed, then rerun the entry point that returned the context completely with the same `recoveryId`; a failed preflight reruns preflight and a failed finalizer reruns that finalizer. If it still fails with a new diagnostic and fingerprint while the gates continue to pass, continue to the next attempt; `baseline`, `final`, `publish`, and `intent` remain framework-internal state and must not be edited.
+- For any other failure, external formal-artifact change, an unsafe repair, repeated diagnostics or fingerprints, lack of progress, the shared edit limit, or recovery identity mismatch, stop without publishing `code.completed`.
 
 Do not rescan or manually write digest data; the completion event must include `--artifact-sha256 {artifact-sha256} --semantic-digest {semantic-digest}` from the successful finalizer result.
 

package/templates/.agents/skills/code-task/SKILL.zh-CN.md

@@ -162,7 +162,7 @@ checkpoint 成功后，若任务存在 `platform_issue_identity`，调用 `agent
 agent-infra-internal task-artifact {task-id} init --family code --artifact {code-artifact}
 ```
 
-骨架只包含身份元数据、稳定 section marker 和必需标题；必须填入真实实现与验证内容后才能通过完成门禁。finalizer 返回可证明的单个结构错误时，会返回受控 recovery candidate；只能编辑返回的 `candidatePath`，然后使用同一个 `recoveryId` 重跑 `task-artifact {task-id} finalize-local --family code --artifact {code-artifact} --recovery-id {recovery-id}`。candidate-only 是协议授权边界，不是操作系统隔离；同 UID 的任意宿主写入者不在本协议的防护承诺内，异常由指纹/状态校验失败关闭。
+骨架只包含身份元数据、稳定 section marker 和必需标题；必须填入真实实现与验证内容后才能通过完成门禁。preflight 或 finalizer 返回可证明的单个结构错误时，会返回受控 recovery candidate；只能编辑返回的 `candidatePath`，并按 `.agents/rules/local-artifact-repair.md` 保持同一 recovery context 后重跑返回该 context 的原入口。candidate-only 是协议授权边界，不是操作系统隔离；同 UID 的任意宿主写入者不在本协议的防护承诺内，异常由指纹/状态校验失败关闭。
 
 创建 `.agents/workspace/active/{task-id}/{code-artifact}`。
 
@@ -179,8 +179,8 @@ echo "$finalizer"
 ```
 
 - `status=0` 且 `finalizer.status="passed"`：绑定这一次返回的 `{artifact-sha256}` 和 `{semantic-digest}`。
-- `status=1` 且返回 recovery context：确认任务、轮次、产物、baseline 和 request identity 未变化后，只编辑返回的 `candidatePath` 一次，确认字节确实变化，再使用同一个 `recoveryId` 完整重跑同一 finalizer；baseline、final、publish 和 intent 均属于框架内部状态，不得编辑。
-- 其他失败、formal artifact 外部变化、无进展或 recovery identity 不匹配：停止，不发布 `code.completed`。
+- `status=1` 且返回 recovery context：确认任务、轮次、产物、baseline 和 request identity 未变化后，本次只编辑返回的 `candidatePath` 一次，确认字节确实变化，再使用同一个 `recoveryId` 完整重跑返回该 context 的同一入口；preflight 失败必须重跑 preflight，finalizer 失败必须重跑 finalizer。若仍失败但诊断和指纹均未重复且安全门继续通过，继续下一轮；baseline、final、publish 和 intent 均属于框架内部状态，不得编辑。
+- 其他失败、formal artifact 外部变化、无法安全修复、诊断或指纹重复、无进展、达到共享规则的编辑上限或 recovery identity 不匹配：停止，不发布 `code.completed`。
 
 不得重新扫描或手工补写摘要；完成事件必须携带本次 `passed` 结果的 `--artifact-sha256 {artifact-sha256} --semantic-digest {semantic-digest}`。
 

package/templates/.agents/skills/code-task/config/verify.en.json

@@ -30,18 +30,7 @@
       ]
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_status_label": "status: in-progress",
-      "expected_comment_marker": "<!-- sync-issue:{task-id}:{artifact-stem} -->",
-      "verify_comment_content": true,
-      "verify_task_comment_content": true,
-      "verify_issue_type": true,
-      "verify_issue_fields": false,
-      "verify_in_labels_computed": true,
-      "verify_milestone": true,
-      "verify_milestone_specific": true,
-      "expected_status_label_key": "inProgress",
-      "expected_comment_marker_key": "artifact"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/code-task/config/verify.zh-CN.json

@@ -30,18 +30,7 @@
       ]
     },
     "platform-sync": {
-      "when": "platform_issue_identity_exists",
-      "expected_status_label": "status: in-progress",
-      "expected_comment_marker": "<!-- sync-issue:{task-id}:{artifact-stem} -->",
-      "verify_comment_content": true,
-      "verify_task_comment_content": true,
-      "verify_issue_type": true,
-      "verify_issue_fields": false,
-      "verify_in_labels_computed": true,
-      "verify_milestone": true,
-      "verify_milestone_specific": true,
-      "expected_status_label_key": "inProgress",
-      "expected_comment_marker_key": "artifact"
+      "when": "platform_issue_identity_exists"
     }
   }
 }

package/templates/.agents/skills/code-task/reference/dual-mode.en.md

@@ -10,7 +10,7 @@ agent-infra-internal task-artifact {task-id} inspect --family code
 
 The core scans `plan.md` / `plan-r{N}.md`, `review-plan.md` / `review-plan-r{N}.md`, `code.md` / `code-r{N}.md`, and `review-code.md` / `review-code-r{N}.md` in the task directory.
 
-`code.started` persists the plan identity and SHA-256 for the round in task.md frontmatter. `code.completed` must read the canonical plan from the implementation report's `Plan Input` field and match both that start context and the current latest plan; missing, mismatched, or changed input fails closed.
+`code.started` persists the plan identity and SHA-256 for the round in task.md frontmatter. `code.completed` uses that start context and verifies the current latest plan; changed input fails closed. The implementation report's `Plan Input` field is reader-facing traceability, not lifecycle identity validation.
 
 ## Eight Branches
 

package/templates/.agents/skills/code-task/reference/dual-mode.zh-CN.md

@@ -10,7 +10,7 @@ agent-infra-internal task-artifact {task-id} inspect --family code
 
 核心扫描任务目录中的 `plan.md` / `plan-r{N}.md`、`review-plan.md` / `review-plan-r{N}.md`、`code.md` / `code-r{N}.md` 和 `review-code.md` / `review-code-r{N}.md`。
 
-`code.started` 会在 task.md frontmatter 中绑定本轮方案文件及其 SHA-256。`code.completed` 必须从实现报告的“方案输入”/“Plan Input”字段读取 canonical plan，并同时匹配该开始上下文和当前最新 plan；缺失、身份不一致或内容变化均失败关闭。
+`code.started` 会在 task.md frontmatter 中绑定本轮方案文件及其 SHA-256。`code.completed` 使用该开始上下文并校验当前最新 plan；内容变化失败关闭。实现报告的“方案输入”/“Plan Input”仅供读者追溯，不参与生命周期身份校验。
 
 ## 8 个分支
 

package/templates/.agents/skills/code-task/reference/report-template.en.md

@@ -4,6 +4,8 @@
 
 Use this structure when creating `code.md` or `code-r{N}.md`.
 
+> Implementation-input fields provide reader-facing traceability. Lifecycle identity uses the input frozen by `code.started` and the completion receipt; it is not parsed from this report body.
+
 ## Output Template
 
 ```markdown
@@ -103,6 +105,15 @@ Use this structure when creating `code.md` or `code-r{N}.md`.
 > Record the state-check command, task/artifact scope, key result, and uncovered parts; each command starts with `$ `.
 > Follow `.agents/rules/evidence-reporting.md`: record task/artifact scope, key result, and uncovered parts; do not paste complete successful stdout.
 
+Record at least one actually executed `$ ` command and its result summary; prose-only status is insufficient. An implementation-stage report normally includes:
+
+```text
+$ agent-infra-internal task-snapshot {task-id} --format text
+{task state, implementation-artifact scope, and uncovered-area summary}
+$ agent-infra-internal task-artifact {task-id} inspect --family code
+{code artifact, upstream input, and next-step summary}
+```
+
 ## Raw Evidence
 
 > Follow `.agents/rules/evidence-reporting.md`: pair each claim with a `$ ` command and proportionate result summary; include a decisive raw excerpt only for failures, blocking conditions, or disputes.

package/templates/.agents/skills/code-task/reference/report-template.zh-CN.md

@@ -4,6 +4,8 @@
 
 创建 `code.md` 或 `code-r{N}.md` 时，使用以下结构。
 
+> “实现输入”字段用于读者追溯。生命周期身份以 `code.started` 冻结的输入和完成 receipt 为准，不从本报告正文解析。
+
 ## 输出模板
 
 ```markdown
@@ -103,6 +105,15 @@
 > 记录状态核对命令、任务/产物范围、关键结果和未覆盖部分；每条命令以 `$ ` 开头。
 > 按 `.agents/rules/evidence-reporting.md` 同时记录任务/产物范围、关键结果和未覆盖部分；正常成功不粘贴完整 stdout。
 
+必须记录至少一条实际执行的 `$ ` 命令及其结果摘要，不能只写自然语言状态。实现阶段通常包括：
+
+```text
+$ agent-infra-internal task-snapshot {task-id} --format text
+{任务状态、实现产物范围和未覆盖项摘要}
+$ agent-infra-internal task-artifact {task-id} inspect --family code
+{code artifact、上游输入和下一步摘要}
+```
+
 ## 证据原文
 
 > 遵循 `.agents/rules/evidence-reporting.md`：每条断言配对 `$ ` 命令和相称结果摘要；仅为失败、阻塞或争议附决定性原文摘录。

package/templates/.agents/skills/commit/config/verify.json

@@ -18,11 +18,7 @@
       "expected_action_pattern": "Commit"
     },
     "platform-sync": {
-      "when": "pr_fact_bound",
-      "expected_pr_comment_marker": "<!-- sync-pr:{task-id}:summary -->",
-      "verify_in_labels_computed": true,
-      "verify_pr_comment_last_commit_matches_head": true,
-      "expected_pr_comment_marker_key": "prSummary"
+      "when": "pr_fact_bound"
     }
   }
 }

package/templates/.agents/skills/complete-manual-validation/config/verify.en.json

@@ -31,17 +31,17 @@
       "expected_action_pattern": "Complete Manual Validation"
     },
     "review-ledger": {
-      "stage_scope": ["analysis", "plan", "code"]
+      "stage_scope": [
+        "analysis",
+        "plan",
+        "code"
+      ]
     },
     "platform-sync": {
       "when": "pr_fact_bound",
-      "expected_pr_comment_marker_key": "prSummary",
       "expected_pr_comment_required_patterns": [
         "^### ✅ (?:人工验证已通过|Manual Validation Passed)$"
-      ],
-      "verify_task_comment_content": true,
-      "verify_issue_type": true,
-      "verify_issue_fields": false
+      ]
     }
   }
 }