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

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/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/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);
+}

package/dist/worker/console/operation-run-facts.js

@@ -13,6 +13,7 @@
  * - A run summary is a projection only: it can never change the terminal
  *   operation state decided by the command envelope/exit facts.
  */
+import { normalizeDagFailureCategory } from "../../shared/dag-failure-category.js";
 import { scrubSecrets } from "./chat/explore-tools.js";
 const RUN_SUMMARY_MAX_NODES = 20;
 const RUN_SUMMARY_MAX_TEXT_CHARS = 600;
@@ -72,7 +73,13 @@ function safeNode(value) {
     const status = boundedRedactedText(rec.status, 100);
     if (!id || !status)
         return undefined;
-    return { id, status };
+    const rawCategory = boundedRedactedText(rec.failureCategory, 200);
+    if (!rawCategory)
+        return { id, status };
+    const category = normalizeDagFailureCategory(rawCategory, status);
+    if (category === "success" || category === "skipped")
+        return { id, status };
+    return { id, status, failureCategory: category };
 }
 /** Independent allowlist projection of a structured run summary. */
 export function safeRunSummaryForProjection(value) {
@@ -117,13 +124,22 @@ export function safeRunSummaryForProjection(value) {
         }
     }
     const verdict = boundedRedactedText(rec.verdict);
-    const failureCategory = boundedRedactedText(rec.failureCategory);
+    const rawFailureCategory = boundedRedactedText(rec.failureCategory, 200);
+    // Normalize the run-level category too (2026-08-23): raw codes like
+    // missing-api-key / nonzero-exit never matched the browser advice table.
+    const failureCategory = rawFailureCategory !== undefined
+        ? normalizeDagFailureCategory(rawFailureCategory, status)
+        : undefined;
     return {
         runId,
         status,
         nodes,
         ...(verdict !== undefined ? { verdict } : {}),
-        ...(failureCategory !== undefined ? { failureCategory } : {}),
+        ...(failureCategory !== undefined &&
+            failureCategory !== "success" &&
+            failureCategory !== "skipped"
+            ? { failureCategory }
+            : {}),
         ...(outOfBounds.length > 0 ? { outOfBounds } : {}),
         ...(next ? { next } : {}),
     };

package/dist/worker/console/operator-actions.js

@@ -1,5 +1,6 @@
 import { access, readFile } from "node:fs/promises";
-import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
+import { buildOperatorCapabilitiesDocument, OFFICIAL_TAIL_ACTION_IDS, } from "../../shared/operator/capabilities.js";
+import { DAG_RERUN_PROMPT_OVERRIDE_ENV, isDagRerunPromptOverrideEnabled, MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS, } from "../../shared/dag-prompt-override.js";
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
@@ -401,6 +402,85 @@ async function runReadCli(ctx, args, command) {
         });
     }
 }
+/**
+ * Parse and bound the experimental promptOverrides action param. The env
+ * switch is checked separately so disabled deployments fail closed before any
+ * staging happens. `mode` defaults to "replace"; "append" keeps the frozen
+ * base prompt and only appends the operator text as a marked addendum.
+ */
+function parsePromptOverrideParams(raw) {
+    if (raw === undefined || raw === null)
+        return { kind: "ok", overrides: [] };
+    if (!Array.isArray(raw)) {
+        return {
+            kind: "error",
+            message: "promptOverrides must be an array of {nodeId, prompt, mode?}",
+        };
+    }
+    if (raw.length === 0)
+        return { kind: "ok", overrides: [] };
+    if (raw.length > 8) {
+        return { kind: "error", message: "promptOverrides supports at most 8 nodes" };
+    }
+    const overrides = [];
+    const seen = new Set();
+    for (const item of raw) {
+        if (!item || typeof item !== "object") {
+            return {
+                kind: "error",
+                message: "promptOverrides entries must be objects {nodeId, prompt, mode?}",
+            };
+        }
+        const record = item;
+        const nodeId = typeof record.nodeId === "string" ? record.nodeId.trim() : "";
+        const prompt = typeof record.prompt === "string" ? record.prompt : "";
+        const mode = record.mode === undefined || record.mode === null
+            ? undefined
+            : typeof record.mode === "string"
+                ? record.mode
+                : "invalid";
+        if (!nodeId) {
+            return { kind: "error", message: "promptOverrides nodeId is required" };
+        }
+        if (seen.has(nodeId)) {
+            return {
+                kind: "error",
+                message: `promptOverrides contains duplicate nodeId: ${nodeId}`,
+            };
+        }
+        seen.add(nodeId);
+        if (mode !== undefined && mode !== "append" && mode !== "replace") {
+            return {
+                kind: "error",
+                message: `promptOverrides mode for ${nodeId} must be append or replace`,
+            };
+        }
+        if (!prompt.trim() || prompt.length > MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS) {
+            return {
+                kind: "error",
+                message: `promptOverrides prompt for ${nodeId} must be 1-${MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS} characters`,
+            };
+        }
+        overrides.push(mode === undefined ? { nodeId, prompt } : { nodeId, prompt, mode });
+    }
+    return { kind: "ok", overrides };
+}
+/** Stage override bodies under app-data and build `--prompt-override` CLI
+ *  args. The flag carries the mode: `--prompt-override-append` for append. */
+async function buildPromptOverrideCliArgs(ctx, overrides) {
+    const args = [];
+    for (const override of overrides) {
+        const staged = await stageUtf8Text(ctx.appData, override.prompt, {
+            extension: ".md",
+            label: `prompt-override-${override.nodeId}`,
+        });
+        const flag = override.mode === "append"
+            ? "--prompt-override-append"
+            : "--prompt-override";
+        args.push(flag, `${override.nodeId}@${staged.path}`);
+    }
+    return args;
+}
 async function acceptOperation(ctx, input) {
     const created = await ctx.operations.create({
         clientRequestId: input.clientRequestId,
@@ -672,6 +752,80 @@ export async function dispatchOperatorAction(ctx, req) {
             const body = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }
+        case "dagDoctor": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            const args = ["dag", "doctor"];
+            if (runId)
+                args.push("--run-id", runId);
+            const body = await runReadCli(ctx, args, "dag doctor");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "dagStatus": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            if (!runId)
+                return invalid(action, "runId is required");
+            const body = await runReadCli(ctx, ["dag", "status", "--run-id", runId], "dag status");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "workerPoolDoctor": {
+            const taskId = str(p.taskId);
+            const run = ctx.runCommand ??
+                ((args, options) => ctx.client.runExternal
+                    ? ctx.client.runExternal(resolveSiblingAgentWorkerBin(), args, options)
+                    : ctx.client.run(args, options));
+            let result;
+            try {
+                result = await run(["pool", "doctor", "--repo", ctx.repoRoot, "--json"], {
+                    cwd: ctx.repoRoot,
+                    artifactName: "read-pool-doctor",
+                    expectJson: true,
+                });
+            }
+            catch (error) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: `cannot read pool doctor facts: ${error instanceof Error ? error.message : String(error)}`,
+                    }),
+                };
+            }
+            if (!result.ok || result.exitCode !== 0 || !result.json) {
+                return {
+                    kind: "error",
+                    status: 400,
+                    body: operatorFailed({
+                        command: action,
+                        outcome: "invalid",
+                        code: "INVALID_INPUT",
+                        message: summarizeReadCliFailure(result),
+                    }),
+                };
+            }
+            const inventory = result.json;
+            if (!taskId) {
+                return {
+                    kind: "sync",
+                    status: 200,
+                    body: operatorSucceeded(action, inventory),
+                };
+            }
+            const v2 = (inventory.v2 ?? []).filter((entry) => entry.taskId === taskId);
+            const legacy = (inventory.legacy ?? []).filter((entry) => entry.taskId === taskId);
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    ...inventory,
+                    v2,
+                    legacy,
+                    focusedTaskId: taskId,
+                }),
+            };
+        }
         case "status": {
             const taskId = str(p.taskId);
             if (!taskId) {
@@ -986,7 +1140,7 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             if (operatorAction) {
                 const target = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === operatorAction &&
-                    entry.description.startsWith("Official CLI action coverage") &&
+                    OFFICIAL_TAIL_ACTION_IDS.has(entry.action) &&
                     entry.humanConfirmation === "required");
                 if (!target)
                     return invalid(action, "operatorAction must name a required official action");
@@ -2004,12 +2158,35 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             return accepted;
         }
+        case "dagPromptOverrideConfig": {
+            // Experimental internal switch; the browser UI hides the prompt-edit
+            // entry unless this reports enabled=true.
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, {
+                    enabled: isDagRerunPromptOverrideEnabled(),
+                    envVar: DAG_RERUN_PROMPT_OVERRIDE_ENV,
+                }),
+            };
+        }
         case "dagRerunPlan": {
             const runId = str(p.runId);
             const fromNode = str(p.fromNode);
             if (!runId || !fromNode) {
                 return invalid(action, "runId and fromNode are required");
             }
+            const parsedOverrides = parsePromptOverrideParams(p.promptOverrides);
+            if (parsedOverrides.kind === "error") {
+                return invalid(action, parsedOverrides.message);
+            }
+            if (parsedOverrides.overrides.length > 0 &&
+                !isDagRerunPromptOverrideEnabled()) {
+                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             const body = await runReadCli(ctx, [
                 "dag",
                 "rerun",
@@ -2018,6 +2195,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 "--from-node",
                 fromNode,
                 "--plan",
+                ...overrideArgs,
                 "--json",
             ], "dag rerun plan");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
@@ -2031,6 +2209,17 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!runId || !fromNode || !planHash || !reason || !clientRequestId) {
                 return invalid(action, "runId, fromNode, planHash, reason, and clientRequestId are required");
             }
+            const parsedOverrides = parsePromptOverrideParams(p.promptOverrides);
+            if (parsedOverrides.kind === "error") {
+                return invalid(action, parsedOverrides.message);
+            }
+            if (parsedOverrides.overrides.length > 0 &&
+                !isDagRerunPromptOverrideEnabled()) {
+                return invalid(action, `prompt override rerun is disabled; set ${DAG_RERUN_PROMPT_OVERRIDE_ENV}=1 to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             return acceptOperation(ctx, {
                 action,
                 actionParams: p,
@@ -2048,6 +2237,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     clientRequestId,
                     "--reason",
                     reason,
+                    ...overrideArgs,
                     "--json",
                 ],
             });
@@ -2536,8 +2726,9 @@ export async function dispatchOperatorAction(ctx, req) {
             // M5 official-command coverage uses one generic tail for newly registered
             // CLI actions. It remains inside dispatchOperatorAction (the sole dispatch
             // surface) and only accepts argv arrays declared by the capability schema.
-            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action &&
-                entry.description.startsWith("Official CLI action coverage"));
+            // 2026-08-18: high-frequency entries got real descriptions; membership is
+            // now derived from OFFICIAL_TAIL_ACTION_IDS, not description prefixes.
+            const capability = buildOperatorCapabilitiesDocument().actions.find((entry) => entry.action === action && OFFICIAL_TAIL_ACTION_IDS.has(entry.action));
             if (capability) {
                 const rawArgs = p.args;
                 if (rawArgs !== undefined &&

package/dist/worker/console/operator-user-error.js

@@ -3,7 +3,7 @@ import { rewriteRecoveryOperatorError } from "./recovery-error-copy.js";
 const MUTATION_GATE_COPY = [
     {
         pattern: /invalid (boot capability|confirmation header) token/i,
-        copy: "页面已过期（控制台已重启），请刷新页面（F5）后重试。",
+        copy: "页面凭证已失效（控制台可能已重启），请刷新页面（F5）后重试。",
     },
     {
         pattern: /mutation requires boot capability cookie|mutation requires confirmation header token/i,
@@ -23,7 +23,7 @@ export function formatOperatorUserError(message) {
     if (recovery)
         return recovery;
     if (/controller identity changed|package fingerprint changed|entry binary sha256 changed/i.test(raw)) {
-        return "控制器版本已变更（Console 启动后代码被重新编译）。请重启 Console 后再试，一次会话中途不要升级/重建控制器。";
+        return "控制器版本已变更（Console 启动后代码被重新编译，或提交了 package.json / bin / dist / skills 等指纹范围文件）。请重启 Console 进程使其重新加载当前构建后再重试本操作；一次会话中途不要重建控制器。";
     }
     if (/Pi session file missing or not openable|cannot reopen chat session .* no persisted Pi session file/i.test(raw)) {
         return "该对话的 Pi 会话文件已丢失，无法恢复上下文。请新建对话继续（历史记录无法重开）。";

package/dist/worker/console/pi-readiness.js

@@ -85,7 +85,7 @@ function hasProviderConfig(snapshot) {
 /**
  * Discover live Pi SDK / auth / model readiness via ModelRuntime.
  * Kept inside worker/console (dynamic import) so Worker does not depend on
- * executors; contract matches pi-sdk-executor 0.80.10.
+ * executors; contract matches pi-sdk-executor 0.83.0.
  */
 export async function discoverPiReadinessProbe(options) {
     const repoRoot = options?.repoRoot ?? process.cwd();
@@ -118,7 +118,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.80.10)",
+                sdkMessage: "Pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0)",
                 authMessage: "skipped (sdk incompatible)",
                 modelsMessage: "skipped (sdk incompatible)",
                 sessionMessage: "skipped (sdk incompatible)",
@@ -159,7 +159,7 @@ export async function discoverPiReadinessProbe(options) {
             modelsAvailable: false,
             interviewSessionOk: false,
             details: {
-                sdkMessage: "Pi SDK 0.80.10 contract available",
+                sdkMessage: "Pi SDK 0.83.0 contract available",
                 authMessage: `ModelRuntime.create failed: ${message}`,
                 modelsMessage: "skipped (runtime init failed)",
                 sessionMessage: "skipped (runtime init failed)",
@@ -222,8 +222,9 @@ export async function discoverPiReadinessProbe(options) {
         authReady,
         modelsAvailable,
         interviewSessionOk,
+        piAvailableModels: availableModels,
         details: {
-            sdkMessage: `Pi SDK 0.80.10 contract available (agentDir=${agentDir})`,
+            sdkMessage: `Pi SDK 0.83.0 contract available (agentDir=${agentDir})`,
             authMessage: authReady
                 ? `credentials/providers ready (available=${availableCount}, providerConfig=${providerConfigured})`
                 : "no available models and no stored/configured provider credentials (set Pi auth or provider API keys)",