@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.4

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

@@ -1,5 +1,9 @@
 import { randomBytes } from "node:crypto";
 import path from "node:path";
+import { assertFrontendSplitProjectionSuccessor, frontendSplitProjectionSchema, } from "../../workflows/dag/frontend-split-application-service.js";
+import { buildFrontendHumanDecisionProjection, consumeFrontendHumanDecision, materializeFrontendHumanDecision, parseFrontendHumanDecisionProjection, parseFrontendHumanDecisionReceipt, } from "../../workflows/dag/frontend-human-decision.js";
+import { buildFrontendSplitAggregateCloseout, computeFrontendSplitDigest, finalizeFrontendSplitAggregate, frontendCommittedFactRefSchema, frontendSplitChildCloseoutFactsSchema, initializeFrontendSplitParent, } from "../../workflows/dag/frontend-split-orchestrator.js";
+import { frontendCloseoutFactsSchema, frontendTestHandoffSchema, } from "../../workflows/dag/frontend-closeout.js";
 import { listJsonFiles, readJsonIfExists, sha256Json, writeSecureJson, } from "./app-data.js";
 export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-out"]);
 function operationFile(appData, operationId) {
@@ -15,16 +19,21 @@ export function computeActionPayloadHash(action, actionParams) {
 export function newOperationId() {
     return `op_${randomBytes(12).toString("hex")}`;
 }
+const sharedWriteChains = new Map();
 export class OperationStore {
     appData;
-    /**
-     * Per-key write lock. Concurrent update/save/create on the same operation
-     * or clientRequestId must not race rename() into the same JSON path
-     * (Windows EPERM) or last-write-wins lost patches.
-     */
-    writeChains = new Map();
+    /** Shared per-store-root, per-key write lock. Multiple OperationStore instances
+     * in one worker process must observe the same CAS critical section. */
+    writeChains;
     constructor(appData) {
         this.appData = appData;
+        const root = path.resolve(appData.operations);
+        let chains = sharedWriteChains.get(root);
+        if (!chains) {
+            chains = new Map();
+            sharedWriteChains.set(root, chains);
+        }
+        this.writeChains = chains;
     }
     serialize(key, op) {
         const prev = this.writeChains.get(key) ?? Promise.resolve();
@@ -66,6 +75,7 @@ export class OperationStore {
                 payloadHash,
                 state: "queued",
                 createdAt: now,
+                revision: 1,
                 taskId: input.taskId,
                 cliArgs: input.cliArgs,
                 ...(input.externalCommand
@@ -77,11 +87,61 @@ export class OperationStore {
             return { kind: "created", operation };
         });
     }
+    /**
+     * Idempotently materialize a split child/integration operation with a
+     * caller-specified deterministic operationId (from the split manifest).
+     * Unlike create() (random op_<hex> id) and save/update (no create), this is
+     * the durable cross-restart idempotency boundary for the production
+     * FrontendSplitTaskMaterializer backend: an existing operation file with the
+     * same taskId + payloadHash is returned as {created:false}; any drift fails
+     * closed instead of overwriting or silently diverging.
+     */
+    async ensureSplitMaterializedOperation(input) {
+        return this.serialize(input.operationId, async () => {
+            const existing = await this.get(input.operationId);
+            if (existing) {
+                if (existing.taskId !== input.taskId ||
+                    existing.payloadHash !== input.payloadHash) {
+                    throw new Error("frontend split operation materialization payload drift");
+                }
+                return { operation: existing, created: false };
+            }
+            const now = new Date().toISOString();
+            const operation = {
+                schemaVersion: 1,
+                operationId: input.operationId,
+                clientRequestId: `split:${input.operationId}`,
+                action: input.action,
+                actionParams: input.actionParams,
+                payloadHash: input.payloadHash,
+                state: "queued",
+                createdAt: now,
+                revision: 1,
+                taskId: input.taskId,
+                ...(input.cliArgs ? { cliArgs: input.cliArgs } : {}),
+            };
+            await writeSecureJson(operationFile(this.appData, input.operationId), operation);
+            return { operation, created: true };
+        });
+    }
     async get(operationId) {
         return readJsonIfExists(operationFile(this.appData, operationId));
     }
     async save(operation) {
         return this.serialize(operation.operationId, async () => {
+            const current = await this.get(operation.operationId);
+            if (current?.revision !== undefined && operation.revision !== current.revision)
+                throw new Error("operation revision may not be changed by save");
+            if (operation.frontendHumanDecision !== undefined || current?.frontendHumanDecision !== undefined) {
+                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
+                    throw new Error("human-decision projection may only be mutated by canonical CAS");
+                return current;
+            }
+            if (operation.frontendSplit !== undefined || current?.frontendSplit !== undefined) {
+                if (!current || JSON.stringify(operation) !== JSON.stringify(current))
+                    throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
+                return current;
+            }
             await writeSecureJson(operationFile(this.appData, operation.operationId), operation);
             return operation;
         });
@@ -92,6 +152,10 @@ export class OperationStore {
             if (!current) {
                 throw new Error(`operation not found: ${operationId}`);
             }
+            if ("frontendHumanDecision" in patch || (current.frontendHumanDecision !== undefined && ("state" in patch || "frontendExecution" in patch)))
+                throw new Error("human-decision projection may only be mutated by canonical CAS");
+            if ("frontendSplit" in patch || "revision" in patch || (current.frontendSplit !== undefined && ("state" in patch || "frontendExecution" in patch)))
+                throw new Error("split projection may only be mutated by compareAndSwapFrontendSplit");
             const next = {
                 ...current,
                 ...patch,
@@ -106,6 +170,162 @@ export class OperationStore {
             return next;
         });
     }
+    async materializeFrontendHumanDecision(input) {
+        return this.serialize(input.operationId, async () => {
+            const current = await this.get(input.operationId);
+            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision) {
+                const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.envelope.runId, revision: Math.max(1, input.expectedRecordRevision) });
+                return { outcome: "rejected", reason: "record revision conflict or legacy record", projection: fallback };
+            }
+            const projection = current.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: current.operationId, runId: input.envelope.runId, revision: current.revision });
+            const result = materializeFrontendHumanDecision({ projection, envelope: input.envelope, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest });
+            if (result.outcome !== "applied")
+                return result;
+            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection, state: "running" };
+            await writeSecureJson(operationFile(this.appData, current.operationId), record);
+            return result;
+        });
+    }
+    async consumeFrontendHumanDecision(input) {
+        return this.serialize(input.operationId, async () => {
+            const current = await this.get(input.operationId);
+            if (!current || current.revision === undefined || !current.frontendHumanDecision) {
+                const fallback = buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
+                return { outcome: "rejected", reason: "record has no mutable human-decision projection", projection: fallback };
+            }
+            const projection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
+            if (current.revision !== input.expectedRecordRevision)
+                return { outcome: "rejected", reason: "record revision conflict", projection };
+            const result = consumeFrontendHumanDecision({ projection, receipt: input.receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
+            if (result.outcome !== "applied")
+                return result;
+            const record = { ...current, revision: result.projection.revision, frontendHumanDecision: result.projection };
+            await writeSecureJson(operationFile(this.appData, current.operationId), record);
+            return result;
+        });
+    }
+    async initializeFrontendHumanApprovedSplit(input) {
+        return this.serialize(input.operationId, async () => {
+            const current = await this.get(input.operationId);
+            const fallback = current?.frontendHumanDecision ?? buildFrontendHumanDecisionProjection({ status: "active", operationId: input.operationId, runId: input.receipt.runId, revision: Math.max(1, input.expectedRecordRevision) });
+            if (!current || current.revision === undefined || current.revision !== input.expectedRecordRevision || !current.frontendHumanDecision || !current.frontendExecution || current.frontendSplit)
+                return { outcome: "rejected", reason: "record is not an authoritative pending single-task split", projection: fallback };
+            const humanProjection = parseFrontendHumanDecisionProjection(current.frontendHumanDecision);
+            if (humanProjection.status !== "blocked-human" || humanProjection.envelope.kind !== "split-materialization-approval" || humanProjection.digest !== input.expectedProjectionDigest)
+                return { outcome: "rejected", reason: "pending split envelope conflict", projection: humanProjection };
+            const receipt = parseFrontendHumanDecisionReceipt(input.receipt);
+            if (receipt.kind !== "split-materialization-approval")
+                return { outcome: "rejected", reason: "receipt is not a split approval", projection: humanProjection };
+            if (JSON.stringify(current.frontendExecution) !== JSON.stringify(input.execution) || input.execution.kind !== "single-task")
+                return { outcome: "rejected", reason: "single-task execution conflict", projection: humanProjection };
+            const consumed = consumeFrontendHumanDecision({ projection: humanProjection, receipt, expectedRecordRevision: input.expectedRecordRevision, expectedProjectionDigest: input.expectedProjectionDigest, currentTargetDigest: input.currentTargetDigest, now: input.now });
+            if (consumed.outcome !== "applied")
+                return consumed;
+            const initialized = initializeFrontendSplitParent({
+                execution: input.execution,
+                manifest: input.manifest,
+                expectedOperationRevision: input.execution.operationRevision,
+                successorOperationRevision: consumed.projection.revision,
+                envelopeTargetDigest: humanProjection.envelope.targetDigest,
+                activeWriterOperationId: input.activeWriterOperationId,
+                activeProviderOperationId: input.activeProviderOperationId,
+                authorization: { mode: "human", envelope: humanProjection.envelope, receipt },
+            });
+            if (initialized.outcome !== "applied")
+                return { outcome: "rejected", reason: initialized.reason, projection: humanProjection };
+            const splitProjection = frontendSplitProjectionSchema.parse({ revision: consumed.projection.revision, execution: initialized.execution, manifest: input.manifest, parent: initialized.parent });
+            const { frontendExecution: _singleTask, ...withoutSingleTask } = current;
+            const record = { ...withoutSingleTask, revision: consumed.projection.revision, frontendHumanDecision: consumed.projection, frontendSplit: splitProjection, state: "running" };
+            await writeSecureJson(operationFile(this.appData, current.operationId), record);
+            return { outcome: "applied", projection: splitProjection, humanDecision: consumed.projection };
+        });
+    }
+    async compareAndSwapFrontendSplit(input) {
+        return this.serialize(input.operationId, async () => {
+            const current = await this.get(input.operationId);
+            if (!current || current.revision === undefined || current.revision !== input.expectedRevision)
+                return { outcome: "conflict" };
+            const currentProjection = current.frontendSplit;
+            if (currentProjection) {
+                if (currentProjection.execution.digest !== input.expectedExecutionDigest || currentProjection.parent.digest !== input.expectedParentDigest)
+                    return { outcome: "conflict" };
+            }
+            else if (input.expectedExecutionDigest || input.expectedParentDigest)
+                return { outcome: "conflict" };
+            const next = currentProjection
+                ? assertFrontendSplitProjectionSuccessor(currentProjection, input.next)
+                : frontendSplitProjectionSchema.parse(input.next);
+            if (next.revision !== current.revision + 1 || next.parent.operationId !== input.operationId)
+                throw new Error("split CAS next revision or operation binding mismatch");
+            const state = next.parent.operationState === "success" ? "succeeded" : next.parent.operationTerminal !== undefined ? "failed" : current.state;
+            const record = { ...current, revision: next.revision, frontendSplit: next, state };
+            await writeSecureJson(operationFile(this.appData, input.operationId), record);
+            return { outcome: "applied", projection: next };
+        });
+    }
+    async loadChildCloseoutFacts(input) {
+        const factsDir = input.closeoutRef.ref;
+        const facts = await readJsonIfExists(path.join(factsDir, "frontend-closeout-facts.json"));
+        if (facts === undefined)
+            return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: [], frontendTestHandoffRef: undefined });
+        const parsedFacts = frontendCloseoutFactsSchema.parse(facts);
+        if (computeFrontendSplitDigest(parsedFacts) !== input.closeoutRef.digest)
+            throw new Error(`child closeout facts digest mismatch: ${input.childId}`);
+        const handoff = await readJsonIfExists(path.join(factsDir, "frontend-test-handoff.json"));
+        const frontendTestHandoffRef = handoff === undefined ? undefined : computeFrontendSplitDigest(frontendTestHandoffSchema.parse(handoff));
+        return frontendSplitChildCloseoutFactsSchema.parse({ childId: input.childId, residualRisks: parsedFacts.residualRisks ?? [], frontendTestHandoffRef });
+    }
+    async settleFrontendSplitAggregate(input) {
+        return this.serialize(input.operationId, async () => {
+            const record = await this.get(input.operationId);
+            if (!record || record.revision === undefined || record.revision !== input.expectedRevision || !record.frontendSplit)
+                return { outcome: "conflict" };
+            const authoritative = frontendSplitProjectionSchema.parse(record.frontendSplit);
+            if (authoritative.parent.operationId !== input.operationId
+                || authoritative.revision !== input.expectedRevision
+                || authoritative.execution.digest !== input.expectedExecutionDigest
+                || authoritative.parent.digest !== input.expectedParentDigest
+                || authoritative.manifest.digest !== input.expectedManifestDigest
+                || authoritative.candidateBinding?.digest !== input.expectedCandidateBindingDigest
+                || authoritative.integrationBinding?.digest !== input.expectedIntegrationBindingDigest)
+                return { outcome: "conflict" };
+            if (!authoritative.candidateBinding)
+                return { outcome: "conflict" };
+            const expectedAggregate = buildFrontendSplitAggregateCloseout(authoritative.parent, authoritative.manifest, authoritative.candidateBinding, authoritative.integrationBinding, input.childCloseoutFacts);
+            if (JSON.stringify(expectedAggregate) !== JSON.stringify(input.aggregate))
+                return { outcome: "conflict" };
+            const transaction = await input.prepareAggregate({
+                operationId: authoritative.parent.operationId,
+                aggregate: expectedAggregate,
+            });
+            try {
+                const committedRef = frontendCommittedFactRefSchema.parse(transaction.committedRef);
+                const finalized = finalizeFrontendSplitAggregate(authoritative.parent, expectedAggregate, committedRef);
+                const next = assertFrontendSplitProjectionSuccessor(authoritative, { ...authoritative, revision: authoritative.revision + 1, parent: finalized.parent, execution: finalized.execution, aggregateCloseout: { value: expectedAggregate, committedRef } });
+                const nextRecord = { ...record, revision: next.revision, frontendSplit: next, state: "succeeded" };
+                await transaction.commit({
+                    parentRecordPath: operationFile(this.appData, record.operationId),
+                    parentRecord: nextRecord,
+                });
+                return { outcome: "applied", projection: next };
+            }
+            catch (error) {
+                await transaction.rollback();
+                throw error;
+            }
+        });
+    }
+    async initializeFrontendSplit(expectedRevision, projectionValue) {
+        const projection = frontendSplitProjectionSchema.parse(projectionValue);
+        return this.serialize(projection.parent.operationId, async () => {
+            const current = await this.get(projection.parent.operationId);
+            if (!current || current.revision === undefined || current.revision !== expectedRevision || current.frontendSplit !== undefined || projection.revision !== expectedRevision + 1)
+                return { outcome: "conflict" };
+            const record = { ...current, revision: projection.revision, frontendSplit: projection };
+            await writeSecureJson(operationFile(this.appData, current.operationId), record);
+            return { outcome: "applied", projection };
+        });
+    }
     async list() {
         const files = await listJsonFiles(this.appData.operations);
         const ops = [];

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,84 @@ 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));
+    }
+}
 export async function dispatchOperatorAction(ctx, req) {
     const action = req.action?.trim();
     if (!action) {
@@ -2078,12 +2236,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",
@@ -2092,6 +2273,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 +2287,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,
@@ -2122,6 +2315,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     clientRequestId,
                     "--reason",
                     reason,
+                    ...overrideArgs,
                     "--json",
                 ],
             });
@@ -2606,6 +2800,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-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 会话文件已丢失，无法恢复上下文。请新建对话继续（历史记录无法重开）。";