@fitlab-ai/agent-infra 0.9.7 → 0.9.9

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

@@ -10,12 +10,12 @@ description: >
 The orchestrator delegates only and never executes a stage skill itself. First read `.agents/rules/no-mid-flow-questions.md`, `.agents/rules/lifecycle-orchestration.md`, and `reference/host-validation.md`.
 
 1. Resolve the canonical task ID, current Agent Client, and optional atomic policy flags, then run `task-snapshot`. If one explicit role field is present, all four are required.
-2. Before `begin-or-resume`, Codex selects a host. Without `AGENT_INFRA_CONTROL_TOKEN`, use direct-host. With task-bound control authority but no `AGENT_INFRA_CODEX_CONTROLLER_CONTEXT`, only run `codex-sandbox-controller run --task-id {task-id} --task-ref {task-ref}` with the complete policy and wait; the outer loop must not create a run, baseline, or receipt. With a context, run `verify-context --task-id {task-id}` first. Stop on any bootstrap, bundle, source/profile discovery, or context failure.
-3. Run `task-orchestration {task-id} begin-or-resume --client {client}` with the complete explicit policy. With no explicit policy, core reads that client's configured policy; existing v2/v3 runs use persisted policy. Stop on paused/completed results.
+2. Before `begin-or-resume`, Codex selects a host. Without `AGENT_INFRA_CONTROL_TOKEN`, use direct-host. With task-bound control authority but no `AGENT_INFRA_CODEX_CONTROLLER_CONTEXT`, only run `codex-sandbox-controller run` with the complete policy and wait; the outer loop must not create a run, baseline, or receipt. With a context, run `verify-context` first. Stop on any bootstrap, bundle, source/profile discovery, or context failure.
+3. Run `task-orchestration {task-id} begin-or-resume --client {client}` with the complete explicit policy. With no explicit policy, core reads that client's configured policy; existing runs use persisted policy. Disk state outside the complete current structure fails closed without rewriting; finish or clear active runs before upgrading. Stop on paused/completed results.
 4. Run `route`. On `completed`, run `agent-infra-internal task-verify {task-id} run-task.completed --format text` and stop. Only a `running` result with non-null `next` supplies action, role, round, artifact, requested model, and requested effort.
-5. Codex runs `codex-lifecycle capability-arm --task-id {task-id}` once. The current loop's real PostToolUse must attest that ordinary tool response. Pass only its marker token to `prepare --client {client} --capability-token {token}`. Before snapshotting, core atomically consumes it, verifies task, hook source, build, contract, and controller binding, and persists the capability session, turn, and tool-use origin. Activation then verifies that spawn belongs to the same session and turn and uses a distinct tool-use. Other clients use the same prepare without a token. Failure creates no baseline, receipt, or child.
-6. After prepare, run `task-orchestration <task-ref> dispatch` immediately before calling the fresh native child, then use route's exact model/effort and only the short task ref, skill, `--orchestrated`, and stage identity. The trusted hook-spawn first-observation time must fall between dispatch and the deadline. Its first provenance-sensitive command must be `await-activation --stage ... --round ... --artifact ... --role ...`; before `running`, it must not snapshot, emit stage-started, write business files, or start commit. Only explicit `recover-prepared` may clear an expired orphan when the task fingerprint is exact, no commit intent exists, and no matching unconsumed active lifecycle evidence remains.
-7. Codex uses SubagentStart/Stop and App Server actual evidence to activate, consume, and seal one v3 receipt; trusted parent fallback must produce the same provenance. Timed-out waits do nothing. Advance only a sealed receipt and repeat step 4 only while running.
+5. Codex runs `codex-lifecycle capability-arm --task-id {task-id}` once. The current loop's real PostToolUse must attest that ordinary tool response. Pass its marker token, the exact routed model, and the exact routed reasoning effort to `prepare --client {client} --requested-model {requestedModel} --requested-reasoning-effort {requestedReasoningEffort} --capability-token {token}`. Core first validates the exact routed model/effort, capability provenance, and controller binding, then captures a read-only snapshot, builds an in-memory prepared receipt, atomically consumes the token, and saves the prepared state with the capability session, turn, and tool-use origin. Activation then verifies that spawn belongs to the same session and turn and uses a distinct tool-use. Other clients use the same prepare without a token. Failure creates no baseline, receipt, or child.
+6. After prepare, run `task-orchestration <task-ref> dispatch` immediately before calling the fresh native child, then use route's exact model/effort and only the short task ref, skill, `--orchestrated`, and stage identity. The trusted hook-spawn first-observation time must fall between dispatch and the deadline. Its first provenance-sensitive command must be `await-activation --stage ... --round ... --artifact ... --role ...`; before `running`, it must not snapshot, emit stage-started, write business files, or start commit. Only explicit `recover-prepared` may clear an expired orphan when the task fingerprint is exact and no matching unconsumed active lifecycle evidence remains.
+7. Codex uses SubagentStart/Stop and App Server actual evidence to activate, consume, and seal one receipt; trusted parent fallback must produce the same complete provenance. Timed-out waits do nothing. Advance only a sealed receipt and repeat step 4 only while running.
 8. Create a fresh child each round and never follow up with an old reviewer. Each requested/actual mismatch needs its own host fallback reason. Capability, hook, source, controller, build, identity, ledger, or fingerprint failure pauses and fails closed.
 9. On pause or completion, run the matching typed verification and report the structured endpoint.
 

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

@@ -10,12 +10,12 @@ description: >
 总控只编排，不直接执行任何阶段技能。执行前先读取 `.agents/rules/no-mid-flow-questions.md`、`.agents/rules/lifecycle-orchestration.md` 与 `reference/host-validation.md`。
 
 1. 解析规范任务 ID、当前 Agent Client，以及可选的原子策略 `--executor-model`、`--executor-reasoning-effort`、`--reviewer-model`、`--reviewer-reasoning-effort`，并执行 `agent-infra-internal task-snapshot {task-id} --format text`。任一显式策略字段出现时四个 role 字段必须完整，不得与配置拼接；两个角色可以使用同一模型。
-2. Codex 在 `begin-or-resume` 前选择宿主：没有 `AGENT_INFRA_CONTROL_TOKEN` 时使用 direct-host；有 task-bound control authority 但没有 `AGENT_INFRA_CODEX_CONTROLLER_CONTEXT` 时，只调用 `agent-infra-internal codex-sandbox-controller run --task-id {task-id} --task-ref {task-ref}`（转发完整显式策略）并等待其终态，外层不得创建 run、baseline 或 receipt；已有 context 时先调用 `verify-context --task-id {task-id}`。controller 的 bootstrap、bundle、source/profile discovery 或 context 任一校验失败即停止。
-3. 调用 `agent-infra-internal task-orchestration {task-id} begin-or-resume --client {client}` 并转发完整显式策略。完全没有显式策略时由核心读取当前 client 的 `agentClients[].orchestration`；已有 v2/v3 run 使用持久化策略。仅当核心返回 `ORCHESTRATION_MODEL_POLICY_REQUIRED` 时，先用 `agent-client model-selection` 展示 complete/partial/interactive-only 来源，再一次收集完整策略；未回答则不创建 run。若为 paused/completed，按结构化结果停止。
+2. Codex 在 `begin-or-resume` 前选择宿主：没有 `AGENT_INFRA_CONTROL_TOKEN` 时使用 direct-host；有 task-bound control authority 但没有 `AGENT_INFRA_CODEX_CONTROLLER_CONTEXT` 时，只调用 `agent-infra-internal codex-sandbox-controller run`（转发完整显式策略）并等待其终态，外层不得创建 run、baseline 或 receipt；已有 context 时先调用 `verify-context`。controller 的 bootstrap、bundle、source/profile discovery 或 context 任一校验失败即停止。
+3. 调用 `agent-infra-internal task-orchestration {task-id} begin-or-resume --client {client}` 并转发完整显式策略。完全没有显式策略时由核心读取当前 client 的 `agentClients[].orchestration`；existing run 使用持久化策略。磁盘状态不符合当前完整结构时核心失败关闭且不改写；升级前必须完成或清空 active run。仅当核心返回 `ORCHESTRATION_MODEL_POLICY_REQUIRED` 时，先用 `agent-client model-selection` 展示 complete/partial/interactive-only 来源，再一次收集完整策略；未回答则不创建 run。若为 paused/completed，按结构化结果停止。
 4. 调用 `route` 并读取结构化结果。若返回 `completed`，立即运行 `agent-infra-internal task-verify {task-id} run-task.completed --format text` 并停止；仅当返回 `running` 且 `next` 非空时读取唯一 action、role、round、artifact、`requestedModel` 和 `requestedReasoningEffort`，不得自行推断。
-5. Codex 先调用一次 `agent-infra-internal codex-lifecycle capability-arm --task-id {task-id}`。该普通工具调用必须由当前 loop 的真实 PostToolUse 回写 attestation；仅把返回的 marker 中 token 传给 `prepare --client {client} --capability-token {token}`。核心在快照前原子消费 token，校验 task、hook source、build、contract 与 controller binding，并持久化 capability 的 session、turn、tool-use 来源。activation 再校验 spawn 与该来源属于同一 session/turn，且 spawn 使用独立的 tool-use。其他客户端直接调用同一 prepare（无 token）。任一失败不得创建 baseline、receipt 或 child。
-6. prepare 成功后，在调用 fresh 原生子 Agent 的紧邻前一步执行 `task-orchestration <task-ref> dispatch`，再显式覆盖 route 返回的 model/effort；只传短任务引用、skill 名、`--orchestrated` 与 stage/round/artifact/role。可信 hook-spawn 首次观察时间必须位于 dispatch 与 deadline 之间。child 的第一条 provenance-sensitive 命令必须是 `await-activation --stage ... --round ... --artifact ... --role ...`；返回 running 前禁止 snapshot、阶段 started、业务写入或 commit-start。超时由核心暂停；崩溃遗留 prepared receipt 只能在 exact workspace fingerprint、无 commit intent、无匹配的未消费 active lifecycle evidence 且 deadline 已过时显式 `recover-prepared`。
-7. Codex 用 SubagentStart/Stop 与 App Server actual evidence 激活、消费并封存唯一 receipt；受信 parent fallback 仍必须形成相同 v3 provenance。timed-out wait 无动作；只有 empty turns 或协议 `inProgress` 可等待，malformed、身份/传输错误或异常 terminal 均暂停。子 Agent 返回后只对 sealed receipt 调用 `advance`；只有 `running` 才重复步骤 4。
+5. Codex 先调用一次 `agent-infra-internal codex-lifecycle capability-arm --task-id {task-id}`。该普通工具调用必须由当前 loop 的真实 PostToolUse 回写 attestation；把 route 返回的精确 model、effort 和 marker 中 token 一并传给 `prepare --client {client} --requested-model {requestedModel} --requested-reasoning-effort {requestedReasoningEffort} --capability-token {token}`。核心先校验精确的 model/effort、capability provenance 与 controller binding，再只读捕获快照、构造内存中的 prepared receipt，最后原子消费 token 并保存 prepared 状态，同时持久化 capability 的 session、turn、tool-use 来源。activation 再校验 spawn 与该来源属于同一 session/turn，且 spawn 使用独立的 tool-use。其他客户端直接调用同一 prepare（无 token）。任一失败不得创建 baseline、receipt 或 child。
+6. prepare 成功后，在调用 fresh 原生子 Agent 的紧邻前一步执行 `task-orchestration <task-ref> dispatch`，再显式覆盖 route 返回的 model/effort；只传短任务引用、skill 名、`--orchestrated` 与 stage/round/artifact/role。可信 hook-spawn 首次观察时间必须位于 dispatch 与 deadline 之间。child 的第一条 provenance-sensitive 命令必须是 `await-activation --stage ... --round ... --artifact ... --role ...`；返回 running 前禁止 snapshot、阶段 started、业务写入或 commit。超时由核心暂停；崩溃遗留 prepared receipt 只能在 exact workspace fingerprint、无匹配的未消费 active lifecycle evidence 且 deadline 已过时显式 `recover-prepared`。
+7. Codex 用 SubagentStart/Stop 与 App Server actual evidence 激活、消费并封存唯一 receipt；受信 parent fallback 仍必须形成相同的完整 provenance。timed-out wait 无动作；只有 empty turns 或协议 `inProgress` 可等待，malformed、身份/传输错误或异常 terminal 均暂停。子 Agent 返回后只对 sealed receipt 调用 `advance`；只有 `running` 才重复步骤 4。
 8. 每轮创建新 child；禁止 follow-up 复用 reviewer。actual model/effort 与 requested 不同时必须有各自的宿主降级理由。任何 capability、hook、source、controller、build、身份、账本或 fingerprint 异常都调用 `pause` 并失败关闭。
 9. 完成或暂停后运行对应 typed verification，并把结构化 run 摘要、暂停原因、commit 终点或 clean completion evidence 告知用户。
 

package/templates/.agents/skills/run-task/reference/host-validation.en.md

@@ -6,7 +6,9 @@ Before publishing support for a client, prove the lifecycle evidence chain with
 
 - Client version, enabled multi-agent capability, launch surface, and trust boundary.
 - Raw start/stop events, or the parent PostTool spawn/completed-wait fallback when custom roles omit them, stably correlate the managed agent, parent/child identity, fresh spawn mode, actual model, and actual reasoning effort.
+  > Direct-host clients that structurally do not emit fork/spawn-mode event fields (currently claude-code) may derive identity correlation solely from parent/child identity uniqueness plus the receipt's one-shot state machine, without an additional fresh-spawn-mode proof; the client must still honestly record this gap and how the substitute guarantee is composed, and must never fabricate spawn-mode evidence. This exception does not apply to any other client. Concretely, claude-code's identity guarantee is provided only by non-empty and mutually distinct `parentId`/`childId`, a unique `childId` within the same run, and the receipt's one-shot state machine — it carries none of Codex's `spawn_mode` fork proof and is weaker than Codex's.
 - Explicit requested model/effort reaches each executor/reviewer. A fallback of either field reports the corresponding actual value and its own non-empty reason.
+  > claude-code exception: requested reasoning effort does not yet support per-role dispatch to executor/reviewer — `.claude/agents/{executor,reviewer}.md` is a repository-level shared singleton, and writing it per role would race across concurrent tasks. This client only needs to honestly record the actual model/actual reasoning effort observed in native Start/Stop host events (`delegationEvidence.actualReasoningEffort` is declared `spawn-ack`); when not observed it is recorded as missing, which is not treated as a fallback requiring its own reason and does not fail closed. This exception does not apply to any other client.
 - Candidate-checkout and packed-install behavior match, with model policy, receipts, and verification results auditable in `orchestration.json`.
 - Direct-host project/managed source and sandbox isolated-user source preserve the same build, contract, profile, and controller provenance through prepare/start/stop/consume.
 
@@ -19,4 +21,4 @@ Before publishing support for a client, prove the lifecycle evidence chain with
 5. Commit only redacted summaries and non-sensitive fixtures. Remove or replace tokens, user-specific absolute paths, transcript content, and credentials.
 6. For sandbox, run at least ten cold executor starts and ten cold reviewer starts. Record monotonic prepared, spawn-dispatch, SubagentStart, and activation-completed timestamps plus p50/p95/max. Enable only when max plus 20% fits the deadline and symlink/config/plugin/lease/context/build failure injection and terminal cleanup audits pass.
 
-If any required field cannot be observed reliably from the real host, keep that client's orchestration capability `unsupported` and record the gap as manual validation. Codex may advertise `experimental`, but every `prepare` must still pass static preflight and either native start/stop or the parent spawn/completed-wait fallback must produce verifiable consumed host evidence. The fallback may wait only for empty turns or protocol `inProgress`; malformed, identity/transport errors, or abnormal terminals pause deterministically.
+If any required field cannot be observed reliably from the real host, keep that client's orchestration capability `unsupported` and record the gap as manual validation. Codex may advertise `experimental`, but every `prepare` must still pass static preflight and either native start/stop or the parent spawn/completed-wait fallback must produce verifiable consumed host evidence. The fallback may wait only for empty turns or protocol `inProgress`; malformed, identity/transport errors, or abnormal terminals pause deterministically. The claude-code exception above is already scoped in the second bullet and does not change this rule's fail-closed requirement for any other field or client.

package/templates/.agents/skills/run-task/reference/host-validation.zh-CN.md

@@ -6,7 +6,9 @@
 
 - 客户端版本、启用的多代理能力、启动入口与信任边界。
 - 原始 start/stop 事件，或 custom role 缺少它们时的 parent PostTool spawn/completed-wait fallback，能稳定关联 managed agent、parent/child identity、fresh spawn mode、actual model 和 actual reasoning effort。
+  > 结构上不提供 fork/spawn-mode 事件字段的 direct-host 客户端（当前为 claude-code），身份关联允许仅由 parent/child identity 的唯一性与一次性状态机提供，不要求额外的 fresh spawn mode 证明；该客户端仍需如实记录这一缺口与替代保证的构成，不得补造 spawn mode 证据。此例外不适用于其他客户端。具体而言，claude-code 的身份保证仅由 `parentId`/`childId` 非空且互不相等、同一 run 内 `childId` 唯一、receipt 一次性状态机三者提供，不含 codex 式的 `spawn_mode` fork 证明，强度弱于 codex。
 - 显式 requested model/effort 能传给 executor/reviewer；宿主对任一字段回退时，事件能给出对应 actual 值与独立的非空 fallback reason。
+  > claude-code 例外：requested reasoning effort 暂不支持按角色下发给 executor/reviewer——`.claude/agents/{executor,reviewer}.md` 是仓库级共享单例，动态写入存在跨任务竞态，解决该竞态超出本任务范围。该客户端只要求如实记录宿主原生 Start/Stop 事件中能观察到的 actual model/actual reasoning effort（`delegationEvidence.actualReasoningEffort` 声明为 `spawn-ack`）；观察不到时记录为缺失，不视为需要独立 fallback reason 的回退场景，也不构成 fail-closed 阻断。此例外不适用于其他客户端。
 - candidate checkout 与打包安装后的行为一致，且模型策略、receipt 与验证结果可从 `orchestration.json` 复核。
 - direct-host 的 project/managed source 与 sandbox controller 的 isolated-user source、build/contract/profile/controller digest 必须在 prepare/start/stop/consume 全链路一致。
 
@@ -19,4 +21,4 @@
 5. 仅把去敏摘要与非敏感 fixture 纳入版本库；token、绝对用户路径、transcript 内容和凭证必须删除或替换。
 6. sandbox backend 另做至少 10 次 executor 与 10 次 reviewer 冷启动，记录 prepared、spawn dispatch、SubagentStart、activation completed 的单调时钟及 p50/p95/max；仅当 max 加 20% 余量不超过 deadline，并通过 symlink/config/plugin/lease/context/build 失败注入和终态清理审计时启用。
 
-任一字段无法从真实宿主稳定观察时，该客户端的 orchestration capability 保持 `unsupported`，并把缺口记录为人工验证项。Codex 可声明为 `experimental`，但每次 `prepare` 仍必须通过静态 preflight，且原生 start/stop 或 parent spawn/completed-wait fallback 必须形成可验证的 consumed host evidence。fallback 只允许 empty turns/协议 `inProgress` 等待；malformed、身份/传输错误或异常 terminal 都稳定暂停。
+任一字段无法从真实宿主稳定观察时，该客户端的 orchestration capability 保持 `unsupported`，并把缺口记录为人工验证项。Codex 可声明为 `experimental`，但每次 `prepare` 仍必须通过静态 preflight，且原生 start/stop 或 parent spawn/completed-wait fallback 必须形成可验证的 consumed host evidence。fallback 只允许 empty turns/协议 `inProgress` 等待；malformed、身份/传输错误或异常 terminal 都稳定暂停。上述关于 claude-code 的例外已在第 2 条单独说明，不改变本条对其余字段/客户端的 fail-closed 要求。

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.en.md

@@ -31,7 +31,7 @@ For each failing check, decide "self-heal" vs "ask for help" in this order:
    - Before fixing, run `git status -s` to record the working tree and ensure only changes related to this failure are included.
    - Locate and make a minimal fix per the logs (touch only code / tests / config related to that failure).
    - Run the relevant tests: prefer the local command for the failing job; otherwise read the project `test` skill and select its declared core or full validation command. If neither command is known, ask for help. **Do not commit or push before tests pass.**
-   - After tests pass, call `git-workflow commit` and `git-workflow push`, then verify the remote SHA.
+   - After tests pass, put the paths, message, expected HEAD, expected tree, and push policy (remote, full refs, automatic) into one intent JSON; call `git-workflow commit` once and verify the remote SHA. If the remote push fails, retry the same commit intent with empty `paths` through the push-only path.
    - Append the fix commit SHA to this run's `repairCommits`, increment the fix count, and return to SKILL step 2. When checks turn green, an empty list routes to `complete-task`; a non-empty list routes to `review-code`.
    - Never make unrelated "drive-by" optimizations; never loosen / skip the failing assertion to "make it green".
 

package/templates/.agents/skills/watch-pr/reference/monitor-and-heal.zh-CN.md

@@ -31,7 +31,7 @@ unknown: help
    - 自愈前先 `git status -s` 记录当前工作树，确保后续只纳入与本次失败相关的改动。
    - 在本地按日志定位并最小化修复（只动与该失败相关的代码 / 测试 / 配置）。
    - 运行对应测试：优先失败 job 对应的本地命令；否则读取项目 `test` skill，选择其中声明的 core 或 full 验证命令。两者均未知时进入求助出口。**测试通过前不得提交或推送。**
-   - 测试通过后发布修复：把相关路径、message 与 expected HEAD 写入 intent JSON，调用 `git-workflow commit`，再调用 `git-workflow push` 并复核远端 SHA。
+   - 测试通过后发布修复：把相关路径、message、expected HEAD、expected tree 和 push policy（remote、完整 refs、automatic）写入同一个 intent JSON，调用一次 `git-workflow commit` 并复核远端 SHA；远端失败时使用相同 commit intent 的空 `paths` push-only 重试。
    - 将本次修复的 commit SHA 追加到当前运行的 `repairCommits`，修复计数 +1，回到 SKILL 步骤 2 重新监控；全绿时列表为空走 `complete-task`，非空走 `review-code`。
    - 绝不执行与失败无关的「顺手优化」；不放宽 / 跳过失败的断言来「修绿」。
 

package/templates/.codex/hooks.json

@@ -18,7 +18,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js\" --client codex --event pre-tool",
-            "timeout": 15,
+            "timeout": 30,
             "statusMessage": "Recording Codex lifecycle spawn evidence"
           }
         ]
@@ -31,7 +31,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js\" --client codex --event post-tool",
-            "timeout": 15,
+            "timeout": 30,
             "statusMessage": "Recording Codex lifecycle tool completion"
           }
         ]
@@ -44,7 +44,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js\" --client codex --event subagent-start",
-            "timeout": 15,
+            "timeout": 30,
             "statusMessage": "Recording Codex child identity"
           }
         ]
@@ -57,7 +57,7 @@
           {
             "type": "command",
             "command": "node \"$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js\" --client codex --event subagent-stop",
-            "timeout": 15,
+            "timeout": 30,
             "statusMessage": "Recording Codex child stop evidence"
           }
         ]

package/dist/lib/task/commit-finalization.js

@@ -1,305 +0,0 @@
-import { execFileSync, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { locateActivityLog, appendActivityEntry, pairEntries, parseCommitAttemptStarted } from './activity-log.js';
-import { commitIntentPath, digest, readCommitIntent } from './commit-intent.js';
-import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.js';
-import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewedGitTree } from './review-fingerprint.js';
-const SHA_RE = /^[a-f0-9]{40,64}$/;
-function git(repoRoot, args) {
-    return execFileSync('git', args, {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe']
-    }).trim();
-}
-function commitExists(repoRoot, value) {
-    return SHA_RE.test(value) && spawnSync('git', ['cat-file', '-e', `${value}^{commit}`], {
-        cwd: repoRoot,
-        stdio: 'ignore'
-    }).status === 0;
-}
-function isAncestor(repoRoot, ancestor, descendant) {
-    return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
-        cwd: repoRoot,
-        stdio: 'ignore'
-    }).status === 0;
-}
-function hasMatchingApprovedReview(taskDir, beforeRound, baseline, tree) {
-    const entries = fs.readdirSync(taskDir);
-    for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
-        const file = path.join(taskDir, artifactName('review-code', round));
-        if (!fs.existsSync(file))
-            continue;
-        const content = fs.readFileSync(file, 'utf8');
-        const summary = parseReviewSummary(content);
-        if (summary.ok
-            && summary.summary.verdict === 'Approved'
-            && extractReviewBaseline(content) === baseline
-            && extractReviewedSnapshotTree(content) === tree)
-            return true;
-    }
-    return false;
-}
-function outcome(disposition, overrides = {}) {
-    return {
-        disposition,
-        code: null,
-        message: disposition,
-        currentHead: '',
-        committedHead: null,
-        commitNote: null,
-        activityNote: null,
-        needsAnchor: false,
-        needsLog: false,
-        intent: null,
-        intentDigest: null,
-        attempt: null,
-        ...overrides
-    };
-}
-function invalid(message, currentHead = '', code = 'COMMIT_FINALIZATION_EVIDENCE_INVALID', overrides = {}) {
-    return outcome('invalid', { code, message, currentHead, ...overrides });
-}
-function inspectCommitFinalization(taskDir, repoRoot, taskId) {
-    let currentHead;
-    let taskContent;
-    let metadata;
-    try {
-        currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
-        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-        metadata = parseTypedTaskFrontmatter(taskContent);
-    }
-    catch (error) {
-        return invalid(error instanceof Error ? error.message : String(error));
-    }
-    const activity = locateActivityLog(taskContent);
-    if (!activity)
-        return invalid('task activity log is missing or ambiguous', currentHead);
-    const commitRows = pairEntries(activity.entries).filter((row) => row.step === 'Commit');
-    const openRows = commitRows.filter((row) => row.started !== '' && row.done === '');
-    const file = commitIntentPath(taskDir);
-    if (!fs.existsSync(file)) {
-        if (openRows.length === 1) {
-            const attempt = parseCommitAttemptStarted(openRows[0].note);
-            if (attempt && attempt.baseline === currentHead) {
-                return outcome('retryable-start', {
-                    message: 'a structured Commit attempt can be safely reused',
-                    currentHead,
-                    attempt
-                });
-            }
-        }
-        if (openRows.length > 0) {
-            return outcome('orphaned-start', {
-                code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
-                message: 'an open Commit activity entry exists without a commit intent',
-                currentHead
-            });
-        }
-        return outcome('idle', { message: 'no active commit finalization exists', currentHead });
-    }
-    let raw;
-    let intent;
-    try {
-        raw = fs.readFileSync(file, 'utf8');
-        intent = readCommitIntent(taskDir, taskId);
-    }
-    catch (error) {
-        return invalid(error instanceof Error ? error.message : String(error), currentHead);
-    }
-    const intentDigest = digest(raw);
-    const shared = { currentHead, intent, intentDigest, committedHead: intent.committedHead };
-    if (!commitExists(repoRoot, intent.baselineHead)) {
-        return invalid('commit intent baseline is not a valid Git commit', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'prepared') {
-        if (intent.committedHead !== null || intent.pushEvidence !== null) {
-            return invalid('prepared commit intent contains commit or push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-        }
-        if (currentHead !== intent.baselineHead || openRows.length !== 1) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'prepared commit intent does not match HEAD and exactly one open Commit entry'
-            });
-        }
-        return outcome('prepared', { ...shared, message: 'prepared commit intent can be safely retried' });
-    }
-    if (!intent.committedHead || !commitExists(repoRoot, intent.committedHead)) {
-        return invalid('committed intent head is missing or invalid', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'committed' && intent.pushEvidence !== null) {
-        return invalid('committed intent contains premature push evidence', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (intent.phase === 'pushed'
-        && (intent.pushEvidence === null
-            || intent.pushEvidence.head !== intent.committedHead
-            || !intent.pushEvidence.remote
-            || !intent.pushEvidence.ref)) {
-        return invalid('pushed intent evidence is missing or inconsistent', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-    }
-    if (currentHead !== intent.committedHead || !isAncestor(repoRoot, intent.baselineHead, intent.committedHead)) {
-        return outcome('conflict', {
-            ...shared,
-            code: 'COMMIT_FINALIZATION_CONFLICT',
-            message: 'repository HEAD or ancestry conflicts with the commit intent'
-        });
-    }
-    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-    const pushOnlyRetry = intent.phase === 'pushed'
-        && intent.baselineHead === intent.committedHead
-        && matchingDone.length === 1
-        && openRows.length === 1;
-    const review = findAuthoritativeReviewCodeArtifact(taskDir);
-    let needsAnchor = false;
-    if (review.ok && review.path) {
-        let reviewContent;
-        try {
-            reviewContent = fs.readFileSync(review.path, 'utf8');
-        }
-        catch (error) {
-            return invalid(error instanceof Error ? error.message : String(error), currentHead, 'COMMIT_FINALIZATION_EVIDENCE_MISSING', shared);
-        }
-        const summary = parseReviewSummary(reviewContent);
-        const reviewBaseline = extractReviewBaseline(reviewContent);
-        const reviewTree = extractReviewedSnapshotTree(reviewContent);
-        if (!summary.ok || summary.summary.verdict !== 'Approved' || !commitExists(repoRoot, reviewBaseline) || !parseReviewedGitTree(reviewTree)) {
-            return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
-        }
-        const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-        const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
-        if (!matchingCurrentReview
-            && !hasMatchingApprovedReview(taskDir, review.round, intent.baselineHead, committedTree)) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'review baseline or snapshot tree conflicts with the committed intent'
-            });
-        }
-        const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-        if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
-            return outcome('conflict', {
-                ...shared,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'task review anchor conflicts with the committed intent'
-            });
-        }
-        needsAnchor = anchor !== intent.committedHead;
-    }
-    const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
-    if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
-        return outcome('conflict', {
-            ...shared,
-            code: 'COMMIT_FINALIZATION_CONFLICT',
-            message: 'Commit activity identity is missing, duplicated, or ambiguous',
-            commitNote
-        });
-    }
-    return outcome('recoverable', {
-        ...shared,
-        message: 'commit finalization can be recovered',
-        commitNote,
-        activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
-        needsAnchor,
-        needsLog
-    });
-}
-function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
-    if (inspection.disposition !== 'recoverable'
-        || !inspection.committedHead
-        || !inspection.commitNote
-        || !inspection.activityNote) {
-        throw new Error('commit finalization task mutations require a recoverable inspection');
-    }
-    const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-    const frontmatter = { assigned_to: agent };
-    if (inspection.needsAnchor)
-        frontmatter.last_reviewed_commit = inspection.committedHead;
-    const mutations = [{
-            kind: 'frontmatter',
-            set: frontmatter
-        }];
-    if (inspection.needsLog) {
-        const activity = locateActivityLog(taskContent);
-        if (!activity)
-            throw new Error('task activity log is missing or ambiguous');
-        mutations.push({
-            kind: 'section',
-            aliases: ['活动日志', 'Activity Log'],
-            heading: activity.heading,
-            body: appendActivityEntry(activity, {
-                time: timestamp,
-                step: 'Commit',
-                agent,
-                note: inspection.activityNote
-            })
-        });
-    }
-    return { mutations, commitNote: inspection.commitNote };
-}
-function inspectCreatePrCommitGate(taskDir, repoRoot, taskId) {
-    const lifecycle = inspectCommitFinalization(taskDir, repoRoot, taskId);
-    if (lifecycle.disposition !== 'idle') {
-        const pending = lifecycle.disposition === 'prepared' || lifecycle.disposition === 'recoverable';
-        return {
-            allowed: false,
-            code: pending ? 'COMMIT_FINALIZATION_PENDING' : lifecycle.code ?? 'COMMIT_FINALIZATION_CONFLICT',
-            message: pending ? 'commit finalization must complete before creating a pull request' : lifecycle.message,
-            disposition: lifecycle.disposition,
-            action: 'rerun-commit'
-        };
-    }
-    const review = findAuthoritativeReviewCodeArtifact(taskDir);
-    if (!review.ok || !review.path) {
-        return { allowed: true, code: null, message: 'no review-code history requires an anchor', disposition: 'idle', action: 'continue' };
-    }
-    try {
-        const content = fs.readFileSync(review.path, 'utf8');
-        const summary = parseReviewSummary(content);
-        if (!summary.ok || summary.summary.verdict !== 'Approved') {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
-                message: 'latest authoritative review-code is not approved',
-                disposition: 'idle',
-                action: 'rerun-review-code'
-            };
-        }
-        const task = parseTypedTaskFrontmatter(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'));
-        const currentHead = git(repoRoot, ['rev-parse', 'HEAD']);
-        const anchor = String(task.last_reviewed_commit ?? '').trim();
-        if (!anchor || !commitExists(repoRoot, anchor)) {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_EVIDENCE_MISSING',
-                message: 'approved review snapshot is not anchored to a Git commit',
-                disposition: 'idle',
-                action: 'rerun-commit'
-            };
-        }
-        if (anchor !== currentHead || extractReviewedSnapshotTree(content) !== git(repoRoot, ['rev-parse', 'HEAD^{tree}'])) {
-            return {
-                allowed: false,
-                code: 'COMMIT_FINALIZATION_CONFLICT',
-                message: 'approved review anchor or tree does not match repository HEAD',
-                disposition: 'idle',
-                action: 'rerun-review-code'
-            };
-        }
-        return { allowed: true, code: null, message: 'commit finalization evidence is complete', disposition: 'idle', action: 'continue' };
-    }
-    catch (error) {
-        return {
-            allowed: false,
-            code: 'COMMIT_FINALIZATION_EVIDENCE_INVALID',
-            message: error instanceof Error ? error.message : String(error),
-            disposition: 'idle',
-            action: 'rerun-review-code'
-        };
-    }
-}
-export { inspectCommitFinalization, inspectCreatePrCommitGate, planCommitTaskFinalization };
-//# sourceMappingURL=commit-finalization.js.map

package/dist/lib/task/commit-intent.js

@@ -1,165 +0,0 @@
-import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-class CommitIntentError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = 'CommitIntentError';
-        this.code = code;
-    }
-}
-function commitIntentPath(taskDir) {
-    return path.join(taskDir, 'commit-intent.json');
-}
-function digest(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function serialize(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function atomicWrite(file, value) {
-    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        fs.writeFileSync(temp, serialize(value), { encoding: 'utf8', flag: 'wx', mode: 0o600 });
-        const handle = fs.openSync(temp, 'r+');
-        try {
-            fs.fsyncSync(handle);
-        }
-        finally {
-            fs.closeSync(handle);
-        }
-        fs.renameSync(temp, file);
-        fs.chmodSync(file, 0o600);
-        try {
-            const directory = fs.openSync(path.dirname(file), 'r');
-            try {
-                fs.fsyncSync(directory);
-            }
-            finally {
-                fs.closeSync(directory);
-            }
-        }
-        catch (error) {
-            const code = error.code;
-            if (!['EACCES', 'EISDIR', 'EINVAL', 'EPERM'].includes(code ?? ''))
-                throw error;
-        }
-    }
-    finally {
-        if (fs.existsSync(temp))
-            fs.unlinkSync(temp);
-    }
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function keysEqual(value, expected) {
-    return Object.keys(value).sort().join('\0') === [...expected].sort().join('\0');
-}
-function validPushEvidence(value) {
-    return value === null || (isRecord(value)
-        && keysEqual(value, ['remote', 'ref', 'head'])
-        && ['remote', 'ref', 'head'].every((key) => typeof value[key] === 'string' && value[key] !== ''));
-}
-function validOrchestration(value) {
-    if (value === null)
-        return true;
-    if (!isRecord(value) || !keysEqual(value, [
-        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest',
-        'completionUpdatedAt', 'plannedReceipt'
-    ]))
-        return false;
-    return [
-        'runId', 'receiptId', 'authorizationIssuedAt', 'sourceRunDigest', 'plannedRunDigest', 'completionUpdatedAt'
-    ].every((key) => typeof value[key] === 'string' && value[key] !== '') && isRecord(value.plannedReceipt);
-}
-function parseIntent(raw, taskId) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent is not valid JSON');
-    }
-    if (!isRecord(value) || !keysEqual(value, [
-        'schemaVersion', 'taskId', 'mode', 'phase', 'tokenDigest', 'baselineHead', 'committedHead',
-        'pushEvidence', 'orchestration', 'createdAt', 'updatedAt'
-    ])) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has an invalid schema');
-    }
-    if (value.schemaVersion !== 1
-        || value.taskId !== taskId
-        || !['standalone', 'orchestrated'].includes(String(value.mode))
-        || !['prepared', 'committed', 'pushed'].includes(String(value.phase))
-        || typeof value.tokenDigest !== 'string'
-        || !/^[a-f0-9]{64}$/.test(value.tokenDigest)
-        || typeof value.baselineHead !== 'string'
-        || (value.committedHead !== null && typeof value.committedHead !== 'string')
-        || !validPushEvidence(value.pushEvidence)
-        || !validOrchestration(value.orchestration)
-        || typeof value.createdAt !== 'string'
-        || typeof value.updatedAt !== 'string'
-        || (value.mode === 'standalone') !== (value.orchestration === null)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_INVALID', 'commit intent has invalid field values');
-    }
-    return value;
-}
-function tokenMatches(actualDigest, token) {
-    const actual = Buffer.from(actualDigest, 'hex');
-    const supplied = Buffer.from(digest(token), 'hex');
-    return actual.length === supplied.length && timingSafeEqual(actual, supplied);
-}
-function readCommitIntent(taskDir, taskId, token) {
-    const file = commitIntentPath(taskDir);
-    const intent = parseIntent(fs.readFileSync(file, 'utf8'), taskId);
-    if (token !== undefined && !tokenMatches(intent.tokenDigest, token)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_TOKEN_MISMATCH', 'commit intent token does not match');
-    }
-    return intent;
-}
-function createCommitIntent(taskDir, input, options = {}) {
-    const file = commitIntentPath(taskDir);
-    if (fs.existsSync(file)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists');
-    }
-    const token = (options.token ?? (() => randomBytes(32).toString('base64url')))();
-    const intent = Object.freeze({ schemaVersion: 1, ...input, tokenDigest: digest(token) });
-    atomicWrite(file, intent);
-    return { intent, token };
-}
-function updateCommitIntent(taskDir, taskId, token, updates) {
-    const current = readCommitIntent(taskDir, taskId, token);
-    const nextPhase = updates.phase ?? current.phase;
-    const transitions = {
-        prepared: ['prepared', 'committed', 'pushed'],
-        committed: ['committed', 'pushed'],
-        pushed: ['pushed']
-    };
-    if (!transitions[current.phase].includes(nextPhase)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_INTENT_STATE_INVALID', `cannot move commit intent from ${current.phase} to ${nextPhase}`);
-    }
-    const updated = Object.freeze({ ...current, ...updates, phase: nextPhase });
-    atomicWrite(commitIntentPath(taskDir), updated);
-    return updated;
-}
-function removeCommitIntent(taskDir, taskId, token) {
-    readCommitIntent(taskDir, taskId, token);
-    fs.unlinkSync(commitIntentPath(taskDir));
-}
-function removeCommitIntentByDigest(taskDir, taskId, expectedDigest) {
-    const file = commitIntentPath(taskDir);
-    const raw = fs.readFileSync(file);
-    parseIntent(raw.toString('utf8'), taskId);
-    const actual = digest(raw);
-    const expected = Buffer.from(expectedDigest, 'hex');
-    const observed = Buffer.from(actual, 'hex');
-    if (!/^[a-f0-9]{64}$/.test(expectedDigest)
-        || expected.length !== observed.length
-        || !timingSafeEqual(expected, observed)) {
-        throw new CommitIntentError('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit intent changed after recovery inspection');
-    }
-    fs.unlinkSync(file);
-}
-export { CommitIntentError, commitIntentPath, createCommitIntent, digest, readCommitIntent, removeCommitIntent, removeCommitIntentByDigest, serialize, updateCommitIntent };
-//# sourceMappingURL=commit-intent.js.map