@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.10

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

@@ -1,5 +1,6 @@
 import { access, readFile } from "node:fs/promises";
 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,
@@ -456,6 +536,184 @@ async function acceptOperation(ctx, input) {
         },
     };
 }
+function splitRuntimeMissing(action) {
+    return {
+        kind: "error",
+        status: 503,
+        body: operatorFailed({
+            command: action,
+            outcome: "blocked",
+            code: "INTERNAL_ERROR",
+            message: `${action} is unavailable: frontend split runtime is not wired`,
+        }),
+    };
+}
+function numOf(v) {
+    return typeof v === "number" ? v : Number(v);
+}
+function splitCommandBase(p) {
+    return {
+        operationId: str(p.operationId) ?? "",
+        expectedRevision: numOf(p.expectedRevision),
+        expectedParentDigest: str(p.expectedParentDigest) ?? "",
+        expectedManifestDigest: str(p.expectedManifestDigest) ?? "",
+    };
+}
+function splitCommandDispatch(action, result) {
+    if (result.outcome === "conflict") {
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: action,
+                outcome: "conflict",
+                code: "CONFLICT",
+                message: "frontend split CAS conflict (stale revision or binding)",
+            }),
+        };
+    }
+    return { kind: "sync", status: 200, body: operatorSucceeded(action, result) };
+}
+async function runSplitAction(action, run) {
+    try {
+        const result = await run();
+        if (result && typeof result === "object" && "outcome" in result) {
+            return splitCommandDispatch(action, result);
+        }
+        return {
+            kind: "sync",
+            status: 200,
+            body: operatorSucceeded(action, result),
+        };
+    }
+    catch (error) {
+        return invalid(action, error instanceof Error ? error.message : String(error));
+    }
+}
+function humanDecisionDispatch(action, result) {
+    if (result.outcome === "rejected") {
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: action,
+                outcome: "conflict",
+                code: "CONFLICT",
+                message: result.reason,
+                details: { projection: result.projection },
+            }),
+        };
+    }
+    return { kind: "sync", status: 200, body: operatorSucceeded(action, result) };
+}
+async function runHumanDecisionAction(action, run) {
+    try {
+        return humanDecisionDispatch(action, await run());
+    }
+    catch (error) {
+        return invalid(action, error instanceof Error ? error.message : String(error));
+    }
+}
+async function acceptConsoleUpdateAndInit(ctx, clientRequestId, channel) {
+    if (!ctx.consoleUpdateExecutor) {
+        return {
+            kind: "error",
+            status: 503,
+            body: operatorFailed({
+                command: "consoleUpdateAndInit",
+                outcome: "blocked",
+                code: "CONSOLE_UPDATE_UNAVAILABLE",
+                message: "Console update runtime is unavailable",
+            }),
+        };
+    }
+    const created = await ctx.operations.create({
+        clientRequestId,
+        action: "consoleUpdateAndInit",
+        actionParams: { channel },
+    });
+    if (created.kind === "conflict") {
+        return {
+            kind: "error",
+            status: 409,
+            body: operatorFailed({
+                command: "consoleUpdateAndInit",
+                outcome: "conflict",
+                code: "REQUEST_ID_REUSE_CONFLICT",
+                message: created.message,
+            }),
+        };
+    }
+    if (created.kind === "idempotent") {
+        return {
+            kind: "accepted",
+            status: 202,
+            body: {
+                operationId: created.operation.operationId,
+                state: created.operation.state,
+                clientRequestId: created.operation.clientRequestId,
+                action: created.operation.action,
+            },
+        };
+    }
+    queueMicrotask(() => {
+        void (async () => {
+            const operationId = created.operation.operationId;
+            await ctx.operations.update(operationId, {
+                state: "running",
+                startedAt: new Date().toISOString(),
+            });
+            ctx.events.append(operationId, {
+                at: new Date().toISOString(),
+                kind: "state",
+                state: "running",
+                message: `checking runtime, npm ${channel}, and safe initialization`,
+            });
+            try {
+                const result = await ctx.consoleUpdateExecutor(channel);
+                const state = result.state;
+                const next = await ctx.operations.update(operationId, {
+                    state,
+                    finishedAt: new Date().toISOString(),
+                    result: result,
+                    ...(result.errorCode ? { errorCode: result.errorCode } : {}),
+                    ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+                });
+                ctx.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "state",
+                    state: next.state,
+                    message: result.errorMessage ?? `console maintenance ${next.state}`,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const next = await ctx.operations.update(operationId, {
+                    state: "needs-reconcile",
+                    finishedAt: new Date().toISOString(),
+                    errorCode: "CONSOLE_UPDATE_EXCEPTION",
+                    errorMessage: message,
+                });
+                ctx.events.append(operationId, {
+                    at: new Date().toISOString(),
+                    kind: "error",
+                    state: next.state,
+                    message,
+                });
+            }
+        })();
+    });
+    return {
+        kind: "accepted",
+        status: 202,
+        body: {
+            operationId: created.operation.operationId,
+            state: created.operation.state,
+            clientRequestId: created.operation.clientRequestId,
+            action: created.operation.action,
+        },
+    };
+}
 export async function dispatchOperatorAction(ctx, req) {
     const action = req.action?.trim();
     if (!action) {
@@ -486,6 +744,31 @@ export async function dispatchOperatorAction(ctx, req) {
         };
     }
     const p = paramsOf(req);
+    if (action === "consoleUpdateAndInit") {
+        if (req.source !== "human-ui") {
+            return {
+                kind: "error",
+                status: 403,
+                body: operatorFailed({
+                    command: action,
+                    outcome: "blocked",
+                    code: "HUMAN_UI_REQUIRED",
+                    message: "consoleUpdateAndInit is available only from the Operate UI",
+                }),
+            };
+        }
+        if (!req.clientRequestId?.trim()) {
+            return invalid(action, "clientRequestId is required");
+        }
+        if (Object.keys(p).some((key) => key !== "channel")) {
+            return invalid(action, "only channel may be provided");
+        }
+        const channel = p.channel ?? "latest";
+        if (channel !== "latest" && channel !== "next") {
+            return invalid(action, "channel must be latest or next");
+        }
+        return acceptConsoleUpdateAndInit(ctx, req.clientRequestId, channel);
+    }
     switch (action) {
         case "operatorCapabilities": {
             const doc = buildOperatorCapabilitiesDocument();
@@ -2078,12 +2361,35 @@ export async function dispatchOperatorAction(ctx, req) {
             }
             return accepted;
         }
+        case "dagPromptOverrideConfig": {
+            // The prompt-edit entry is visible by default. The internal environment
+            // switch remains an emergency kill switch and is reflected here.
+            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 by ${DAG_RERUN_PROMPT_OVERRIDE_ENV}; unset it or use a value other than 0, false, or off to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             const body = await runReadCli(ctx, [
                 "dag",
                 "rerun",
@@ -2092,6 +2398,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 };
@@ -2105,6 +2412,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 by ${DAG_RERUN_PROMPT_OVERRIDE_ENV}; unset it or use a value other than 0, false, or off to enable this experimental capability`);
+            }
+            const overrideArgs = parsedOverrides.overrides.length > 0
+                ? await buildPromptOverrideCliArgs(ctx, parsedOverrides.overrides)
+                : [];
             return acceptOperation(ctx, {
                 action,
                 actionParams: p,
@@ -2122,6 +2440,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     clientRequestId,
                     "--reason",
                     reason,
+                    ...overrideArgs,
                     "--json",
                 ],
             });
@@ -2606,6 +2925,75 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
+        case "frontendSplitWakeup": {
+            if (!ctx.splitOrchestrator)
+                return splitRuntimeMissing(action);
+            return runSplitAction(action, () => ctx.splitOrchestrator.wakeupChildren(splitCommandBase(p)));
+        }
+        case "frontendSplitChildCallback": {
+            if (!ctx.splitOrchestrator)
+                return splitRuntimeMissing(action);
+            return runSplitAction(action, () => ctx.splitOrchestrator.childCallback({
+                ...splitCommandBase(p),
+                observation: p.observation,
+            }));
+        }
+        case "frontendSplitWakeupIntegration": {
+            if (!ctx.splitOrchestrator)
+                return splitRuntimeMissing(action);
+            return runSplitAction(action, () => ctx.splitOrchestrator.wakeupIntegration(splitCommandBase(p)));
+        }
+        case "frontendSplitIntegrationCallback": {
+            if (!ctx.splitOrchestrator)
+                return splitRuntimeMissing(action);
+            return runSplitAction(action, () => ctx.splitOrchestrator.integrationCallback({
+                ...splitCommandBase(p),
+                completion: p.completion,
+            }));
+        }
+        case "frontendSplitFinalize": {
+            if (!ctx.splitOrchestrator)
+                return splitRuntimeMissing(action);
+            return runSplitAction(action, () => ctx.splitOrchestrator.finalize(splitCommandBase(p)));
+        }
+        case "frontendHumanDecisionMaterialize": {
+            if (!ctx.humanDecisionAdapter)
+                return splitRuntimeMissing(action);
+            return runHumanDecisionAction(action, () => ctx.humanDecisionAdapter.materialize({
+                operationId: str(p.operationId) ?? "",
+                expectedRecordRevision: numOf(p.expectedRecordRevision),
+                expectedProjectionDigest: str(p.expectedProjectionDigest) ?? "",
+                envelope: p.envelope,
+            }));
+        }
+        case "frontendHumanDecisionApprove": {
+            if (!ctx.humanDecisionAdapter)
+                return splitRuntimeMissing(action);
+            return runHumanDecisionAction(action, () => ctx.humanDecisionAdapter.consume({
+                operationId: str(p.operationId) ?? "",
+                expectedRecordRevision: numOf(p.expectedRecordRevision),
+                expectedProjectionDigest: str(p.expectedProjectionDigest) ?? "",
+                receipt: p.receipt,
+                currentTargetDigest: str(p.currentTargetDigest) ?? "",
+                now: str(p.now) ?? new Date().toISOString(),
+            }));
+        }
+        case "frontendSplitInitialize": {
+            if (!ctx.humanDecisionAdapter)
+                return splitRuntimeMissing(action);
+            return runHumanDecisionAction(action, () => ctx.humanDecisionAdapter.initializeSplit({
+                operationId: str(p.operationId) ?? "",
+                expectedRecordRevision: numOf(p.expectedRecordRevision),
+                expectedProjectionDigest: str(p.expectedProjectionDigest) ?? "",
+                execution: p.execution,
+                manifest: p.manifest,
+                receipt: p.receipt,
+                currentTargetDigest: str(p.currentTargetDigest) ?? "",
+                now: str(p.now) ?? new Date().toISOString(),
+                activeWriterOperationId: str(p.activeWriterOperationId) ?? null,
+                activeProviderOperationId: str(p.activeProviderOperationId) ?? null,
+            }));
+        }
         default: {
             // M5 official-command coverage uses one generic tail for newly registered
             // CLI actions. It remains inside dispatchOperatorAction (the sole dispatch

package/dist/worker/console/operator-surface-health.js

@@ -12,6 +12,7 @@ export function buildOperatorSurfaceHealthV1(input) {
         repoName: input.repoRoot.split(/[\\/]/).filter(Boolean).pop() ?? "repository",
         packageName,
         packageVersion,
+        consoleInstanceId: input.consoleInstanceId,
         piReadiness: input.piReadiness,
         inspect: {
             ready: input.inspectReady,

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/prd-intake-bridge.js

@@ -9,6 +9,7 @@ import { getTaskPaths } from "../../task/runtime.js";
 import { SEMANTIC_INTAKE_ARTIFACT_REL, } from "../../task/source-prepare/semantic-intake.js";
 import { extractRequirementFactsFromMarkdown } from "../../task/source-prepare/parse-intent.js";
 import { filterPlaceholderPaths, isNonPlaceholderPath, } from "../../task/source-prepare/placeholder-paths.js";
+import { summarizeLedgerPayload, } from "./draft-store.js";
 import { emptyDraft } from "./interview/grill-me.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 function asStringList(value) {
@@ -219,6 +220,15 @@ export async function buildDraftFromTaskIntake(input) {
     const paths = getTaskPaths(input.repoRoot, input.taskId);
     const warnings = warningList(input.advanceJson);
     const lifecycleState = lifecycleFromAdvanceJson(input.advanceJson);
+    // Source fidelity ledger 安全摘要透传（AC-009）：来自 advance/prepare 结果，
+    // 未知形状安全丢弃，绝不携带未截断原文。
+    const advanceRoot = input.advanceJson && typeof input.advanceJson === "object"
+        ? input.advanceJson
+        : {};
+    const ledgerSummary = summarizeLedgerPayload(advanceRoot.ledgerSummary) ??
+        summarizeLedgerPayload(advanceRoot.result && typeof advanceRoot.result === "object"
+            ? advanceRoot.result.ledgerSummary
+            : undefined);
     const semanticApplied = warnings.some((w) => w.code === "SEMANTIC_INTAKE_APPLIED");
     const semanticFailed = warnings.find((w) => w.code === "SEMANTIC_INTAKE_PI_FAILED" ||
         w.code === "SEMANTIC_INTAKE_INVALID_OUTPUT" ||
@@ -427,11 +437,14 @@ export async function buildDraftFromTaskIntake(input) {
     if (input.engineering) {
         draft = applyEngineeringBoundaryToDraft(draft, input.engineering);
     }
+    // AC-BLOCK-002：摘要仅经响应返回 UI 视图模型，不写入 draft（防止 strict
+    // taskContractDraftSchema 因未知 ledgerSummary 键拒绝 canonical draft）。
     return {
         draft,
         parseStatus,
         semanticIntake,
         gaps,
+        ...(ledgerSummary ? { ledgerSummary } : {}),
         lifecycleState,
     };
 }