@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

package/dist/worker/console/chat/session-store.js

@@ -17,6 +17,7 @@ import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
 import { projectOperationForChat } from "./chat-event-store.js";
 import { scrubSecrets } from "./explore-tools.js";
+import { hashDeferredTurnPayload, parseDeferredTurn, } from "./deferred-turn.js";
 const CHAT_TITLE_MAX_CHARS = 80;
 /** Safe, one-line bounded title used for placeholders and model output. */
 export function cleanChatTitle(value) {
@@ -53,6 +54,7 @@ export class ChatSessionStore {
         const raw = await readJsonIfExists(recordPath(this.appData, sessionId));
         if (!raw || raw.sessionId !== sessionId)
             return undefined;
+        const deferredTurn = parseDeferredTurn(raw.deferredTurn);
         return {
             schemaVersion: 2,
             sessionId,
@@ -67,6 +69,7 @@ export class ChatSessionStore {
             ...(typeof raw.modelProvider === "string" ? { modelProvider: raw.modelProvider } : {}),
             ...(typeof raw.modelId === "string" ? { modelId: raw.modelId } : {}),
             ...(typeof raw.thinkingLevel === "string" ? { thinkingLevel: raw.thinkingLevel } : {}),
+            ...(deferredTurn ? { deferredTurn } : {}),
             messages: Array.isArray(raw.messages) ? raw.messages : [],
             toolInvocations: Array.isArray(raw.toolInvocations) ? raw.toolInvocations : [],
         };
@@ -147,6 +150,7 @@ export class ChatSessionStore {
                 ...(input.targetSessionFile ? { sessionFile: input.targetSessionFile } : { sessionFile: undefined }),
                 createdAt: now,
                 updatedAt: now,
+                deferredTurn: undefined,
                 messages: structuredClone(source.messages),
                 toolInvocations: structuredClone(source.toolInvocations),
             };
@@ -216,6 +220,146 @@ export class ChatSessionStore {
             return true;
         });
     }
+    async putDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return { ok: false, code: "NOT_FOUND" };
+            const clientRequestId = input.clientRequestId.trim();
+            const blockedByTurnId = input.blockedByTurnId.trim();
+            const text = input.text.trim() || (input.images.length > 0 ? "请查看附件图片。" : "");
+            if (!clientRequestId || !blockedByTurnId || !text) {
+                return { ok: false, code: "INVALID_INPUT" };
+            }
+            const payloadHash = hashDeferredTurnPayload({ text, images: input.images });
+            const existing = record.deferredTurn;
+            if (existing) {
+                if (existing.clientRequestId === clientRequestId) {
+                    if (existing.payloadHash !== payloadHash) {
+                        return {
+                            ok: false,
+                            code: "REQUEST_ID_REUSE_CONFLICT",
+                            deferredTurn: existing,
+                        };
+                    }
+                    return { ok: true, deferredTurn: existing, idempotent: true };
+                }
+                if (existing.state !== "queued") {
+                    return {
+                        ok: false,
+                        code: "NOT_REPLACEABLE",
+                        deferredTurn: existing,
+                    };
+                }
+                if (input.expectedRevision !== existing.revision) {
+                    return {
+                        ok: false,
+                        code: "REVISION_CONFLICT",
+                        deferredTurn: existing,
+                    };
+                }
+            }
+            else if (input.expectedRevision !== undefined &&
+                input.expectedRevision !== 0) {
+                return { ok: false, code: "REVISION_CONFLICT" };
+            }
+            const now = new Date().toISOString();
+            const deferredTurn = {
+                schemaVersion: 1,
+                revision: (existing?.revision ?? 0) + 1,
+                clientRequestId,
+                payloadHash,
+                blockedByTurnId,
+                text,
+                images: structuredClone(input.images),
+                state: "queued",
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+            };
+            record.deferredTurn = deferredTurn;
+            record.updatedAt = now;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn, idempotent: false };
+        });
+    }
+    async claimDeferredTurn(sessionId, expectedRevision) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing)
+                return { ok: false, code: "NOT_FOUND" };
+            if (existing.revision !== expectedRevision) {
+                return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
+            }
+            if (existing.state !== "queued") {
+                return { ok: false, code: "NOT_CLAIMABLE", deferredTurn: existing };
+            }
+            const next = {
+                ...existing,
+                revision: existing.revision + 1,
+                state: "dispatching",
+                updatedAt: new Date().toISOString(),
+            };
+            record.deferredTurn = next;
+            record.updatedAt = next.updatedAt;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn: next };
+        });
+    }
+    async transitionDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.revision !== input.expectedRevision)
+                return undefined;
+            const next = {
+                ...existing,
+                revision: existing.revision + 1,
+                state: input.state,
+                updatedAt: new Date().toISOString(),
+                ...(input.acceptedTurnId ? { acceptedTurnId: input.acceptedTurnId } : {}),
+                ...(input.lastError ? { lastError: input.lastError } : {}),
+            };
+            if (!input.lastError)
+                delete next.lastError;
+            record.deferredTurn = next;
+            record.updatedAt = next.updatedAt;
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return next;
+        });
+    }
+    async deleteDeferredTurn(sessionId, input) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.clientRequestId !== input.clientRequestId) {
+                return { ok: false, code: "NOT_FOUND" };
+            }
+            if (existing.state !== "queued" && existing.state !== "failed") {
+                return { ok: false, code: "NOT_CANCELLABLE", deferredTurn: existing };
+            }
+            if (existing.revision !== input.expectedRevision) {
+                return { ok: false, code: "REVISION_CONFLICT", deferredTurn: existing };
+            }
+            delete record.deferredTurn;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { ok: true, deferredTurn: existing };
+        });
+    }
+    async clearDeferredTurnForRequest(sessionId, clientRequestId) {
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            const existing = record?.deferredTurn;
+            if (!record || !existing || existing.clientRequestId !== clientRequestId) {
+                return undefined;
+            }
+            delete record.deferredTurn;
+            record.updatedAt = new Date().toISOString();
+            await writeSecureJson(recordPath(this.appData, sessionId), record);
+            return { deferredTurn: existing, clearedRevision: existing.revision + 1 };
+        });
+    }
     async appendMessage(sessionId, message) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -340,10 +484,10 @@ export async function runChatTurn(options) {
             },
         };
     }
-    await store.appendMessage(sessionId, { role: "user", text });
+    const userMessage = await store.appendMessage(sessionId, { role: "user", text });
     const afterUserMessage = await store.get(sessionId);
     if (afterUserMessage)
-        await options.onUserMessagePersisted?.(afterUserMessage);
+        await options.onUserMessagePersisted?.(afterUserMessage, userMessage);
     let turnError;
     // Collect persistence promises so runChatTurn does not resolve before the
     // chat history / audit trail is durably written (also makes the outcome

package/dist/worker/console/chat/turn-process.js

@@ -216,9 +216,6 @@ export function buildTurnProcessGroups(input) {
             current = startGroup(`assistant-${message.id}`);
         current.assistants.push(message);
     }
-    if (groups.length === 0 && input.toolCalls.length > 0) {
-        groups.push(emptyGroup("orphan-tools"));
-    }
     const assigned = new Set();
     const assistantToGroup = new Map();
     for (const group of groups) {
@@ -265,17 +262,12 @@ export function buildTurnProcessGroups(input) {
             const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
             return tool.createdAt >= start && tool.createdAt < end;
         });
+        // Time window only. Never dump unmatched tools onto the latest group:
+        // that is how a previous turn's bash cards jump under a new prompt.
         if (windowGroup) {
             windowGroup.tools.push(tool);
             assigned.add(tool.id);
         }
-        else {
-            const lastGroup = groups.at(-1);
-            if (lastGroup) {
-                lastGroup.tools.push(tool);
-                assigned.add(tool.id);
-            }
-        }
     }
     for (const group of groups) {
         group.tools.sort((a, b) => {
@@ -292,6 +284,14 @@ export function buildTurnProcessGroups(input) {
     }
     return groups;
 }
+/** Keep the most recent complete turns. Slice groups, never raw messages. */
+export function selectRecentTurnGroups(groups, limit) {
+    if (limit <= 0)
+        return [];
+    if (groups.length <= limit)
+        return [...groups];
+    return groups.slice(-limit);
+}
 export function processGroupSummary(tools, options) {
     const count = tools.length;
     const thinkingCount = options?.thinkingCount ?? 0;

package/dist/worker/console/console-handoff.js

@@ -0,0 +1,82 @@
+import { createHash, randomBytes } from "node:crypto";
+const HANDOFF_ENV = "LOOP_CONSOLE_HANDOFF_V1";
+const HANDOFF_HASH_ENV = "LOOP_CONSOLE_HANDOFF_SHA256";
+function canonicalJson(value) {
+    return JSON.stringify(value);
+}
+function digest(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+export function createConsoleHandoff(input) {
+    const handoff = {
+        schemaVersion: 1,
+        consoleInstanceId: `console_${randomBytes(16).toString("hex")}`,
+        ...input,
+    };
+    const encoded = canonicalJson(handoff);
+    return {
+        handoff,
+        env: {
+            [HANDOFF_ENV]: Buffer.from(encoded, "utf8").toString("base64url"),
+            [HANDOFF_HASH_ENV]: digest(encoded),
+        },
+    };
+}
+/** Parse an exact, hash-bound handoff contract inherited by the replacement process. */
+export function readConsoleHandoff(env) {
+    const encoded = env[HANDOFF_ENV];
+    const expectedDigest = env[HANDOFF_HASH_ENV];
+    if (!encoded && !expectedDigest)
+        return undefined;
+    if (!encoded || !expectedDigest)
+        throw new Error("console handoff contract is incomplete");
+    let raw;
+    try {
+        raw = Buffer.from(encoded, "base64url").toString("utf8");
+    }
+    catch {
+        throw new Error("console handoff payload is invalid");
+    }
+    if (digest(raw) !== expectedDigest)
+        throw new Error("console handoff hash mismatch");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("console handoff payload is not JSON");
+    }
+    const value = parsed;
+    if (value.schemaVersion !== 1 ||
+        !Number.isInteger(value.oldPid) ||
+        value.oldPid <= 0 ||
+        typeof value.repoRoot !== "string" ||
+        typeof value.host !== "string" ||
+        !Number.isInteger(value.port) ||
+        value.port < 0 ||
+        typeof value.targetVersion !== "string" ||
+        typeof value.consoleInstanceId !== "string") {
+        throw new Error("console handoff payload has invalid fields");
+    }
+    return value;
+}
+export async function waitForOldConsoleExit(oldPid, options = {}) {
+    const isAlive = options.isAlive ?? ((pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const started = Date.now();
+    while (isAlive(oldPid)) {
+        if (Date.now() - started >= timeoutMs) {
+            throw new Error(`old Console PID ${oldPid} did not exit before handoff timeout`);
+        }
+        await sleep(50);
+    }
+}

package/dist/worker/console/console-update-and-init.js

@@ -0,0 +1,115 @@
+import semver from "semver";
+function notRunMaintenance(channel) {
+    return {
+        package: { status: "failed", channel },
+        initialization: { status: "not-run", pendingPaths: [] },
+        handoff: { status: "not-needed" },
+    };
+}
+function failed(code, message, maintenance = notRunMaintenance("latest")) {
+    return {
+        state: "failed",
+        maintenance,
+        errorCode: code,
+        errorMessage: message,
+    };
+}
+/**
+ * Deterministic core for the Console-only maintenance operation. It contains
+ * no HTTP, model, or process-global calls, which makes the safety ordering
+ * independently testable and keeps the caller responsible for privileged
+ * handoff mechanics.
+ */
+export async function performConsoleUpdateAndInit(deps, channel = "latest") {
+    const preflight = await deps.preflight();
+    if (!preflight.ok) {
+        return failed(preflight.code, preflight.message, notRunMaintenance(channel));
+    }
+    const target = await deps.resolveVersion(channel);
+    if (!target.ok) {
+        return failed("REGISTRY_UNAVAILABLE", `could not verify npm ${channel} (${target.reason})`, notRunMaintenance(channel));
+    }
+    if (!semver.valid(deps.currentVersion) || !semver.valid(target.version)) {
+        return failed("INVALID_VERSION", "installed or selected channel version is invalid", notRunMaintenance(channel));
+    }
+    if (channel === "latest" && semver.lt(target.version, deps.currentVersion)) {
+        return failed("REGISTRY_VERSION_REGRESSION", `npm latest ${target.version} is older than installed ${deps.currentVersion}`, notRunMaintenance(channel));
+    }
+    const release = await deps.acquireLock();
+    if (!release) {
+        return failed("UPDATE_LOCKED", "another loop-agent update is already in progress for this user", notRunMaintenance(channel));
+    }
+    try {
+        const packageChanged = target.version !== deps.currentVersion;
+        const maintenance = {
+            package: {
+                status: packageChanged ? "updated" : "current",
+                channel,
+                targetVersion: target.version,
+            },
+            initialization: { status: "not-run", pendingPaths: [] },
+            handoff: { status: "not-needed" },
+        };
+        if (packageChanged) {
+            const proof = await deps.canAutoInstall();
+            if (!proof.ok) {
+                maintenance.package = { status: "failed", channel, reason: proof.reason };
+                return failed("GLOBAL_INSTALL_UNPROVEN", proof.reason, maintenance);
+            }
+            const installed = await deps.installExact(target.version, channel);
+            if (!installed.ok) {
+                maintenance.package = { status: "failed", channel, reason: installed.reason };
+                return failed("INSTALL_FAILED", installed.reason, maintenance);
+            }
+            const verified = await deps.verifyInstalled(target.version);
+            if (!verified.ok) {
+                maintenance.package = { status: "failed", channel, reason: verified.reason };
+                return failed("INSTALL_VERIFICATION_FAILED", verified.reason, maintenance);
+            }
+        }
+        const initResult = await deps.applySafeInit();
+        maintenance.initialization = initResult.ok
+            ? { status: "clean", pendingPaths: initResult.pendingPaths }
+            : {
+                status: "needs-reconcile",
+                pendingPaths: initResult.pendingPaths,
+                message: initResult.message,
+            };
+        if (!packageChanged) {
+            return {
+                state: initResult.ok ? "succeeded" : "needs-reconcile",
+                maintenance,
+                ...(initResult.ok
+                    ? {}
+                    : {
+                        errorCode: "INIT_NEEDS_RECONCILE",
+                        errorMessage: initResult.message,
+                    }),
+            };
+        }
+        const handoff = await deps.requestHandoff({
+            targetVersion: target.version,
+            initResult,
+        });
+        if (!handoff.ok) {
+            maintenance.handoff = {
+                status: "needs-reconcile",
+                message: handoff.message,
+            };
+            return {
+                state: "needs-reconcile",
+                maintenance,
+                errorCode: "HANDOFF_FAILED",
+                errorMessage: handoff.message,
+            };
+        }
+        maintenance.handoff = {
+            status: "requested",
+            consoleInstanceId: handoff.consoleInstanceId,
+        };
+        return { state: "restarting", maintenance };
+    }
+    finally {
+        await release().catch(() => undefined);
+    }
+}

package/dist/worker/console/console-update-runtime.js

@@ -0,0 +1,84 @@
+import os from "node:os";
+import { readPackageVersion } from "../../shared/package-metadata.js";
+import { createNpmUpdateClient } from "../../shared/update/npm-client.js";
+import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
+import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
+import { performConsoleUpdateAndInit, } from "./console-update-and-init.js";
+import { TERMINAL_OPERATION_STATES } from "./operation-store.js";
+export function createConsoleUpdateExecutor(input) {
+    return async (channel) => {
+        const currentVersion = readPackageVersion(input.packageRoot);
+        if (!currentVersion) {
+            return {
+                state: "failed",
+                errorCode: "PACKAGE_IDENTITY_UNAVAILABLE",
+                errorMessage: "Console package version cannot be proven",
+                maintenance: {
+                    package: { status: "failed", channel },
+                    initialization: { status: "not-run", pendingPaths: [] },
+                    handoff: { status: "not-needed" },
+                },
+            };
+        }
+        const npm = createNpmUpdateClient({
+            currentVersion,
+            packageRoot: input.packageRoot,
+            cwd: input.repoRoot,
+        });
+        return performConsoleUpdateAndInit({
+            currentVersion,
+            preflight: async () => {
+                const [activity, operations] = await Promise.all([
+                    readInitRuntimeActivity(input.repoRoot),
+                    input.operations.list(),
+                ]);
+                if (activity.workerProjectionError ||
+                    activity.activeDagRunIds.length > 0 ||
+                    activity.activeWorkerTasks > 0 ||
+                    activity.activeWorkerBatches > 0) {
+                    return {
+                        ok: false,
+                        code: "ACTIVE_RUNTIME",
+                        message: "active DAG/Worker runtime exists or cannot be proven inactive",
+                    };
+                }
+                if (input.activeChatTurnCount() > 0) {
+                    return {
+                        ok: false,
+                        code: "CHAT_TURN_ACTIVE",
+                        message: "an Operator Chat turn is active",
+                    };
+                }
+                const liveOtherOperation = operations.some((operation) => operation.action !== "consoleUpdateAndInit" &&
+                    !TERMINAL_OPERATION_STATES.has(operation.state));
+                return liveOtherOperation
+                    ? {
+                        ok: false,
+                        code: "OPERATION_ACTIVE",
+                        message: "another Console operation is active",
+                    }
+                    : { ok: true };
+            },
+            acquireLock: () => acquireUpdateLock(updateLockPath(os.homedir())),
+            resolveVersion: (selectedChannel) => npm.distTagVersionCheck(selectedChannel),
+            canAutoInstall: () => npm.canAutoInstall(),
+            installExact: (version, selectedChannel) => npm.installExact(version, selectedChannel),
+            verifyInstalled: (version) => npm.verifyInstalled(version),
+            applySafeInit: async () => {
+                const result = await input.client.runExternal("loop-agent", ["init", "update", "--apply-safe", "--repo-root", input.repoRoot], {
+                    cwd: input.repoRoot,
+                    artifactName: "console-update-safe-init",
+                    timeoutMs: 120_000,
+                });
+                return result.ok
+                    ? { ok: true, pendingPaths: [] }
+                    : {
+                        ok: false,
+                        message: result.stderr || result.stdout || "safe initialization failed",
+                        pendingPaths: [],
+                    };
+            },
+            requestHandoff: async ({ targetVersion }) => input.requestHandoff(targetVersion),
+        }, channel);
+    };
+}

package/dist/worker/console/dag-execution-receipt.js

@@ -35,6 +35,32 @@ import { hashDagBytes, } from "./dag-confirmation.js";
  * framework invocations that don't embed the word "verify".
  */
 export const STRUCTURED_VERIFICATION_COMMAND_RE = /\b(vitest|jest|playwright|cypress|pytest|py-test|go\s+test|cargo\s+test|npm\s+run\s+(lint|typecheck|test|verify)|npm\s+(test|run\s+test)|check-repo\.sh|loop-agent-standard-verify)\b/i;
+/**
+ * Deterministic shell preset keys whose executors are themselves structured
+ * verification/gate materializers: their shell.commands[] is empty and the
+ * preset alone carries the verification authority (hash-bound artifact
+ * gates, evidence validators, report finalize). Mirrors the named-shell
+ * handler registry in shell-executor.ts so preset-only workflows
+ * (frontend-test finalize/reports, backend-test pipeline, verify-evidence
+ * gates) pass the G2 autonomous execution gate without depending on node-id
+ * naming conventions.
+ */
+export const STRUCTURED_VERIFICATION_SHELL_PRESETS = new Set([
+    "frontendTestCaseChecklist",
+    "frontendTestCaseManifest",
+    "frontendTestEvidenceValidation",
+    "frontendTestResultFinalize",
+    "frontendTestL5Report",
+    "frontendTestHtmlReport",
+    "frontendTestReports",
+    "backendTestPipeline",
+    "verifyEvidence",
+    "repairArtifactGate",
+    "jacocoCoverage",
+    "requirementCoverageGate",
+    "jsonArtifactGate",
+    "verdictGate",
+]);
 export const DEFAULT_EXECUTION_RECEIPT_TTL_MS = 30 * 60 * 1000;
 function normalizePathEntry(entry) {
     return entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -157,6 +183,13 @@ export function deriveEligibilityFactsFromDagSpec(input) {
             return false;
         if (/verify|verification/i.test(task.id ?? ""))
             return true;
+        // Preset-only verification shells (empty commands[]): the preset key is
+        // the verification authority (frontend-test finalize, backend-test
+        // pipeline, evidence/artifact gates).
+        const shellRecord = task.shell;
+        const hasVerificationPreset = Object.keys(shellRecord).some((key) => STRUCTURED_VERIFICATION_SHELL_PRESETS.has(key));
+        if (hasVerificationPreset)
+            return true;
         const commands = stringList(task.shell.commands);
         return commands.some((command) => STRUCTURED_VERIFICATION_COMMAND_RE.test(command));
     });

package/dist/worker/console/draft-store.js

@@ -1,5 +1,51 @@
 import path from "node:path";
 import { readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
+/**
+ * 从任意上游载荷安全投影 ledger 摘要（未知形状丢弃，绝不抛错、绝不信任字段外的数据）。
+ * 供 DraftStore / prd-intake-bridge 把 prepare/advance 结果中的 ledger 摘要带入草稿。
+ */
+export function summarizeLedgerPayload(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    if (record.present !== true)
+        return undefined;
+    const num = (key) => {
+        const raw = record[key];
+        return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+    };
+    const gateRaw = record.gateStatus;
+    const gateStatus = gateRaw === "pass" || gateRaw === "fail" || gateRaw === "unknown"
+        ? gateRaw
+        : "unknown";
+    const failureCode = typeof record.failureCode === "string" && record.failureCode
+        ? record.failureCode
+        : null;
+    const rawExclusions = Array.isArray(record.exclusions) ? record.exclusions : [];
+    const exclusions = [];
+    for (const item of rawExclusions) {
+        if (!item || typeof item !== "object")
+            continue;
+        const entry = item;
+        const fragmentId = typeof entry.fragmentId === "string" ? entry.fragmentId : "";
+        const reason = typeof entry.reason === "string" ? entry.reason : "";
+        if (!fragmentId)
+            continue;
+        exclusions.push({ fragmentId, reason });
+    }
+    return {
+        present: true,
+        fragmentCount: num("fragmentCount"),
+        canonicalRequirementCount: num("canonicalRequirementCount"),
+        contextOnlyCount: num("contextOnlyCount"),
+        duplicateCount: num("duplicateCount"),
+        unresolvedCount: num("unresolvedCount"),
+        conflictCount: num("conflictCount"),
+        gateStatus,
+        failureCode,
+        exclusions,
+    };
+}
 function draftPath(appData, taskId) {
     const safe = taskId.replace(/[^a-zA-Z0-9._-]+/g, "_");
     return path.join(appData.drafts, `${safe}.json`);
@@ -86,6 +132,9 @@ export function toCanonicalDraftForCli(draft) {
     if (draft.interviewAssessmentRef) {
         canonical.interviewAssessmentRef = draft.interviewAssessmentRef;
     }
+    // AC-BLOCK-002：canonical draft JSON 绝不携带 ledgerSummary 字段（strict
+    // taskContractDraftSchema 拒绝未知键）。摘要仅留在 prd-intake-bridge 响应与
+    // console-types 的 LedgerSummaryView（UI 视图模型），不进入持久化 draft。
     return canonical;
 }
 export class DraftStore {

package/dist/worker/console/inspect-split.js

@@ -80,3 +80,21 @@ export function pickInspectNode(nodes, preferredNodeId) {
     });
     return running ?? nodes[0];
 }
+/**
+ * Terminal DagRun effective/status values (mirrors observe read-model
+ * TERMINAL_RUN_STATUSES). A run that reached one of these states no longer
+ * needs live polling in the console split panel.
+ */
+export const TERMINAL_DAG_RUN_STATUSES = new Set([
+    "finished",
+    "failed",
+    "partial_failed",
+    "superseded",
+    "abandoned",
+]);
+export function isTerminalDagRun(dag) {
+    if (!dag)
+        return false;
+    const status = String(dag.effectiveStatus ?? dag.status ?? "").toLowerCase();
+    return TERMINAL_DAG_RUN_STATUSES.has(status);
+}