@tea-agent/loop-agent 0.13.0-beta.0 → 0.14.0

package/dist/commands/init.js

@@ -679,9 +679,34 @@ function buildManagedAgentsBlock(input) {
         "- 保留无关的用户改动，不要回退自己没有做的修改。",
         "- 委托模型写入前，必须把写入边界写成结构化 `task.json.allowedPaths` / `task.json.forbiddenPaths`，再审查生成 DAG 的 writer `writeSet`；不要只依赖 `source/执行约束.md` 的自然语言约束。",
         "",
+        "### 自然语言入口路由",
+        "",
+        "用户用中文表达意图时，按以下三类入口路由；只读与写入必须严格区分。",
+        "",
+        "| 用户表达 | 入口 | 执行动作 |",
+        "|---|---|---|",
+        "| loop-agent 初始化 / loop agent 初始化 / loop agent初始化 / 初始化 loop-agent | 初始化 | 完成确定性初始化闭环 |",
+        "| 初始化更新校验 / 检查初始化更新 / loop-agent 初始化更新校验 / loop agent初始化更新校验 | 更新校验 | 只读报告，不写入 |",
+        "| 初始化安全更新 / 应用初始化更新 / loop-agent 初始化安全更新 / loop agent初始化安全更新 | 安全更新 | check-update 后只执行确定性安全动作 |",
+        "",
+        "**更新校验（只读）**：用户说“初始化更新校验”“检查初始化更新”时，只读执行下面命令，汇报 deterministic actions、model merge、human decisions 和 next steps。**这一步不得自动执行 `apply-safe` 或模型合并。**",
+        "",
+        "```bash",
+        "loop-agent init check-update --repo-root . --markdown",
+        "```",
+        "",
+        "**安全更新（写入型）**：用户明确说“初始化安全更新”“应用初始化更新”时，先 check-update，再执行确定性安全动作；surface 缺失时先 bootstrap，存在 human decisions 时停下等用户决策。model merge 任务必须带 allowed/forbidden paths，且不得自动决策。安全更新完成后必须复查 `loop-agent init doctor --repo-root .`、`loop-agent inspect --repo-root .`、`loop-agent docs audit --repo-root .` 与目标项目治理检查（如 `bash scripts/check-repo.sh`）。",
+        "",
+        "```bash",
+        "loop-agent init check-update --repo-root . --markdown",
+        "loop-agent init update --repo-root . --apply-safe",
+        "```",
+        "",
+        "仅当 check-update 报告 surface 缺失时才执行 `loop-agent init update --repo-root . --bootstrap-surface`。",
+        "",
         "### 初始化闭环",
         "",
-        `当用户要求在本仓库初始化 loop-agent，或发现 \`README.md\` / \`${input.governanceRoot}/verification-matrix.md\` 仍停留在通用初始化状态时，模型应在同一轮工作中完成初始化闭环，不要把补全文档和验证矩阵留给用户交互。`,
+        `当用户要求初始化 loop-agent（“初始化 loop-agent”“loop agent 初始化”“loop agent初始化”“loop-agent 初始化”），或发现 \`README.md\` / \`${input.governanceRoot}/verification-matrix.md\` 仍停留在通用初始化状态时，模型应在同一轮工作中完成初始化闭环，不要把补全文档和验证矩阵留给用户交互。`,
         "",
         "标准流程：",
         "",
@@ -731,6 +756,22 @@ function buildManagedAgentsBlock(input) {
         "",
         "执行 DAG 前必须审查 profile routing、governance profile、writer 的 `writeSet`、`allowedPaths`、`forbiddenPaths`、shell verification 和 decision gate mode。不要执行占位或过宽的写入范围。",
         "",
+        "### 任务类型路由（taskKind）",
+        "",
+        "- 用户明确提出后端测试、接口/API 测试、pytest，或语境明确为后端的自动化测试时，必须把 `.harness/tasks/<task-id>/task.json` 的 `taskKind` 设置为 `\"backend-test\"`，不得保留默认 `standard`。",
+        "- `backend-test` 是 `taskKind`，不是 `--profile` 的可选值；运行 `dag run-task` 时继续使用 `--profile auto`，也可按需显式选择 `minimal` / `standard` / `reviewed` / `supervised`，不要把业务模板名当作 profile。",
+        "- 仅出现“自动化测试”且无法判断前后端时，先阅读任务源与目标项目技术栈再决定，禁止无条件路由到 `backend-test`。",
+        "",
+        "### 运行看板（只读）",
+        "",
+        "启动本地只读运行看板：",
+        "",
+        "```bash",
+        "agent-worker observe serve --repo . --port 8787",
+        "```",
+        "",
+        "浏览器打开 `http://127.0.0.1:8787/`。看板只读，默认只绑定本机 `127.0.0.1`；不要直接暴露到公开网络。",
+        "",
         "### DAG 诊断与收口",
         "",
         "执行后优先使用 `loop-agent dag report --run-id <run-id> --markdown` 读取 run facts；失败或 paused run 使用 `loop-agent dag doctor --run-id <run-id> --markdown` 诊断。失败 DAG run 不应写成成功 closeout，应使用 `loop-agent dag closeout-draft --run-id <run-id>` 生成 failure handoff，保留 what failed、evidence、classification、recommended follow-up、safe retry conditions 和 human decision needed。",
@@ -822,6 +863,9 @@ export function buildManagedGitignoreBlock() {
         ".harness/task-pool/*",
         ".task-pool/",
         "",
+        "# repo-local skill dependencies installed inside projected skills",
+        ".agents/skills/*/node_modules/",
+        "",
         "# multi-worktree parallel mode",
         ".worktrees/",
         GITIGNORE_BLOCK_END,
@@ -1242,7 +1286,7 @@ async function buildCurrentSurfaceState(input) {
             repoRoot: input.repoRoot,
             projectName: input.projectName,
             governanceRoot: input.governanceRoot,
-            entry,
+            entry: manifestEntry,
         });
         const sourceSha256 = desired.content === undefined ? undefined : sha256Text(desired.content);
         const base = {
@@ -1318,6 +1362,19 @@ async function buildCurrentSurfaceState(input) {
 }
 async function writeInitSurfaceState(input) {
     const state = await buildCurrentSurfaceState(input);
+    if (input.stateKind === "recorded" && input.preserveOwnershipFrom) {
+        for (const [pathName, file] of Object.entries(state.files)) {
+            if (file.relationship !== "local-existing-unknown")
+                continue;
+            const priorHash = input.preserveOwnershipFrom.files[pathName]?.currentSha256;
+            if (priorHash !== undefined) {
+                file.currentSha256 = priorHash;
+            }
+            else {
+                delete file.currentSha256;
+            }
+        }
+    }
     const target = path.join(input.repoRoot, INIT_SURFACE_STATE_PATH);
     await mkdir(path.dirname(target), { recursive: true });
     await writeFile(target, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
@@ -1867,9 +1924,28 @@ function buildTargetFeatureWorkflow(input) {
         "",
         "- `taskKind: \"frontend-implementation\"` explicitly selects the frontend DAG for compatibility or intentional override. Optional `frontendMock` config sets `policy: auto|required|disabled`, an existing `serviceRoot`, and generation-time-frozen `verifyCommands`; an unsafe or incomplete explicit required contract produces an assessment-only DAG with no writer, while a complete required contract adds Mock-specific verification only when trusted commands exist. Auto API tasks without a native service may use an existing browser interception harness or reversible request adapter, then continue through static and behavior verification.",
         "- `taskKind: \"backend-test\"` selects the dedicated backend test DAG. Its Pi nodes analyze requirements, generate and review backend cases, generate pytest, and retrospect on results; shell gate/execution nodes enforce the review verdict and run the target project's pytest. The backend test templates (`backend-test-dag.json` and the `backend-test-dag.*.prompt.md` files) ship inside the loop-agent package as static references and are projected to target projects under the governance `templates/` directory.",
+        "- `taskKind: \"knowledge-sync\"` selects the Feature-scoped test-knowledge write-back DAG (collect → draft → validate → apply → pointer). Bind `featureId` in `task.json` (or hardConstraints / requirement text). It writes only under `features/<featureId>/…` after final verification evidence exists.",
+        "- `taskKind: \"knowledge-graph-bootstrap\"` selects the business knowledge-graph bootstrap DAG (preflight → inventory → propose → validate → review → gate → promote → materialize). AI writes only `knowledge/bootstrap/staging/**`; promote is merge-new-only.",
         "- `taskKind: \"frontend-test\"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case's token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headed <base-url>`; the generic playwright-cli skill is unchanged.",
         "- Only eligible read-only Pi nodes (planner, scout, reviewer, verifier, closeout with no write-capable tool profile) receive the conservative automatic retry policy. Supervisor, implementer, writer, docs-only, dynamic, shell, static, and decision-gate nodes are not retried automatically. Eligible nodes cannot write repository files; the controller only records immutable attempt evidence under `.harness/dag-runs/<state>/<run-id>/<node-id>/attempt-<n>.json`.",
         "",
+        "Use the package-backed public knowledge CLI for graph operations. Do not require target projects to run package-only kb runtime scripts:",
+        "",
+        "```bash",
+        "loop-agent knowledge graph-init --product-name <name>",
+        "# edit knowledge/bootstrap/scope.yaml, then:",
+        "loop-agent dag run-task <task-id>   # taskKind: knowledge-graph-bootstrap",
+        "loop-agent knowledge query --mode by_feature --feature F-2026-004 --json",
+        "loop-agent knowledge query --mode by_id --id SVC-order --json",
+        "loop-agent knowledge query --mode search --text \"keyword\" --json",
+        "loop-agent knowledge graph-incremental-prepare --feature F-2026-004 --service <service>",
+        "# review the prepared scope/staging; for a manual reviewed promotion:",
+        "loop-agent knowledge graph-promote",
+        "loop-agent knowledge graph-materialize",
+        "```",
+        "",
+        "Daily Feature test-knowledge write-back still uses `taskKind: \"knowledge-sync\"` with a bound `featureId`, separate from graph bootstrap/incremental entry points.",
+        "",
         "## Verification",
         "",
         `Use \`${input.governanceRoot}/verification-matrix.md\` to choose the narrowest command that proves the claim.`,
@@ -2563,38 +2639,31 @@ export async function applyInitUpdate(input) {
         });
     }
     if (input.applySafe) {
+        const existingSurface = await readExistingSurfaceState(repoRoot);
+        // Preserve source strength: recorded stays recorded so unchanged owned files
+        // remain deterministic refresh candidates; bootstrap/inferred stays inferred.
+        const preservedStateKind = existingSurface?.stateKind === "recorded" ? "recorded" : "inferred-baseline";
         const report = await checkInitUpdate({ repoRoot, projectName, governanceRoot });
         for (const action of report.deterministicActions) {
             if (action.type === "bootstrap-surface") {
                 skipped.push(action);
                 continue;
             }
-            if (action.type !== "strip-pi-requires-api-key" &&
-                action.type !== "add-harness-schema-ref" &&
-                action.type !== "refresh-owned-file" &&
-                action.type !== "migrate-harness-governance-root" &&
-                action.type !== "migrate-harness-model-fields" &&
-                action.type !== "migrate-owned-file" &&
-                action.type !== "remove-owned-file" &&
-                action.type !== "remove-empty-directory") {
-                const currentState = await buildCurrentSurfaceState({
-                    repoRoot,
-                    projectName,
-                    governanceRoot,
-                    stateKind: "inferred-baseline",
-                });
-                const relationship = currentState.files[action.path]?.relationship;
-                if (relationship === "local-existing-unknown") {
-                    skipped.push(action);
-                    continue;
-                }
-            }
+            // The report was produced immediately before this batch. Each action also
+            // performs its own target check; missing-file writes refuse existing paths,
+            // while managed blocks merge into the latest user-authored content.
             if (await applySafeAction({ repoRoot, projectName, governanceRoot, action }))
                 applied.push(action);
             else
                 skipped.push(action);
         }
-        await writeInitSurfaceState({ repoRoot, projectName, governanceRoot, stateKind: "inferred-baseline" });
+        await writeInitSurfaceState({
+            repoRoot,
+            projectName,
+            governanceRoot,
+            stateKind: preservedStateKind,
+            preserveOwnershipFrom: existingSurface,
+        });
     }
     return {
         applied,

package/dist/executors/pi-event-serializer.js

@@ -5,39 +5,61 @@
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function unifyToolPayloadFields(event) {
+    const out = { ...event };
+    const args = out.args ?? out.input ?? out.toolInput;
+    if (args !== undefined) {
+        out.args = args;
+        if (out.input === undefined)
+            out.input = args;
+    }
+    const result = out.result ?? out.toolResult;
+    if (result !== undefined) {
+        out.result = result;
+    }
+    return out;
+}
 /** Map SDK event shapes to the JSONL format emitted by `pi -p --mode json`. */
 export function normalizePiSessionEvent(event) {
     const type = typeof event.type === 'string' ? event.type : undefined;
     if (type === 'assistant_message' && isRecord(event.message)) {
-        return {
+        return unifyToolPayloadFields({
             type: 'turn_end',
             message: event.message,
             usage: event.usage,
-        };
+        });
     }
     if (type === 'tool_start' && typeof event.toolName === 'string') {
-        return {
+        const args = event.args ?? event.input ?? event.toolInput;
+        return unifyToolPayloadFields({
             type: 'tool_execution_start',
             toolName: event.toolName,
             toolCallId: event.toolCallId,
-            input: event.input,
-        };
+            input: args,
+            args,
+        });
     }
     if (type === 'tool_end' && typeof event.toolName === 'string') {
-        return {
+        const result = event.result ?? event.toolResult;
+        return unifyToolPayloadFields({
             type: 'tool_execution_end',
             toolName: event.toolName,
             toolCallId: event.toolCallId,
             isError: event.isError,
-        };
+            ...(result !== undefined ? { result } : {}),
+        });
     }
-    return event;
+    return unifyToolPayloadFields(event);
 }
 /** Serialize one SDK session event as a single JSONL line. */
-export function serializeSessionEvent(event) {
-    return JSON.stringify(normalizePiSessionEvent(event));
+export function serializeSessionEvent(event, options) {
+    const normalized = normalizePiSessionEvent(event);
+    if (typeof normalized.recordedAt !== 'string') {
+        normalized.recordedAt = options?.recordedAt ?? new Date().toISOString();
+    }
+    return JSON.stringify(normalized);
 }
 /** Serialize multiple events into newline-delimited JSON (no trailing newline). */
 export function serializeSessionEvents(events) {
-    return events.map(serializeSessionEvent).join('\n');
+    return events.map((event) => serializeSessionEvent(event)).join('\n');
 }

package/dist/executors/shell-executor.js

@@ -3,8 +3,14 @@ import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { writeDagNodeTextArtifact } from "../infrastructure/harness/artifact-store.js";
 import { truncateOutput } from "../shared/output-truncation.js";
-import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand } from "./shell-presets.js";
+import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand, } from "./shell-presets.js";
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
+import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
+import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
+import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout, runFrontendFailureAssessGate, runFrontendRepairContractGate, } from "../workflows/dag/frontend-repair.js";
+import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
+import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
+import { materializeBackendTestResultFromRunDir } from "../workflows/dag/backend-test-result-contract.js";
 import { pathsChangedDuringRun, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
@@ -24,7 +30,9 @@ function resolveBashExecutable() {
         path.join(process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)", "Git", "bin", "bash.exe"),
         path.join(process.env.LocalAppData ?? "", "Programs", "Git", "bin", "bash.exe"),
     ].filter(Boolean);
-    return candidates.find((candidate) => existsSync(candidate)) ?? envCandidate ?? "bash";
+    return (candidates.find((candidate) => existsSync(candidate)) ??
+        envCandidate ??
+        "bash");
 }
 function isWithinRoot(root, candidate) {
     const relative = path.relative(root, candidate);
@@ -48,7 +56,12 @@ export function resolveShellCommands(shell) {
     const fromRequirementCoverageGate = shell.requirementCoverageGate
         ? [buildRequirementCoverageGateShellCommand(shell.requirementCoverageGate)]
         : [];
-    return [...fromPreset, ...explicit, ...fromVerdictGate, ...fromRequirementCoverageGate];
+    return [
+        ...fromPreset,
+        ...explicit,
+        ...fromVerdictGate,
+        ...fromRequirementCoverageGate,
+    ];
 }
 async function readGitStatusPorcelain(cwd) {
     return new Promise((resolve, reject) => {
@@ -145,13 +158,16 @@ export async function executeShellCommand(input) {
             });
         });
         child.on("close", (code) => {
+            let failureCategory = "nonzero-exit";
+            if (timedOut) {
+                failureCategory = "timeout";
+            }
+            else if (code === 0) {
+                failureCategory = "success";
+            }
             finish({
                 exitCode: code,
-                failureCategory: timedOut
-                    ? "timeout"
-                    : code === 0
-                        ? "success"
-                        : "nonzero-exit",
+                failureCategory,
                 ok: code === 0 && !timedOut,
             });
         });
@@ -286,16 +302,164 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.jsonArtifactGate) {
         const started = Date.now();
         try {
-            const artifact = await materializeBackendTestAnalysisContract({
+            const gate = shell.jsonArtifactGate;
+            let artifact;
+            switch (gate.schemaId) {
+                case "backend-test-analysis-v1":
+                    artifact = await materializeBackendTestAnalysisContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                case "backend-test-execution-v1":
+                    artifact = await materializeBackendTestExecutionContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                    });
+                    break;
+                case "backend-test-result-v1":
+                    artifact = await materializeBackendTestResultFromRunDir({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                    });
+                    break;
+                case "backend-test-case-manifest-v1":
+                    artifact = await materializeBackendTestCaseManifest({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                case "frontend-implementation-contract-v1":
+                    artifact = await materializeFrontendImplementationContract({
+                        runDir: meta.runDir,
+                        fromNodeId: gate.fromNodeId,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
+                default:
+                    throw new Error(`unsupported jsonArtifactGate.schemaId: ${String(gate.schemaId)}`);
+            }
+            return {
+                ok: true,
+                stdout: `Structured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "backend-test-traceability-gate") {
+        const started = Date.now();
+        try {
+            const result = await runBackendTestTraceabilityGate({
                 runDir: meta.runDir,
-                fromNodeId: shell.jsonArtifactGate.fromNodeId,
-                artifactName: shell.jsonArtifactGate.artifactName,
-                outputDir: shell.jsonArtifactGate.outputDir,
-                sourceBinding: meta.spec.sourceBinding,
+                workspaceRoot: input.cwd,
             });
             return {
                 ok: true,
-                stdout: `Structured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+                stdout: formatTraceabilityGateStdout(result),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-verification-trace-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendVerificationTraceGate({
+                runDir: meta.runDir,
+                workspaceRoot: input.cwd,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendVerificationTraceStdout(result),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            const stderr = error instanceof Error ? error.message : String(error);
+            const recordNonZero = shell.nonZeroExitPolicy === "record";
+            return {
+                ok: recordNonZero,
+                stdout: recordNonZero
+                    ? "nonZeroExitPolicy=record failureCategory=invalid-output\n"
+                    : "",
+                stderr,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-failure-assess-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendFailureAssessGate({
+                runDir: meta.runDir,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendFailureAssessStdout(result),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: error instanceof Error ? error.message : String(error),
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
+    if (shell?.commands?.length === 1 &&
+        shell.commands[0] === "frontend-repair-contract-gate") {
+        const started = Date.now();
+        try {
+            const result = await runFrontendRepairContractGate({
+                runDir: meta.runDir,
+            });
+            return {
+                ok: true,
+                stdout: formatFrontendRepairContractStdout(result.assessment),
                 stderr: "",
                 failureCategory: "success",
                 durationMs: Date.now() - started,
@@ -362,7 +526,8 @@ export async function executeDagShellNode(input, meta) {
         }
     }
     const commandsOk = results.every((result) => result.ok);
-    const ok = commandsOk && writeGuardOk;
+    const recordNonZero = shell.nonZeroExitPolicy === "record";
+    const ok = (commandsOk || recordNonZero) && writeGuardOk;
     const firstFailure = results.find((result) => !result.ok);
     await writeDagNodeTextArtifact(meta.runDir, input.task.id, "result.summary.md", buildShellResultSummaryMarkdown({
         nodeId: input.task.id,
@@ -376,15 +541,29 @@ export async function executeDagShellNode(input, meta) {
     if (!writeGuardOk) {
         stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
     }
+    let failureCategory = "success";
+    if (!commandsOk) {
+        failureCategory = firstFailure?.failureCategory ?? "nonzero-exit";
+    }
+    else if (!writeGuardOk) {
+        failureCategory = "write-guard";
+    }
+    const commandResults = results.map((result) => ({
+        ok: result.ok,
+        exitCode: result.exitCode,
+        failureCategory: result.failureCategory,
+        command: result.command,
+    }));
+    const recordPrefix = recordNonZero && !commandsOk
+        ? `nonZeroExitPolicy=record exitCode=${firstFailure?.exitCode ?? "null"}\n`
+        : "";
     return {
         ok,
-        stdout: aggregate.stdout,
+        stdout: `${recordPrefix}${aggregate.stdout}`,
         stderr: stderrParts.filter(Boolean).join("\n\n"),
-        failureCategory: !commandsOk
-            ? (firstFailure?.failureCategory ?? "nonzero-exit")
-            : !writeGuardOk
-                ? "write-guard"
-                : "success",
+        failureCategory,
         durationMs: Date.now() - started,
+        // extra field consumed by node-execution if supported; also embedded in stdout marker
+        ...{ commandResults },
     };
 }

package/dist/infrastructure/evaluation/candidate-store.js

@@ -272,7 +272,11 @@ export async function registerCandidateManifest(input) {
         }
         catch (error) {
             const code = error.code;
-            if (code !== "EEXIST" && code !== "ENOTEMPTY")
+            const isCreateRace = code === "EEXIST" ||
+                code === "ENOTEMPTY" ||
+                (code === "EPERM" &&
+                    (await pathExists(candidateDir(repoRoot, manifest.candidateId))));
+            if (!isCreateRace)
                 throw error;
             await rm(stagingDir, { recursive: true, force: true });
             return readExistingRegistration(repoRoot, manifest, manifestPath, lifecyclePath);

package/dist/worker/observe/spec-evidence.js

@@ -87,7 +87,11 @@ function resolveToolName(event) {
     return (event.toolName ?? "").toLowerCase();
 }
 function eventTimestamp(event) {
-    return event.timestamp ?? event.at;
+    return event.timestamp ?? event.at ?? event.recordedAt;
+}
+function eventToolArgs(event) {
+    const args = event.args ?? event.toolInput ?? event.input;
+    return args && typeof args === "object" && !Array.isArray(args) ? args : {};
 }
 /**
  * Parse a tool input path to a repo-relative path.
@@ -150,7 +154,7 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
         const type = event.type;
         const toolName = resolveToolName(event);
         const toolCallId = event.toolCallId;
-        const toolInput = event.toolInput ?? event.input ?? {};
+        const toolInput = eventToolArgs(event);
         const ts = eventTimestamp(event);
         // Collect tool_execution_start events by toolCallId
         if (type === "tool_execution_start" && toolCallId) {
@@ -159,18 +163,21 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
         }
         // Process tool_execution_end events
         if (type === "tool_execution_end") {
+            const start = toolCallId ? startMap.get(toolCallId) : undefined;
+            const pairedInput = start?.input ?? toolInput;
             // Successful read calls: must have matching start event and no error
             if (toolName === "read") {
                 const isErrored = event.isError === true ||
                     event.toolResult?.error != null ||
-                    event.toolResult?.ok === false;
+                    event.toolResult?.ok === false ||
+                    event.result?.error != null ||
+                    event.result?.ok === false;
                 if (isErrored)
                     continue;
                 let filePath;
                 // Only paired read calls qualify: must have toolCallId, matching start
                 // with same toolName, and start must be a "read" tool.
                 if (toolCallId) {
-                    const start = startMap.get(toolCallId);
                     if (start && start.toolName === "read") {
                         const startInput = start.input ?? {};
                         filePath = typeof startInput.path === "string" ? startInput.path : undefined;
@@ -188,18 +195,20 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
             }
             // Search/scan tool calls (grep, find, ls, glob)
             if (["grep", "find", "ls", "glob"].includes(toolName)) {
-                const query = typeof toolInput.pattern === "string"
-                    ? toolInput.pattern
-                    : typeof toolInput.query === "string"
-                        ? toolInput.query
-                        : typeof toolInput.path === "string"
-                            ? toolInput.path
+                const query = typeof pairedInput.pattern === "string"
+                    ? pairedInput.pattern
+                    : typeof pairedInput.query === "string"
+                        ? pairedInput.query
+                        : typeof pairedInput.path === "string"
+                            ? pairedInput.path
                             : toolName;
                 searches.push({
                     tool: toolName,
                     query,
                     timestamp: ts,
                 });
+                if (toolCallId)
+                    startMap.delete(toolCallId);
             }
             // Knowledge base connector calls
             if (isKnowledgeBaseTool(toolName)) {

package/dist/worker/observe/static/app.js

@@ -29,6 +29,7 @@ import {
 	renderViewState,
 	mountViewState,
 	viewStateDescriptor,
+	uiState,
 } from "./state.js";
 import { sortPoolTasks, poolStatusCounts } from "./format-pool.js";
 import {
@@ -46,7 +47,7 @@ import {
 } from "./dag-model.js";
 
 import { renderFailures } from "./views/failures.js";
-import { startPoolPolling } from "./views/pool.js";
+import { startPoolView } from "./views/pool.js";
 import { startDashboardPolling } from "./views/dashboard.js";
 import { renderFeatureDetail } from "./views/feature.js";
 import { renderBatch } from "./views/batch.js";
@@ -126,7 +127,7 @@ function route() {
 	} else if (r.view === "failures") {
 		void renderFailures();
 	} else if (r.view === "pool") {
-		startPoolPolling();
+		startPoolView();
 	} else if (r.view === "task") {
 		startTaskPolling(r.featureId, r.taskId);
 	} else if (r.view === "feature") {
@@ -144,7 +145,7 @@ if (typeof window !== "undefined") {
 		if (r.view === "dashboard") startDashboardPolling();
 		if (r.view === "run") startRunPolling(r.workerRunId, false);
 		if (r.view === "dag") startDagPolling(r.dagRunId, false);
-		if (r.view === "pool") startPoolPolling();
+		if (r.view === "pool" && uiState.poolAutoRefresh) startPoolView();
 		if (r.view === "task") startTaskPolling(r.featureId, r.taskId);
 	});
 }