@tea-agent/loop-agent 0.37.0 → 0.37.1-beta.0

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

@@ -1,7 +1,7 @@
 import { access, readFile } from "node:fs/promises";
 import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
 import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
-import { CANONICAL_TASK_ID_PATTERN, formatLocalBusinessDate, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
+import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { diffTaskContract, validateDraftForTask, } from "../../task/contract/index.js";
 import { stageUtf8Text } from "./app-data.js";
 import { ALL_CONFIRMATION_CHALLENGES, hashDagBytes, } from "./dag-confirmation.js";
@@ -18,23 +18,18 @@ import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.js";
 import { discoverPrdReferences } from "./prd-reference-discovery.js";
-import { clearSemanticIntakeAttempt, SEMANTIC_INTAKE_CLI_TIMEOUT_MS, } from "../../task/source-prepare/semantic-intake.js";
+import { clearSemanticIntakeAttempt } from "../../task/source-prepare/semantic-intake.js";
 import nodePath from "node:path";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
-import { OperationWaitError, waitForOperationChange, } from "./operation-wait.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
-import { formatIneligibleRerunMessage } from "./recovery-error-copy.js";
-import { evaluateConsoleDagInterruptEligibility } from "../observability/interrupt-eligibility.js";
-import { INTERRUPT_ERROR_MESSAGES, isInterruptReasonCode, normalizeInterruptReasonDetail, } from "../observability/interrupt-eligibility.js";
 import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec, } from "./dag-execution-receipt.js";
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
 const MUTATION_GATE_ACTIONS = new Set([
     // 2026-08-11: standaloneTaskRerun / workerTaskRetry are autonomous (server
-    // run-facts checks). Destructive DAG reconciliation, live cooperative
-    // interrupt, and Night Scheduler mutations still need the browser Human Gate.
+    // run-facts checks). Destructive DAG reconciliation and Night Scheduler
+    // mutations still need the browser Human Gate.
     "dagReconcileRun",
-    "dagRequestInterrupt",
     "workerAdmissionPrepare",
     "workerSchedulerAdd",
     "workerSchedulerCancel",
@@ -47,12 +42,10 @@ const MUTATION_OR_LONG = new Set([
     "contractApply",
     "contractAdopt",
     "contractRecover",
-    "taskAdvance",
     "dagRunTask",
     "runDag",
     "dagRerun",
     "dagReconcileRun",
-    "dagRequestInterrupt",
     "standaloneTaskRerun",
     "workerTaskRetry",
 ]);
@@ -62,15 +55,6 @@ function paramsOf(req) {
 function str(v) {
     return typeof v === "string" && v.trim() ? v.trim() : undefined;
 }
-const TASK_ID_PLACEHOLDER_RE = /[<>]|^(?:id|task-?id|your-task-id|todo|tbd)$/i;
-/** Mirror of runtime GENERIC_TASK_SLUGS (not exported there); keep in sync. */
-const GENERIC_SLUG_SET = new Set(["test", "fix", "tmp", "new-task"]);
-const TASK_ADVANCE_ALIAS_ACTIONS = new Set(["promoteRun", "closeoutTask"]);
-function taskIdInputError(taskId) {
-    if (!TASK_ID_PLACEHOLDER_RE.test(taskId))
-        return undefined;
-    return `taskId must be a concrete canonical id; placeholder values are not allowed: ${JSON.stringify(taskId)}`;
-}
 /** Extract write-set gate token from task advance operator JSON. */
 function extractWriteSetGateTokenFromCliJson(json, taskId) {
     if (!json || typeof json !== "object")
@@ -145,46 +129,13 @@ function gateError(action, code, message, details) {
         }),
     };
 }
-/**
- * `dag report --json` is `{ schemaVersion, runs: [...] }` (no Operator `ok`).
- * `runReadCli` used to wrap that as `{ stdout, raw }`, which made the
- * autonomous rerun gate miss `primaryFailure` even after the UI showed the
- * report (2026-08-16). Accept both the native report shape and the wrap.
- */
-function extractDagReportRunFacts(reportResult, runId) {
-    const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-    const result = asRecord(reportResult);
-    const envelope = Array.isArray(result?.runs)
-        ? result
-        : asRecord(result?.raw);
-    if (!envelope)
-        return undefined;
-    const runs = Array.isArray(envelope.runs) ? envelope.runs : [];
-    const matched = runs.find((entry) => asRecord(entry)?.runId === runId) ?? runs[0];
-    const matchedRec = asRecord(matched);
-    if (matchedRec?.primaryFailure) {
-        return {
-            primaryFailure: asRecord(matchedRec.primaryFailure),
-            primaryRecovery: asRecord(matchedRec.primaryRecovery),
-        };
-    }
-    if (envelope.primaryFailure) {
-        return {
-            primaryFailure: asRecord(envelope.primaryFailure),
-            primaryRecovery: asRecord(envelope.primaryRecovery),
-        };
-    }
-    return undefined;
-}
 /**
  * 2026-08-11 R2 run-facts check for standaloneTaskRerun (read-only CLI
  * evidence only — no browser Human Gate). Fails closed when facts are missing.
  */
 async function assertAutonomousRerunEligible(ctx, runId, taskId) {
     const report = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
-    const reportResult = extractDagReportRunFacts(report.ok ? report.result : undefined, runId);
+    const reportResult = (report.ok ? report.result : undefined);
     const recovery = reportResult?.primaryRecovery;
     if (!report.ok || !reportResult?.primaryFailure || !recovery) {
         return gateError("standaloneTaskRerun", "INVALID_INPUT", "cannot read dagReport run facts; standaloneTaskRerun requires server-side run evidence", { runId });
@@ -330,9 +281,6 @@ async function runReadCli(ctx, args, command) {
             if (env.schemaVersion === 1 && typeof env.ok === "boolean") {
                 return env;
             }
-            if (raw.schemaVersion === 1 && Array.isArray(raw.runs)) {
-                return operatorSucceeded(command, raw);
-            }
             if (command === "dag rerun plan" &&
                 raw.plan &&
                 typeof raw.plan === "object") {
@@ -344,8 +292,9 @@ async function runReadCli(ctx, args, command) {
                     ? plan.blockedReasons.map(String)
                     : [];
                 const blockingNodes = Array.isArray(plan.blockingNodes)
-                    ? plan.blockingNodes
+                    ? plan.blockingNodes.map((n) => [n.nodeId, n.reasonCode].filter(Boolean).join(":"))
                     : [];
+                const reasons = [...blockedReasons, ...blockingNodes].filter(Boolean);
                 return buildOperatorResult({
                     command,
                     ok: false,
@@ -353,10 +302,9 @@ async function runReadCli(ctx, args, command) {
                     result: plan,
                     error: {
                         code: "DAG_RERUN_INELIGIBLE",
-                        message: formatIneligibleRerunMessage({
-                            blockedReasons,
-                            blockingNodes,
-                        }),
+                        message: reasons.length > 0
+                            ? `从节点重跑不具备安全资格：${reasons.slice(0, 6).join("; ")}${reasons.length > 6 ? "…" : ""}`
+                            : "从节点重跑不具备安全资格（eligible=false）",
                         details: {
                             eligible: false,
                             planHash: typeof plan.planHash === "string" ? plan.planHash : undefined,
@@ -571,90 +519,6 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
-        case "operationWait": {
-            const operationId = str(p.operationId);
-            if (!operationId)
-                return invalid(action, "operationId is required");
-            const rawAfterSeq = p.afterSeq ?? 0;
-            const afterSeq = typeof rawAfterSeq === "number" ? rawAfterSeq : Number(rawAfterSeq);
-            const rawMaxWaitMs = p.maxWaitMs;
-            const maxWaitMs = typeof rawMaxWaitMs === "number"
-                ? rawMaxWaitMs
-                : rawMaxWaitMs === undefined
-                    ? undefined
-                    : Number(rawMaxWaitMs);
-            const rawWakeOn = str(p.wakeOn);
-            const wakeOn = rawWakeOn === "all" || rawWakeOn === "meaningful" ? rawWakeOn : undefined;
-            try {
-                const result = await waitForOperationChange({
-                    operations: ctx.operations,
-                    events: ctx.events,
-                    operationId,
-                    afterSeq,
-                    maxWaitMs,
-                    ...(wakeOn ? { wakeOn } : {}),
-                    poll: async () => {
-                        const current = await ctx.operations.get(operationId);
-                        const runId = current?.dagRunId ??
-                            (typeof current?.actionParams?.runId === "string"
-                                ? current.actionParams.runId
-                                : undefined);
-                        if (!current || !runId)
-                            return false;
-                        const eligibility = await evaluateConsoleDagInterruptEligibility({
-                            repoRoot: ctx.repoRoot,
-                            operations: ctx.operations,
-                            runId,
-                        });
-                        if (!eligibility.interrupt)
-                            return false;
-                        const targetId = eligibility.targetOperationId ?? current.operationId;
-                        return syncTargetInterruptProjection({
-                            operations: ctx.operations,
-                            events: ctx.events,
-                            operationId: targetId,
-                            runId,
-                            interrupt: eligibility.interrupt,
-                        });
-                    },
-                });
-                return {
-                    kind: "sync",
-                    status: 200,
-                    body: operatorSucceeded(action, result),
-                };
-            }
-            catch (error) {
-                if (error instanceof OperationWaitError) {
-                    if (error.code === "NOT_FOUND") {
-                        return {
-                            kind: "error",
-                            status: 404,
-                            body: operatorFailed({
-                                command: action,
-                                outcome: "not-found",
-                                code: "NOT_FOUND",
-                                message: error.message,
-                            }),
-                        };
-                    }
-                    if (error.code === "EVENT_CURSOR_EXPIRED") {
-                        return {
-                            kind: "error",
-                            status: 410,
-                            body: operatorFailed({
-                                command: action,
-                                outcome: "blocked",
-                                code: "EVENT_CURSOR_EXPIRED",
-                                message: error.message,
-                            }),
-                        };
-                    }
-                    return invalid(action, error.message);
-                }
-                throw error;
-            }
-        }
         case "inspect": {
             const body = await runReadCli(ctx, ["inspect", "--json"], "inspect");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
@@ -1322,24 +1186,8 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const reviewPacket = extractReviewPacketFromCliJson(gen.json) ?? {};
-            let parsedDagSpec;
-            try {
-                parsedDagSpec = JSON.parse(dagText);
-            }
-            catch (error) {
-                return {
-                    kind: "error",
-                    status: 409,
-                    body: operatorFailed({
-                        command: action,
-                        outcome: "blocked",
-                        code: "DAG_GENERATION_FAILED",
-                        message: `generated DAG is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
-                    }),
-                };
-            }
             const derivedFacts = deriveEligibilityFactsFromDagSpec({
-                dagSpec: parsedDagSpec,
+                dagSpec: JSON.parse(dagText),
                 allowedPaths,
                 forbiddenPaths,
             });
@@ -1501,24 +1349,6 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !clientRequestId) {
                 return invalid(action, "taskId and clientRequestId are required");
             }
-            const taskIdError = taskIdInputError(taskId);
-            if (taskIdError)
-                return invalid(action, taskIdError);
-            // Canonical id gate at admission (2026-08-16): non-canonical ids were
-            // accepted here (validateNewTaskId only warns) and every downstream
-            // advance/import then flailed on the malformed task directory. Fail
-            // fast with a concrete suggested id instead.
-            if (!CANONICAL_TASK_ID_PATTERN.test(taskId)) {
-                const slug = taskId
-                    .toLowerCase()
-                    .replace(/[^a-z0-9]+/g, "-")
-                    .replace(/^-+|-+$/g, "")
-                    .slice(0, 48);
-                const suggested = slug && !GENERIC_SLUG_SET.has(slug)
-                    ? `${formatLocalBusinessDate()}-${slug}`
-                    : `${formatLocalBusinessDate()}-${slug || "task"}-r2`;
-                return invalid(action, `taskId must be canonical YYYY-MM-DD-<kebab-slug> (local business date); got "${taskId}" — suggested id: "${suggested}" (e.g. 2026-08-16-tool-preview-edge-test); retry newTask with that id`);
-            }
             return acceptOperation(ctx, {
                 action,
                 actionParams: p,
@@ -1527,38 +1357,6 @@ export async function dispatchOperatorAction(ctx, req) {
                 cliArgs: ["task", "advance", taskId, title, "--json"],
             });
         }
-        case "taskAdvance": {
-            const taskId = str(p.taskId);
-            const clientRequestId = str(req.clientRequestId);
-            if (!taskId || !clientRequestId) {
-                return invalid(action, "taskId and clientRequestId are required");
-            }
-            const taskIdError = taskIdInputError(taskId);
-            if (taskIdError)
-                return invalid(action, taskIdError);
-            const args = ["task", "advance", taskId];
-            const title = str(p.title);
-            if (title)
-                args.push(title);
-            const taskKind = str(p.taskKind);
-            if (taskKind)
-                args.push("--task-kind", taskKind);
-            const featureId = str(p.featureId);
-            if (featureId)
-                args.push("--feature-id", featureId);
-            const profile = str(p.profile);
-            if (profile)
-                args.push("--profile", profile);
-            appendEngineeringCliArgs(args, parseEngineeringBoundaryFromParams(p));
-            args.push("--json");
-            return acceptOperation(ctx, {
-                action,
-                actionParams: p,
-                clientRequestId,
-                taskId,
-                cliArgs: args,
-            });
-        }
         case "bootstrapFromPrd":
             return dispatchBootstrapFromPrd(ctx, p);
         case "importPrd": {
@@ -1569,9 +1367,6 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !content) {
                 return invalid(action, "taskId and content are required");
             }
-            const taskIdError = taskIdInputError(taskId);
-            if (taskIdError)
-                return invalid(action, taskIdError);
             const taskKindRaw = str(p.taskKind)?.trim();
             const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
             const taskKindExplicit = Boolean(taskKindRaw);
@@ -1625,7 +1420,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 cwd: ctx.repoRoot,
                 artifactName: "import-prd-task-advance-intake",
                 expectJson: true,
-                timeoutMs: SEMANTIC_INTAKE_CLI_TIMEOUT_MS,
+                timeoutMs: 300_000,
             });
             const intakeJson = intake.json ?? null;
             const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
@@ -1766,9 +1561,6 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !clientRequestId) {
                 return invalid(action, "taskId and clientRequestId are required");
             }
-            const taskIdError = taskIdInputError(taskId);
-            if (taskIdError)
-                return invalid(action, taskIdError);
             const out = await stageUtf8Text(ctx.appData, "", { extension: ".json" });
             return acceptOperation(ctx, {
                 action,
@@ -2051,99 +1843,6 @@ export async function dispatchOperatorAction(ctx, req) {
                 ],
             });
         }
-        case "dagInterruptEligibility": {
-            const runId = str(p.runId) ?? str(p.dagRunId);
-            if (!runId)
-                return invalid(action, "runId is required");
-            const eligibility = await evaluateConsoleDagInterruptEligibility({
-                repoRoot: ctx.repoRoot,
-                operations: ctx.operations,
-                runId,
-            });
-            if (eligibility.interrupt && eligibility.targetOperationId) {
-                await syncTargetInterruptProjection({
-                    operations: ctx.operations,
-                    events: ctx.events,
-                    operationId: eligibility.targetOperationId,
-                    runId,
-                    interrupt: eligibility.interrupt,
-                });
-            }
-            return {
-                kind: "sync",
-                status: 200,
-                body: operatorSucceeded(action, eligibility),
-            };
-        }
-        case "dagRequestInterrupt": {
-            const runId = str(p.runId);
-            const reasonCode = str(p.reasonCode);
-            const reasonDetail = str(p.reasonDetail) ?? str(p.reason);
-            const clientRequestId = str(req.clientRequestId);
-            if (!runId || !reasonCode || !reasonDetail || !clientRequestId) {
-                return invalid(action, "runId, reasonCode, reasonDetail, and clientRequestId are required");
-            }
-            if (!isInterruptReasonCode(reasonCode)) {
-                return invalid(action, `reasonCode must be one of requirements-changed | suspected-runaway | resource-protection | operator-request | other`);
-            }
-            try {
-                normalizeInterruptReasonDetail(reasonDetail);
-            }
-            catch (error) {
-                return invalid(action, error instanceof Error ? error.message : String(error));
-            }
-            const gated = await consumeMutationGateReceipt(ctx, action, p);
-            if (gated.kind === "error")
-                return gated;
-            if (gated.kind === "idempotent")
-                return gated.result;
-            const eligibility = await evaluateConsoleDagInterruptEligibility({
-                repoRoot: ctx.repoRoot,
-                operations: ctx.operations,
-                runId,
-            });
-            if (!eligibility.eligible || !eligibility.targetOperationId || !eligibility.expectedRunnerIdentity) {
-                const failed = interruptActionFailed(action, eligibility.reasonCodes[0] ?? "RUN_NOT_ACTIVE", eligibility.message);
-                return failed;
-            }
-            const expected = eligibility.expectedRunnerIdentity;
-            const accepted = await acceptOperation(ctx, {
-                action,
-                actionParams: {
-                    runId,
-                    reasonCode,
-                    reasonDetail,
-                    targetOperationId: eligibility.targetOperationId,
-                    expectedRunnerIdentity: expected,
-                },
-                clientRequestId,
-                cliArgs: [
-                    "dag",
-                    "request-interrupt",
-                    "--run-id",
-                    runId,
-                    "--request-id",
-                    clientRequestId,
-                    "--target-operation-id",
-                    eligibility.targetOperationId,
-                    "--reason-code",
-                    reasonCode,
-                    "--reason",
-                    reasonDetail,
-                    "--expected-runner-pid",
-                    String(expected.pid),
-                    "--expected-runner-hostname",
-                    expected.hostname,
-                    "--expected-runner-started-at",
-                    expected.startedAt,
-                    "--expected-controller-fingerprint",
-                    expected.controllerFingerprint,
-                    "--json",
-                ],
-            });
-            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
-            return accepted;
-        }
         case "dagReconcileRun": {
             // S6 Recovery: orphan/interrupted runs — structured reason is the human
             // confirmation surface (CLI eligibility still fail-closed).
@@ -2437,7 +2136,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 return invalid(action, "action and actionParams are required");
             }
             if (!MUTATION_GATE_ACTIONS.has(targetAction)) {
-                return invalid(action, "action must be a mutation-gate target (dagReconcileRun | dagRequestInterrupt | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
+                return invalid(action, "action must be a mutation-gate target (dagReconcileRun | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
             }
             const secret = ctx.humanGateSecret;
             if (!secret) {
@@ -2496,14 +2195,6 @@ export async function dispatchOperatorAction(ctx, req) {
                         rawArgs.some((value) => typeof value !== "string"))) {
                     return invalid(action, "args must be an array of strings");
                 }
-                if (TASK_ADVANCE_ALIAS_ACTIONS.has(action) && Array.isArray(rawArgs)) {
-                    const aliasTaskId = str(rawArgs[0]);
-                    const taskIdError = aliasTaskId
-                        ? taskIdInputError(aliasTaskId)
-                        : undefined;
-                    if (taskIdError)
-                        return invalid(action, taskIdError);
-                }
                 if (capability.humanConfirmation === "required") {
                     const confirmationId = str(p.confirmationId);
                     if (!confirmationId)
@@ -2583,9 +2274,6 @@ export async function dispatchOperatorAction(ctx, req) {
                     .replace(/^(loop-agent|agent-worker)\s+/, "")
                     .split(/\s+/);
                 const args = [...prefix, ...(rawArgs ?? [])];
-                if (TASK_ADVANCE_ALIAS_ACTIONS.has(action) && !args.includes("--json")) {
-                    args.push("--json");
-                }
                 if (capability.kind === "read") {
                     if (!args.includes("--json"))
                         args.push("--json");
@@ -3008,7 +2696,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         cwd: ctx.repoRoot,
         artifactName: "bootstrap-task-advance-intake",
         expectJson: true,
-        timeoutMs: SEMANTIC_INTAKE_CLI_TIMEOUT_MS,
+        timeoutMs: 300_000,
     });
     const intakeJson = intake.json ?? null;
     const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
@@ -3482,71 +3170,6 @@ function invalid(action, message) {
         }),
     };
 }
-function interruptActionFailed(action, code, message) {
-    const blocked = code === "INTERRUPT_ALREADY_PENDING" ||
-        code === "INTERRUPT_NEEDS_RECONCILE" ||
-        code === "RUN_ALREADY_TERMINAL" ||
-        code === "RUN_NOT_CONSOLE_OWNED" ||
-        code === "RUNNER_IDENTITY_MISMATCH" ||
-        code === "RUN_NOT_ACTIVE";
-    return {
-        kind: "error",
-        status: code === "INVALID_INPUT" ? 400 : 409,
-        body: operatorFailed({
-            command: action,
-            outcome: blocked ? "blocked" : "invalid",
-            code,
-            message: message || INTERRUPT_ERROR_MESSAGES[code] || message,
-        }),
-    };
-}
-async function syncTargetInterruptProjection(input) {
-    const current = await input.operations.get(input.operationId);
-    if (!current)
-        return false;
-    if (current.interrupt?.status === input.interrupt.status &&
-        current.interrupt?.requestId === input.interrupt.requestId) {
-        return false;
-    }
-    const nextStatus = input.interrupt.status;
-    if (nextStatus !== "requested" &&
-        nextStatus !== "acknowledged" &&
-        nextStatus !== "settled" &&
-        nextStatus !== "needs-reconcile") {
-        return false;
-    }
-    await input.operations.update(input.operationId, {
-        dagRunId: current.dagRunId ?? input.runId,
-        interrupt: {
-            status: nextStatus,
-            ...(input.interrupt.requestId
-                ? { requestId: input.interrupt.requestId }
-                : {}),
-            ...(input.interrupt.reasonCode
-                ? { reasonCode: input.interrupt.reasonCode }
-                : {}),
-            ...(input.interrupt.requestedAt
-                ? { requestedAt: input.interrupt.requestedAt }
-                : {}),
-            ...(input.interrupt.acknowledgedAt
-                ? { acknowledgedAt: input.interrupt.acknowledgedAt }
-                : {}),
-            ...(input.interrupt.settledAt
-                ? { settledAt: input.interrupt.settledAt }
-                : {}),
-            ...(input.interrupt.outcome ? { outcome: input.interrupt.outcome } : {}),
-        },
-    });
-    input.events.append(input.operationId, {
-        kind: "state",
-        message: `interrupt ${nextStatus}`,
-        data: {
-            interruptStatus: nextStatus,
-            runId: input.runId,
-        },
-    });
-    return true;
-}
 function confirmationErrorStatus(code) {
     if (code === "NOT_FOUND")
         return 404;

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

@@ -1,12 +1,8 @@
-import { rewriteRecoveryOperatorError } from "./recovery-error-copy.js";
 /** Map internal spawn/controller errors to actionable Chinese copy. */
 export function formatOperatorUserError(message) {
     const raw = (message ?? "").trim();
     if (!raw)
         return "操作失败";
-    const recovery = rewriteRecoveryOperatorError(raw);
-    if (recovery)
-        return recovery;
     if (/controller identity changed|package fingerprint changed|entry binary sha256 changed/i.test(raw)) {
         return "控制器版本已变更（Console 启动后代码被重新编译）。请重启 Console 后再试，一次会话中途不要升级/重建控制器。";
     }