@tea-agent/loop-agent 0.16.26 → 0.17.0

package/CHANGELOG.md

@@ -1,10 +1,45 @@
+# 更新日志
+
+## [0.17.0] - 2026-07-22
+
+### 新增
+
+- streamline report-first workflow (#53)
+- add operator console, task contract, and harden bindings (#51)
+- condition DAG design and repair branches
+
+### 修复
+
+- synchronize console frontend lockfile (#52)
+- tolerate mock strategy format drift
+- bound executor output
+
 ## [Unreleased]
 
+- 将 `backend-test` runtime 与打包模板收敛为报告优先的 12 节点 DAG：case review 改为 advisory evidence，移除 pytest semantic review/gates 与最终 outcome gate，保留 pytest 前确定性 traceability hard gate、单次 pytest、canonical context/retrospective/L-5；Analysis v2 对 string evidence gap 与 `id` alias 做窄 canonicalize，同时继续严格拒绝未知键、错类型、secret 与多 JSON envelope。
+
+### 修复
+
+- DAG runtime 的 task-contract 启动门禁现在只将 `writePolicy: "exclusive"` 视为 writer execution：历史只读/static/shell DAG 可继续执行，legacy writer DAG 仍必须升级为 DagSpec v4 并绑定 managed Task Contract；真实 DAG 生成会冻结当前 managed binding。测试执行 fixture、Worker materializer 和 Windows npm/tmp 路径也已同步适配该契约。
+- Pi CLI / SDK executor 不再把单个节点的完整 stdout 累积为一个 JS 字符串；长 `frontend-plan-pi` 或大段结构化输出会保留有界预览并继续流式解析最终 assistant 事件，避免触发 V8 `Invalid string length` 或卡死。
+- DAG 节点新增 `outputMode: "structured-required"`；前端实现计划/修订节点显式使用该模式，并在 `output-too-large` 时用紧凑结构化输出指令重试，避免直接截断计划后继续执行，也减少长计划输出阻断后续流程的概率。
+- `frontend-mock-assess-pi` 的 `MOCK_STRATEGY:` 协议行规范化现在可处理列表、引用、inline code、中文冒号、`Mock strategy` 标签和标签/值分行等常见格式漂移；仍只接受明确 Mock strategy 标签和五态白名单，不从普通正文猜默认策略。
+
 ### 改进
 
-- Observe 节点检查器“规范证据”页签新增安全文件预览：已绑定任务源和已读取规范文件条目现以可聚焦按钮呈现，点击后在检查器内下钻查看内容（不新增弹窗），提供“返回规范证据”按钮并恢复触发行焦点。新增只读接口 `GET /api/dag-runs/:runId/nodes/:nodeId/spec-evidence/file?source=binding|read&path=...`，服务端重新校验证据成员身份（binding 必须在 `sourceBinding.sources`，read 必须有成功配对 read），拒 `..`/绝对/目录/二进制/仓库外符号链接；正文上限 64KB 并返回截断标志，统一走 Observe 脱敏规则；binding 返回 `sha256`/`currentSha256`/`hashMatch`，read 返回 session event 中实际读取正文与 `readAt`（不以当前工作区文件替代）。
+- **Console Phase 3（Observe 协作）**：
+  - Observe `GET /api/health` 升级为 versioned DTO（`schemaVersion: 1`、`repoFingerprint` 复用 Console `repoFingerprintV1`、package name/version、由 ROUTES 派生的 `routeCapabilities`）。
+  - Console `observeLink` fail-closed：仅 health **match**（同仓 fingerprint + schema + 目标 kind 所需 capability）时返回深链；offline / mismatch 返回诊断与 `agent-worker observe serve --repo . --port 8787`，不打开错误 URL。
+  - Doctor 的 Observe 探测扩展 match / mismatch / unavailable（Observe 仍非阻塞，doctor `ok` 保持）。
+  - Recovery CTA 矩阵（report / doctor / decision / resume / reconcile / regenerate / observeLink）：**无** Cancel、**无**主 CTA「直接改代码」。
+  - Console 与 Observe 仍为独立进程；不 mount、不 proxy、不复制第二套 read model。
+- Phase 1 Console skeleton：`agent-worker console serve|doctor`（默认 loopback `127.0.0.1:8790`、非 loopback fail-closed）、Vite SPA 静态产物 + Node health/static server、boot capability cookie + mutation Host/Origin 门禁、封闭 ResourceLoader 骨架、sibling `loop-agent` identity doctor、`repoFingerprintV1` / Observe 深链 builder、以及 `UPSTREAM.md`（pi-web 源 commit）与预算 report。
+- Phase 0.5 operator surface repair：`buildOperatorCapabilitiesDocument()` 在权威 `src/shared/operator` 上补齐 Console 协商块 `dag`（`generatedSpecVersion: 4`、`requiresTaskContractBinding: true`，与 `dagSpecVersions` 同源常量），并删除冲突的 `src/task/operator` 双实现；CLI `--json` 继续写 `process.stdout`，测试侧改为捕获 stdout。
 
+- `frontend-implementation` 绿色路径由固定全链改为按需分支：删除重复的首轮 design shell gate，初审通过直接复用原计划，只有 `request-revision` 才执行计划修订与终审；只有可修复失败才执行 repair/reverify/retrace。常规全绿路径因此少执行 3 个 Pi 与 4 个 shell 节点，同时保留 pass-only 写入门禁、验证/评审证据和只读 `frontend-closeout-pi`。原计划/修订计划的结构化合同与需求覆盖使用同一有效来源，且只有主分支产物缺失时才回退；已存在但 malformed/schema-invalid 的产物继续 fail-closed。
+- Observe 节点检查器“规范证据”页签新增安全文件预览：已绑定任务源和已读取规范文件条目现以可聚焦按钮呈现，点击后在检查器内下钻查看内容（不新增弹窗），提供“返回规范证据”按钮并恢复触发行焦点。新增只读接口 `GET /api/dag-runs/:runId/nodes/:nodeId/spec-evidence/file?source=binding|read&path=...`，服务端重新校验证据成员身份（binding 必须在 `sourceBinding.sources`，read 必须有成功配对 read），拒 `..`/绝对/目录/二进制/仓库外符号链接；正文上限 64KB 并返回截断标志，统一走 Observe 脱敏规则；binding 返回 `sha256`/`currentSha256`/`hashMatch`，read 返回 session event 中实际读取正文与 `readAt`（不以当前工作区文件替代）。
 - 通用 standard/reviewed/supervised 实现 DAG 现在会在目标仓库存在 `AGENTS.md` 时，按本次 writer 的实际变更解析适用的根级/嵌套指令和仓库内代码规范索引：standard 复用 `verify-pi` 与条件 shell gate，reviewed/supervised 复用现有 `review-pi`/review gate，不新增模型节点；无 `AGENTS.md` 或无适用规范时保持原行为，审查节点只读且不会直接改代码。专用测试、前端和知识类 DAG 不受影响。
+
 - GitHub Actions CI 降低私有仓分钟消耗：合并为单 job（避免两次 `npm ci`）、同分支/`PR` concurrency 取消旧 run、Draft PR 跳过完整 CI，且仅忽略 `docs/reports/**`、`docs/progress/**`、`docs/design/archive/**`、`docs/exec-plans/completed/**` 等纯运营文档路径；治理文档与代码门禁仍全量跑。
 - 明确 **Compatibility / Operator Assist**：openCode 等主会话只编排已发布 `loop-agent` / `agent-worker` CLI 与只读诊断，不得绕过 CLI 直接改业务实现，失败只走 doctor / reconcile / human gate / CLI 重跑。`loop-agent init` 写入的 `AGENTS.md` managed block、包内 skills 与 website 快速开始/治理说明已对齐；架构决策见 `docs/decisions/0005-governed-operator-surface.md`（accepted）。已有目标项目用 `loop-agent init check-update` / `init update --apply-safe` 或 `init reconcile` 刷新 managed block。
 - 前端测试 DAG 收紧体验：execution preflight 仅硬校验绝对非生产 `baseUrl`；用例 map 缩短为优先用 `playwright-cli` 执行；复盘合并执行证据审查且不依赖 outcome=pass，失败也能出报告。
@@ -22,6 +57,8 @@
 
 ### 修复
 
+- Windows DAG Shell/verification 的 clean environment 现在保留 `APPDATA`，使 Python 3.12/pip 可按系统规则发现用户级 `site-packages` 与其中的 pytest；仍不会继承完整宿主环境或透传未授权 token/credential，backend-test 无需硬编码用户路径。
+
 - Backend-test Analysis v2 intake 现在可确定性归一化模型常见的外部依赖 `type` / `target` 与风险 `type` 字段：dependency `target` 映射为 canonical `name`，扩展字段不落盘；dependency/risk 仍使用类别化白名单，未知字段和 `risks[].target` 继续 fail-closed，避免节点 02 因合法近似形态过早中断。
 
 - Backend-test 唯一 JSON object 提取器在扫描裸对象前会等长忽略完整 Markdown 行内代码中的对象形状示例（如 `{error:{code,message,type}}`）；唯一真实 envelope 可正常物化，多个真实 JSON、fence 外额外对象与未闭合对象继续 fail-closed。

package/README.md

@@ -5,7 +5,7 @@
 发布包提供两个 CLI：
 
 | CLI | 职责 |
-|---|---|
+| --- | --- |
 | `loop-agent` | 单仓库任务、Agent DAG、验证、恢复与治理 |
 | `agent-worker` | 可选的 Feature、TaskSpec、Task Pool 与 Observe 外层编排 |
 
@@ -85,13 +85,24 @@ loop-agent dag doctor --run-id <run-id> --markdown
 loop-agent dag report --run-id <run-id>
 ```
 
-启动本地只读看板：
+### Official 本地操作面（CLI + Console + 独立 Observe）
+
+| 入口 | 命令 | 角色 |
+| --- | --- | --- |
+| 受治理 CLI | `loop-agent …` / `agent-worker …` | 权威写入与诊断 |
+| Loop Operator Console | `agent-worker console serve --repo .` | Official 本地控制面（默认 `127.0.0.1:8790`） |
+| Observe | `agent-worker observe serve --repo . --port 8787` | 独立只读看板 |
 
 ```bash
+# 终端 A：Console（任务/运行操作面；canonical mutation 只经 sibling loop-agent）
+agent-worker console serve --repo .
+agent-worker console doctor --repo .
+
+# 终端 B：独立 Observe（不经 Console mount/proxy）
 agent-worker observe serve --repo . --port 8787
 ```
 
-访问 <http://127.0.0.1:8787/>。Observe 只读取运行事实，不修改 DAG、Task Pool 或 Feature 状态。
+访问 Console <http://127.0.0.1:8790/> 与 Observe <http://127.0.0.1:8787/>。Observe 只读运行事实；Console 通过 versioned health（同仓 `repoFingerprint` + route capability）fail-closed 构建深链。openCode 等主会话仍是 **Compatibility / Operator Assist**，不得升级为与 Official 同等保证。
 
 ## 核心边界
 

package/dist/cli/command-definitions.js

@@ -11,6 +11,8 @@ import { runInspect } from "../commands/inspect.js";
 import { runInstructions } from "../commands/instructions.js";
 import { runNewTask } from "../commands/new-task.js";
 import { runImportPrd } from "../commands/import-prd.js";
+import { runTaskContract } from "../commands/task-contract.js";
+import { runOperator } from "../commands/operator.js";
 import { runPlanList } from "../commands/plan-list.js";
 import { runPlanCheck, runPlanComplete, runPlanCreate, } from "../commands/plan.js";
 import { runPromoteRun } from "../commands/promote-run.js";
@@ -133,6 +135,17 @@ const DAG_SUBCOMMANDS = [
     "final-verification",
     "decision",
 ];
+const TASK_SUBCOMMANDS = ["contract"];
+const TASK_CONTRACT_SUBCOMMANDS = [
+    "show",
+    "validate",
+    "diff",
+    "apply",
+    "adopt",
+    "doctor",
+    "recover",
+];
+const OPERATOR_SUBCOMMANDS = ["capabilities"];
 const WORKFLOW_SUBCOMMANDS = [
     "list",
     "inspect",
@@ -250,6 +263,36 @@ export const COMMAND_DEFINITIONS = [
             await runImportPrd(repoRoot, [subcommand, ...rest].filter(Boolean));
         },
     },
+    {
+        name: "task",
+        adapter: "required",
+        tier: "primary",
+        intent: "Task Contract application boundary: show/validate/diff/apply/adopt/doctor/recover managed contract facts.",
+        usage: "task contract <show|validate|diff|apply|adopt|doctor|recover> ...",
+        subcommands: [...TASK_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            if (subcommand !== "contract") {
+                throw new Error(formatSubcommandUsageError("task", TASK_SUBCOMMANDS));
+            }
+            const [contractSub, ...contractRest] = rest;
+            if (!contractSub ||
+                !TASK_CONTRACT_SUBCOMMANDS.includes(contractSub)) {
+                throw new Error(`usage: task contract <${TASK_CONTRACT_SUBCOMMANDS.join("|")}> ...`);
+            }
+            await runTaskContract(repoRoot, [contractSub, ...contractRest]);
+        },
+    },
+    {
+        name: "operator",
+        adapter: "required",
+        tier: "operator",
+        intent: "Operator machine envelope capabilities registry for Console/CLI negotiation.",
+        usage: "operator capabilities [--json]",
+        subcommands: [...OPERATOR_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runOperator(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
+        },
+    },
     {
         name: "status",
         adapter: "required",

package/dist/cli/program.js

@@ -38,6 +38,8 @@ import { runLoop } from "../commands/loop.js";
 import { runLoopBenchmark } from "../commands/loop-benchmark.js";
 import { runNewTask } from "../commands/new-task.js";
 import { runImportPrd } from "../commands/import-prd.js";
+import { runTaskContract } from "../commands/task-contract.js";
+import { runOperator } from "../commands/operator.js";
 import { runPiReuseBenchmark } from "../commands/pi-reuse-benchmark.js";
 import { parsePiPromptArgs, printPiPromptUsage, runPiPrompt, } from "../commands/pi-prompt.js";
 import { runPlanList } from "../commands/plan-list.js";
@@ -140,6 +142,30 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
         case "import-prd":
             await runImportPrd(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
+        case "task": {
+            if (subcommand !== "contract") {
+                throw new Error("usage: task <contract> ...");
+            }
+            const [contractSub, ...contractRest] = rest;
+            const allowed = [
+                "show",
+                "validate",
+                "diff",
+                "apply",
+                "adopt",
+                "doctor",
+                "recover",
+            ];
+            if (!contractSub ||
+                !allowed.includes(contractSub)) {
+                throw new Error(`usage: task contract <${allowed.join("|")}> ...`);
+            }
+            await runTaskContract(ctx.repoRoot, [contractSub, ...contractRest]);
+            return;
+        }
+        case "operator":
+            await runOperator(ctx.repoRoot, compactArgs([subcommand, ...rest]));
+            return;
         case "status": {
             if (!subcommand)
                 throw new Error("taskId required");

package/dist/commands/dag-approve.js

@@ -51,6 +51,10 @@ export function parseDagApproveArgs(args) {
 export async function runDagApprove(repoRoot, rawArgs) {
     const parsed = parseDagApproveArgs(rawArgs);
     const { runDir, state, spec } = await requirePausedDagRun(repoRoot, parsed.runId);
+    // Phase 0.5 migration matrix: paused v3 cannot approve new writer paths.
+    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent, } = await import("../workflows/dag/task-contract-binding.js");
+    assertDagSpecAllowsNewWriterExecution(spec);
+    await assertTaskContractBindingConsistent({ repoRoot, spec });
     const nodeId = state.pausedByNodeId;
     const node = state.nodes[nodeId];
     if (!node) {

package/dist/commands/dag-resume.js

@@ -26,6 +26,7 @@ export function parseDagResumeArgs(args) {
 }
 export async function runDagResume(repoRoot, rawArgs) {
     const parsed = parseDagResumeArgs(rawArgs);
+    // resumeDagRun loads the frozen run spec and revalidates taskContractBinding.
     const summary = await resumeDagRun({
         cwd: repoRoot,
         runId: parsed.runId,

package/dist/commands/dag-validate.js

@@ -7,6 +7,12 @@ export async function runDagValidate(repoRoot, rawArgs) {
         repoRoot,
         ...parsed,
     });
+    // Phase 0.5: revalidate live taskContractBinding for v4 specs.
+    // Fail closed on any binding load/check error — do not swallow unexpected exceptions.
+    const { loadDagSpecFromFile } = await import("../workflows/dag/runner.js");
+    const { assertTaskContractBindingConsistent } = await import("../workflows/dag/task-contract-binding.js");
+    const spec = await loadDagSpecFromFile(parsed.dagPath);
+    await assertTaskContractBindingConsistent({ repoRoot, spec });
     console.log(JSON.stringify({
         mode: "validate",
         ...result,

package/dist/commands/operator.js

@@ -0,0 +1,44 @@
+import { buildOperatorCapabilitiesDocument, operatorFailed, operatorSucceeded, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+export function parseOperatorArgs(args) {
+    const options = {};
+    const positional = [];
+    for (const token of args) {
+        if (token === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            throw new Error(`unknown flag ${token}\nusage: operator capabilities --json`);
+        }
+        positional.push(token);
+    }
+    const subcommand = positional[0];
+    if (!subcommand) {
+        throw new Error("usage: operator <capabilities> --json");
+    }
+    return { subcommand, options };
+}
+export async function runOperator(_repoRoot, args) {
+    const { subcommand, options } = parseOperatorArgs(args);
+    if (subcommand !== "capabilities") {
+        const result = operatorFailed({
+            command: "operator",
+            outcome: "invalid",
+            code: "INVALID_INPUT",
+            message: `unknown operator subcommand: ${subcommand}`,
+        });
+        emit(result, options.json !== false);
+        process.exitCode = processExitCodeForOutcome(result.outcome);
+        return;
+    }
+    const doc = buildOperatorCapabilitiesDocument();
+    const result = operatorSucceeded("operator capabilities", doc);
+    emit(result, true);
+}
+function emit(result, json) {
+    if (json) {
+        writeOperatorJson(result);
+        return;
+    }
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/task-contract.js

@@ -0,0 +1,271 @@
+import { ContractMutationError, adoptTaskContract, applyTaskContract, diffTaskContract, doctorTaskContract, loadDraftFromPath, observeTaskContractState, recoverTaskContract, validateDraftForTask, } from "../task/contract/index.js";
+import { operatorFailed, operatorSucceeded, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
+const USAGE = `usage:
+  task contract show <taskId> [--json]
+  task contract validate --task <id> --input <path> [--json]
+  task contract diff --task <id> --input <path> [--json]
+  task contract apply --task <id> --input <path> --expected-revision <n> --expected-observed-hash <sha256> --request-id <id> --request-payload-sha256 <sha256> [--json]
+  task contract adopt --task <id> --expected-revision <n> --expected-observed-hash <sha256> --request-id <id> --request-payload-sha256 <sha256> [--json]
+  task contract doctor --task <id> [--json]
+  task contract recover --task <id> [--tx-id <id>] [--json]`;
+export function parseTaskContractArgs(args) {
+    const options = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === "--json") {
+            options.json = true;
+            continue;
+        }
+        if (token === "--task") {
+            options.task = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--input") {
+            options.input = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--expected-revision") {
+            const raw = args[i + 1];
+            const n = Number(raw);
+            if (!Number.isInteger(n) || n < 0) {
+                throw new Error(`invalid --expected-revision: ${raw}`);
+            }
+            options.expectedRevision = n;
+            i += 1;
+            continue;
+        }
+        if (token === "--expected-observed-hash") {
+            options.expectedObservedHash = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--request-id") {
+            options.requestId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--request-payload-sha256") {
+            options.requestPayloadSha256 = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token === "--tx-id") {
+            options.txId = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (token.startsWith("-")) {
+            throw new Error(`unknown flag ${token}\n${USAGE}`);
+        }
+        positional.push(token);
+    }
+    const subcommand = positional[0];
+    if (!subcommand) {
+        throw new Error(USAGE);
+    }
+    // show takes positional taskId; others prefer --task
+    let taskId = options.task;
+    if (subcommand === "show") {
+        taskId = positional[1] ?? options.task;
+    }
+    return { subcommand, taskId, options };
+}
+function mutationOutcome(code) {
+    switch (code) {
+        case "REVISION_CONFLICT":
+        case "OBSERVED_HASH_CONFLICT":
+        case "REQUEST_ID_REUSE_CONFLICT":
+        case "LEASE_HELD":
+            return "conflict";
+        case "NOT_FOUND":
+            return "not-found";
+        case "TRANSACTION_INCOMPLETE":
+        case "OPERATION_NEEDS_RECONCILE":
+            return "needs-reconcile";
+        case "EXTERNALLY_MODIFIED":
+        case "NOT_MANAGED":
+        case "BINDING_DRIFT":
+            return "blocked";
+        case "INVALID_INPUT":
+        case "PATH_OUTSIDE_REPO":
+        case "UNSUPPORTED_SCHEMA_VERSION":
+            return "invalid";
+        default:
+            return "rejected";
+    }
+}
+function emit(result, json) {
+    // Machine envelope is the default for task contract when --json is set;
+    // without --json still print the same document for dogfood consistency.
+    writeOperatorJson(result);
+    if (!json) {
+        // already wrote JSON; human path same for Phase 0.5
+    }
+    process.exitCode = processExitCodeForOutcome(result.outcome);
+}
+export async function runTaskContract(repoRoot, args) {
+    let subcommand;
+    let taskId;
+    let options;
+    try {
+        ({ subcommand, taskId, options } = parseTaskContractArgs(args));
+    }
+    catch (error) {
+        const result = operatorFailed({
+            command: "task contract",
+            outcome: "invalid",
+            code: "INVALID_INPUT",
+            message: error instanceof Error ? error.message : String(error),
+        });
+        emit(result, true);
+        return;
+    }
+    const command = `task contract ${subcommand}`;
+    try {
+        switch (subcommand) {
+            case "show": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract show requires <taskId>");
+                }
+                const state = await observeTaskContractState(repoRoot, taskId);
+                const result = operatorSucceeded(command, { taskId, state });
+                emit(result, options.json);
+                return;
+            }
+            case "validate": {
+                if (!taskId || !options.input) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract validate requires --task and --input");
+                }
+                const { draft } = await loadDraftFromPath(options.input, repoRoot);
+                const validation = await validateDraftForTask({
+                    repoRoot,
+                    taskId,
+                    draft,
+                });
+                if (!validation.ok) {
+                    const result = operatorFailed({
+                        command,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: validation.errors.join("; "),
+                        details: { errors: validation.errors },
+                    });
+                    emit(result, options.json);
+                    return;
+                }
+                const result = operatorSucceeded(command, {
+                    taskId,
+                    valid: true,
+                    warnings: validation.warnings,
+                });
+                emit(result, options.json);
+                return;
+            }
+            case "diff": {
+                if (!taskId || !options.input) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract diff requires --task and --input");
+                }
+                const { draft } = await loadDraftFromPath(options.input, repoRoot);
+                const diff = await diffTaskContract({ repoRoot, taskId, draft });
+                const result = operatorSucceeded(command, diff);
+                emit(result, options.json);
+                return;
+            }
+            case "apply": {
+                if (!taskId ||
+                    !options.input ||
+                    options.expectedRevision === undefined ||
+                    !options.expectedObservedHash ||
+                    !options.requestId ||
+                    !options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract apply requires --task --input --expected-revision --expected-observed-hash --request-id --request-payload-sha256");
+                }
+                const loaded = await loadDraftFromPath(options.input, repoRoot);
+                // Client-supplied payload hash must match file bytes
+                if (loaded.payloadSha256 !== options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", `request-payload-sha256 does not match input file hash (expected ${loaded.payloadSha256})`);
+                }
+                const applyResult = await applyTaskContract({
+                    repoRoot,
+                    taskId,
+                    draft: loaded.draft,
+                    expectedRevision: options.expectedRevision,
+                    expectedObservedHash: options.expectedObservedHash,
+                    requestId: options.requestId,
+                    requestPayloadSha256: options.requestPayloadSha256,
+                    rawDraftText: loaded.rawText,
+                });
+                const result = operatorSucceeded(command, applyResult);
+                emit(result, options.json);
+                return;
+            }
+            case "adopt": {
+                if (!taskId ||
+                    options.expectedRevision === undefined ||
+                    !options.expectedObservedHash ||
+                    !options.requestId ||
+                    !options.requestPayloadSha256) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract adopt requires --task --expected-revision --expected-observed-hash --request-id --request-payload-sha256");
+                }
+                const adoptResult = await adoptTaskContract({
+                    repoRoot,
+                    taskId,
+                    expectedRevision: options.expectedRevision,
+                    expectedObservedHash: options.expectedObservedHash,
+                    requestId: options.requestId,
+                    requestPayloadSha256: options.requestPayloadSha256,
+                });
+                const result = operatorSucceeded(command, adoptResult);
+                emit(result, options.json);
+                return;
+            }
+            case "doctor": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract doctor requires --task");
+                }
+                const doctor = await doctorTaskContract({ repoRoot, taskId });
+                const result = operatorSucceeded(command, doctor);
+                emit(result, options.json);
+                return;
+            }
+            case "recover": {
+                if (!taskId) {
+                    throw new ContractMutationError("INVALID_INPUT", "task contract recover requires --task");
+                }
+                const recover = await recoverTaskContract({
+                    repoRoot,
+                    taskId,
+                    txId: options.txId,
+                });
+                const result = operatorSucceeded(command, recover);
+                emit(result, options.json);
+                return;
+            }
+            default:
+                throw new ContractMutationError("INVALID_INPUT", `unknown task contract subcommand: ${subcommand}\n${USAGE}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ContractMutationError) {
+            const result = operatorFailed({
+                command,
+                outcome: mutationOutcome(error.code),
+                code: error.code,
+                message: error.message,
+                details: error.details,
+            });
+            emit(result, options.json);
+            return;
+        }
+        const result = operatorFailed({
+            command,
+            outcome: "rejected",
+            code: "INTERNAL_ERROR",
+            message: error instanceof Error ? error.message : String(error),
+        });
+        emit(result, options.json);
+    }
+}

package/dist/executors/dag-pi-executor.js

@@ -353,11 +353,18 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
         return assistantText;
     const lines = assistantText.split(/\r?\n/);
     let protocolIndex = -1;
+    let protocolNextLineIndex = -1;
     let protocolLine = "";
     for (const [index, line] of lines.entries()) {
-        const normalized = normalizeProtocolLine(line);
-        if (normalized.startsWith(firstProtocolLine)) {
+        const nextLine = lines[index + 1];
+        const normalized = normalizeProtocolLine(line, firstProtocolLine, nextLine);
+        if (normalized !== undefined) {
             protocolIndex = index;
+            if (normalizeProtocolLine(line, firstProtocolLine) === undefined &&
+                nextLine !== undefined &&
+                normalizedProtocolValue(nextLine) !== "") {
+                protocolNextLineIndex = index + 1;
+            }
             protocolLine = normalized;
             break;
         }
@@ -365,10 +372,14 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
     if (protocolIndex < 0)
         return assistantText;
     if (protocolIndex === 0) {
-        return [protocolLine, ...lines.slice(1)].join("\n");
+        const remaining = lines.slice(protocolNextLineIndex === 1 ? 2 : 1);
+        return [protocolLine, ...remaining].join("\n");
     }
     const before = lines.slice(0, protocolIndex);
     const after = lines.slice(protocolIndex + 1);
+    if (protocolNextLineIndex === protocolIndex + 1) {
+        after.shift();
+    }
     while (before.at(-1)?.trim() === "" &&
         after.at(0)?.trim() === "") {
         after.shift();
@@ -382,10 +393,47 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
         ? `${protocolLine}\n\n${bodyLines.join("\n")}`
         : protocolLine;
 }
-function normalizeProtocolLine(line) {
-    const trimmed = line.trim();
-    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
-    return (emphasized?.[2] ?? trimmed).trim();
+function normalizeProtocolLine(line, firstProtocolLine, nextLine) {
+    const normalizedLine = stripMarkdownLineDecorations(line);
+    if (!firstProtocolLine)
+        return normalizedLine;
+    const label = firstProtocolLine.replace(/[:：]\s*$/, "").trim();
+    const labelPattern = label
+        .split(/[_\-\s]+/)
+        .filter(Boolean)
+        .map(escapeRegExp)
+        .join("[_\\-\\s]+");
+    if (!labelPattern)
+        return undefined;
+    const direct = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
+    if (direct) {
+        const value = normalizedProtocolValue(direct[1] ?? "");
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
+    if (splitValue && nextLine !== undefined) {
+        const value = normalizedProtocolValue(nextLine);
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    return undefined;
+}
+function normalizedProtocolValue(value) {
+    let normalized = stripMarkdownLineDecorations(value);
+    normalized = normalized.replace(/^[:：]\s*/, "").trim();
+    normalized = normalized.replace(/[。.!；;，,]+$/u, "").trim();
+    normalized = stripMarkdownLineDecorations(normalized);
+    return normalized;
+}
+function stripMarkdownLineDecorations(line) {
+    let trimmed = line.trim();
+    trimmed = trimmed.replace(/^(?:>\s*)+/, "");
+    trimmed = trimmed.replace(/^(?:[-*+]\s+|\d+[.)]\s+)/, "");
+    const emphasized = trimmed.match(/^(\*{1,3}|_{1,3}|`{1,3})\s*(.*?)\s*\1$/);
+    trimmed = (emphasized?.[2] ?? trimmed).trim();
+    return trimmed;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
  * Validate the writer's observed diff against its declared write boundary.