@tea-agent/loop-agent 0.43.0 → 0.44.0-next.10

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

@@ -1,15 +1,113 @@
 /**
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
-import { compareChatOrder } from "./turn-order.js";
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
 import { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
-function emptyGroup(key) {
+import { compareChatOrder } from "./turn-order.js";
+import { ensureLinkedSubmissionOrder } from "./timeline-message-order.js";
+function conversationNodeOrder(node) {
+    return { eventSeq: node.anchorSeq, createdAt: node.at };
+}
+function processItemOrder(item, group) {
+    const createdAt = item.createdAt ??
+        (item.kind === "tool" ? item.tool.createdAt : undefined) ??
+        group.assistants[0]?.createdAt ??
+        0;
+    const eventSeq = item.eventSeq ?? (item.kind === "tool" ? item.tool.eventSeq : undefined);
+    return eventSeq === undefined ? { createdAt } : { eventSeq, createdAt };
+}
+function compareFlowEntries(a, b) {
+    return compareChatOrder(a.order, b.order);
+}
+/** Base identity for a rendered process row. Content is deliberately excluded
+ * so streaming text updates keep the same React instance. */
+function processItemKey(item, order) {
+    if (item.kind === "tool")
+        return `tool:${item.tool.id}`;
+    if (item.kind === "activity")
+        return `activity:${item.activity.id}`;
+    if (item.kind === "dag-progress")
+        return `dag-progress:${item.progress.id}`;
+    const anchor = order.eventSeq ?? order.createdAt;
+    return `${item.kind}:${anchor}`;
+}
+export function turnProcessItemKey(item, occurrence = 0) {
+    const order = {
+        ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
+        createdAt: item.createdAt ?? (item.kind === "tool" ? item.tool.createdAt : 0),
+    };
+    const base = processItemKey(item, order);
+    return occurrence === 0 ? base : `${base}:${occurrence}`;
+}
+/**
+ * Project one turn into the same ordered buckets used by the main timeline and
+ * the trajectory view. Only existing request/running-step nodes are prelude;
+ * retry and other lifecycle nodes stay in the collapsible process window.
+ */
+export function projectTurnFlow(group) {
+    const conversationItems = group.conversationItems ?? [];
+    const prelude = conversationItems
+        .filter((item) => item.kind === "request" ||
+        (item.kind === "step" && item.node.status === "running"))
+        .sort((a, b) => compareChatOrder(conversationNodeOrder(a.node), conversationNodeOrder(b.node)));
+    const postAnswer = conversationItems
+        .filter((item) => item.kind === "max-tokens" || item.kind === "turn-error")
+        .sort((a, b) => compareChatOrder(conversationNodeOrder(a.node), conversationNodeOrder(b.node)));
+    const preludeKeys = new Set(prelude.map((item) => item.node.key));
+    const postAnswerKeys = new Set(postAnswer.map((item) => item.node.key));
+    const process = [];
+    for (const item of group.processItems) {
+        process.push({
+            source: "process",
+            key: "",
+            item,
+            order: processItemOrder(item, group),
+        });
+    }
+    for (const item of conversationItems) {
+        if (preludeKeys.has(item.node.key) || postAnswerKeys.has(item.node.key))
+            continue;
+        process.push({
+            source: "conversation",
+            key: `conversation:${item.node.key}`,
+            item,
+            order: conversationNodeOrder(item.node),
+        });
+    }
+    process.sort(compareFlowEntries);
+    const occurrences = new Map();
+    for (const entry of process) {
+        const base = entry.source === "conversation"
+            ? entry.key
+            : processItemKey(entry.item, entry.order);
+        const occurrence = occurrences.get(base) ?? 0;
+        occurrences.set(base, occurrence + 1);
+        entry.key = occurrence === 0 ? base : `${base}:${occurrence}`;
+    }
+    return { prelude, process, postAnswer };
+}
+/**
+ * Main-chat projection: request provenance and model-step bookkeeping remain
+ * available to Trajectory, but do not occupy the user-facing message stream.
+ */
+export function projectTimelineTurnFlow(group) {
+    const flow = projectTurnFlow(group);
+    return {
+        prelude: [],
+        process: flow.process.filter((entry) => entry.source === "process" ||
+            (entry.item.kind !== "request" && entry.item.kind !== "step")),
+        postAnswer: flow.postAnswer,
+    };
+}
+function emptyGroup(key, turnId) {
     return {
         key,
+        ...(turnId ? { turnId } : {}),
         assistants: [],
         tools: [],
         processItems: [],
+        conversationItems: [],
+        turnClosed: false,
         live: false,
     };
 }
@@ -45,6 +143,7 @@ export function hydrateSessionThread(raw) {
                 ...(item.clientRequestId ? { clientRequestId: item.clientRequestId } : {}),
                 ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
                 ...(item.turnId ? { turnId: item.turnId } : {}),
+                ...(item.attachments?.length ? { attachments: item.attachments } : {}),
             });
             continue;
         }
@@ -91,6 +190,10 @@ export function hydrateSessionThread(raw) {
                     ? finishedAtMs
                     : createdAt,
                 turnId: item.turnId ?? turnId,
+                ...(item.step === undefined ? {} : { step: item.step }),
+                ...(item.parentToolCallId
+                    ? { parentToolCallId: item.parentToolCallId }
+                    : {}),
                 ...(item.eventSeq === undefined ? {} : { eventSeq: item.eventSeq }),
                 ...(item.finishedSeq === undefined
                     ? {}
@@ -131,30 +234,52 @@ function flushToolBuffer(processItems, buffer) {
         return;
     const sorted = sortToolsStable(buffer);
     for (const tool of sorted) {
+        const order = {
+            ...(tool.eventSeq === undefined ? {} : { eventSeq: tool.eventSeq }),
+            createdAt: tool.createdAt,
+        };
         const dagProgress = dagProgressActivityForTool(tool);
         if (dagProgress) {
-            processItems.push({ kind: "dag-progress", progress: dagProgress });
+            processItems.push({
+                kind: "dag-progress",
+                progress: dagProgress,
+                toolCallCount: 1,
+                ...order,
+            });
             continue;
         }
         const activity = semanticActivityForTool(tool);
         if (activity) {
-            processItems.push({ kind: "activity", activity });
+            processItems.push({ kind: "activity", activity, toolCallCount: 1, ...order });
         }
         else {
-            processItems.push({ kind: "tool", tool });
+            processItems.push({ kind: "tool", tool, ...order });
         }
     }
 }
 function collapseDagProgressItems(items) {
-    const seen = new Set();
-    return items.filter((item) => {
-        if (item.kind !== "dag-progress")
-            return true;
-        if (seen.has(item.progress.activityRef))
-            return false;
-        seen.add(item.progress.activityRef);
-        return true;
-    });
+    const collapsed = [];
+    const progressIndexByRef = new Map();
+    for (const item of items) {
+        if (item.kind !== "dag-progress") {
+            collapsed.push(item);
+            continue;
+        }
+        const existingIndex = progressIndexByRef.get(item.progress.activityRef);
+        if (existingIndex === undefined) {
+            progressIndexByRef.set(item.progress.activityRef, collapsed.length);
+            collapsed.push(item);
+            continue;
+        }
+        const existing = collapsed[existingIndex];
+        if (existing?.kind === "dag-progress") {
+            collapsed[existingIndex] = {
+                ...existing,
+                toolCallCount: (existing.toolCallCount ?? 1) + (item.toolCallCount ?? 1),
+            };
+        }
+    }
+    return collapsed;
 }
 function fillProcessDetails(group) {
     const usedToolIds = new Set();
@@ -184,12 +309,24 @@ function fillProcessDetails(group) {
         };
         for (const block of blocks) {
             if (block.type === "thinking") {
-                items.push({ kind: "thinking", thinking: block.thinking });
+                items.push({
+                    kind: "thinking",
+                    thinking: block.thinking,
+                    ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                    createdAt: anchorAt,
+                });
                 continue;
             }
             if (block.type === "text") {
-                if (block.text.trim())
-                    items.push({ kind: "text", text: block.text });
+                if (block.text.trim()) {
+                    items.push({
+                        kind: "text",
+                        text: block.text,
+                        assistantMessageId: assistant.id,
+                        ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                        createdAt: anchorAt,
+                    });
+                }
                 continue;
             }
             const tool = group.tools.find((entry) => entry.id === block.toolCallId);
@@ -212,7 +349,12 @@ function fillProcessDetails(group) {
             anchorAt = tool.createdAt;
         }
         if (includeProviderError && assistant.providerError) {
-            items.push({ kind: "provider-error", error: assistant.providerError });
+            items.push({
+                kind: "provider-error",
+                error: assistant.providerError,
+                ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
+                createdAt: anchorAt,
+            });
         }
         flushItems();
         // Preserve the old-data fallback after this stage. Sequenced unmatched
@@ -245,8 +387,16 @@ function fillProcessDetails(group) {
         }
         addAssistantNode(assistant, getDisplayableAssistantBlocks(assistant.content ?? []));
     }
-    const blocks = finalAssistant?.content ?? [];
-    const split = splitFinalAssistantBlocks(blocks, { isStreaming: group.live });
+    const blocks = finalAssistant?.content ??
+        (finalAssistant?.text.trim()
+            ? [{ type: "text", text: finalAssistant.text }]
+            : []);
+    // Without durable step-completion metadata, only a normally settled Turn can
+    // prove that its latest assistant generation is a final answer. Keep partial
+    // text in process for running/aborted/failed and legacy unknown states.
+    const split = splitFinalAssistantBlocks(blocks, {
+        isStreaming: group.live || group.turnState !== "settled",
+    });
     if (finalAssistant) {
         addAssistantNode(finalAssistant, split.processBlocks);
     }
@@ -265,14 +415,13 @@ function fillProcessDetails(group) {
             items,
         });
     }
-    // Unified order (DSH rule): server seq is the single authoritative key,
-    // createdAt falls back, insertion order breaks remaining ties. No
-    // "fullySequenced" switch — a partially-sequenced group must not
-    // silently re-sort its peers by wall clock when most nodes carry seq.
+    const fullySequenced = nodes.every((node) => node.eventSeq !== undefined);
     nodes.sort((a, b) => {
-        const byOrder = compareChatOrder(a, b);
-        if (byOrder !== 0)
-            return byOrder;
+        if (fullySequenced && a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
         return a.insertionOrder - b.insertionOrder;
     });
     const processItems = nodes.flatMap((node) => node.items);
@@ -284,10 +433,6 @@ function fillProcessDetails(group) {
     group.processItems = collapseDagProgressItems(processItems);
     if (!finalAssistant)
         return;
-    if (blocks.length === 0) {
-        group.answer = finalAssistant;
-        return;
-    }
     if (split.answerBlocks.length === 0)
         return;
     const answerText = joinAssistantText(split.answerBlocks);
@@ -297,43 +442,49 @@ function fillProcessDetails(group) {
         content: split.answerBlocks,
     };
 }
-/**
- * Build user → process → answer groups for the message timeline.
- */
 export function buildTurnProcessGroups(input) {
-    const visible = input.messages
+    const visible = ensureLinkedSubmissionOrder(input.messages
         .filter((m) => m.role === "user" || m.role === "assistant")
-        .sort(compareChatOrder);
+        .sort((a, b) => {
+        if (a.eventSeq !== undefined &&
+            b.eventSeq !== undefined &&
+            a.eventSeq !== b.eventSeq) {
+            return a.eventSeq - b.eventSeq;
+        }
+        if (a.createdAt !== b.createdAt)
+            return a.createdAt - b.createdAt;
+        if (a.eventSeq !== undefined && b.eventSeq === undefined)
+            return 1;
+        if (a.eventSeq === undefined && b.eventSeq !== undefined)
+            return -1;
+        return 0;
+    }));
     const groups = [];
     let current = null;
-    const startGroup = (key) => {
-        const group = emptyGroup(key);
+    const startGroup = (key, turnId) => {
+        const group = emptyGroup(key, turnId);
         groups.push(group);
         return group;
     };
     for (const message of visible) {
         if (message.role === "user") {
-            current = startGroup(`user-${message.id}`);
+            current = startGroup(`user-${message.id}`, message.turnId);
             current.user = message;
-            if (message.turnId)
-                current.turnId = message.turnId;
             continue;
         }
         if (message.kind === "compaction") {
             // Compaction is a standalone timeline event. Starting a fresh group
             // prevents it from replacing the previous turn's assistant answer.
-            current = startGroup(`compaction-${message.id}`);
+            current = startGroup(`compaction-${message.id}`, message.turnId);
             current.assistants.push(message);
-            if (message.turnId)
-                current.turnId = message.turnId;
             current = null;
             continue;
         }
         if (!current)
-            current = startGroup(`assistant-${message.id}`);
-        current.assistants.push(message);
-        if (current.turnId === undefined && message.turnId)
+            current = startGroup(`assistant-${message.id}`, message.turnId);
+        if (!current.turnId && message.turnId)
             current.turnId = message.turnId;
+        current.assistants.push(message);
     }
     const assigned = new Set();
     const assistantToGroup = new Map();
@@ -355,10 +506,10 @@ export function buildTurnProcessGroups(input) {
         if (assigned.has(tool.id))
             continue;
         if (tool.turnId) {
-            const byTurn = groups.find((group) => group.turnId === tool.turnId ||
-                group.user?.turnId === tool.turnId ||
+            const byTurn = groups.find((group) => group.user?.turnId === tool.turnId ||
                 group.assistants.some((assistant) => assistant.turnId === tool.turnId) ||
                 group.tools.some((t) => t.turnId === tool.turnId) ||
+                group.key === `turn-${tool.turnId}` ||
                 (group.user && `restored-${group.user.id}` === tool.turnId));
             if (byTurn) {
                 byTurn.tools.push(tool);
@@ -374,25 +525,15 @@ export function buildTurnProcessGroups(input) {
             }
         }
     }
-    // Time-window fallback for legacy rows with neither assistantMessageId nor
-    // turnId. The window ends at the NEXT group's first anchor (user OR first
-    // assistant) — using POSITIVE_INFINITY would swallow every later group's
-    // tools when the very next group has no user message (e.g. compaction or a
-    // stand-alone assistant row), dumping one turn's bash cards into another.
     for (const tool of input.toolCalls) {
         if (assigned.has(tool.id))
             continue;
         const windowGroup = groups.find((group, index) => {
             const start = group.user?.createdAt ?? group.assistants[0]?.createdAt ?? 0;
-            let end = Number.POSITIVE_INFINITY;
-            for (let i = index + 1; i < groups.length; i += 1) {
-                const next = groups[i];
-                const nextAnchor = next?.user?.createdAt ?? next?.assistants[0]?.createdAt;
-                if (nextAnchor !== undefined) {
-                    end = nextAnchor;
-                    break;
-                }
-            }
+            const next = groups[index + 1];
+            const end = next?.user?.createdAt ??
+                next?.assistants[0]?.createdAt ??
+                Number.POSITIVE_INFINITY;
             return tool.createdAt >= start && tool.createdAt < end;
         });
         // Time window only. Never dump unmatched tools onto the latest group:
@@ -402,13 +543,43 @@ export function buildTurnProcessGroups(input) {
             assigned.add(tool.id);
         }
     }
+    for (const node of input.conversationNodes ?? []) {
+        if (node.location.kind === "session")
+            continue;
+        const turnId = node.location.turnId;
+        if (!groups.some((group) => group.turnId === turnId)) {
+            startGroup(`turn-${turnId}`, turnId);
+        }
+    }
     for (const group of groups) {
-        group.tools.sort(compareChatOrder);
+        group.tools.sort((a, b) => {
+            if (a.eventSeq !== undefined && b.eventSeq !== undefined) {
+                return a.eventSeq - b.eventSeq;
+            }
+            return a.createdAt - b.createdAt;
+        });
+        const turnState = group.turnId
+            ? input.turnStatesById?.[group.turnId]
+            : undefined;
+        if (turnState !== undefined)
+            group.turnState = turnState;
+        group.turnClosed =
+            turnState === "settled" ||
+                turnState === "aborted" ||
+                turnState === "failed";
+        const targetsActiveAssistant = input.activeAssistantId !== null &&
+            group.assistants.some((assistant) => assistant.id === input.activeAssistantId);
         group.live =
             input.streaming &&
-                input.activeAssistantId !== null &&
-                group.assistants.some((a) => a.id === input.activeAssistantId);
+                !group.turnClosed &&
+                (targetsActiveAssistant || turnState === "running");
         fillProcessDetails(group);
+        group.conversationItems = (input.conversationNodes ?? [])
+            .filter((node) => node.location.kind !== "session" && node.location.turnId === group.turnId)
+            .map((node) => ({ kind: node.kind, node }));
+        if (group.conversationItems.some((item) => item.kind === "turn-error")) {
+            group.processItems = group.processItems.filter((item) => item.kind !== "provider-error");
+        }
     }
     return groups;
 }

package/dist/worker/console/chat/user-turn-outline.js

@@ -0,0 +1,19 @@
+const PREVIEW_LIMIT = 160;
+/** Project the complete durable user-message index without shipping full history. */
+export function projectUserTurnOutline(messages) {
+    let index = 0;
+    return messages.flatMap((message) => {
+        if (message.role !== "user")
+            return [];
+        index += 1;
+        const flat = message.text.trim().replace(/\s+/g, " ");
+        return [{
+                messageId: message.id,
+                index,
+                textPreview: flat.length > PREVIEW_LIMIT
+                    ? `${flat.slice(0, PREVIEW_LIMIT).trimEnd()}…`
+                    : flat,
+                createdAt: Date.parse(message.at) || 0,
+            }];
+    });
+}

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

@@ -4,7 +4,7 @@ import { createNpmUpdateClient } from "../../shared/update/npm-client.js";
 import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
 import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
 import { performConsoleUpdateAndInit, } from "./console-update-and-init.js";
-import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
+import { isOperationOccupied, } from "../../infrastructure/console/operation-store.js";
 export function createConsoleUpdateExecutor(input) {
     return async (channel) => {
         const currentVersion = readPackageVersion(input.packageRoot);
@@ -49,7 +49,7 @@ export function createConsoleUpdateExecutor(input) {
                     };
                 }
                 const liveOtherOperation = operations.some((operation) => operation.action !== "consoleUpdateAndInit" &&
-                    !TERMINAL_OPERATION_STATES.has(operation.state));
+                    isOperationOccupied(operation.state));
                 return liveOtherOperation
                     ? {
                         ok: false,

package/dist/worker/console/dag-confirmation.js

@@ -142,6 +142,9 @@ export class DagConfirmationStore {
             preparedAt: now.toISOString(),
             expiresAt,
             operatorSessionId: input.operatorSessionId,
+            ...(input.telemetrySessionId
+                ? { telemetrySessionId: input.telemetrySessionId }
+                : {}),
             dagHandle: input.dagHandle,
             dagSha256,
             dagBytesPath: input.dagBytesPath,

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

@@ -286,6 +286,9 @@ export class DagExecutionReceiptStore {
             preparedAt: now.toISOString(),
             expiresAt: new Date(now.getTime() + ttl).toISOString(),
             operatorSessionId: input.operatorSessionId,
+            ...(input.telemetrySessionId
+                ? { telemetrySessionId: input.telemetrySessionId }
+                : {}),
             taskId: input.taskId,
             dagHandle: input.dagHandle,
             dagSha256: hashDagBytes(input.dagBytes),

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

@@ -35,6 +35,7 @@ import { evaluateConsoleDagInterruptEligibility } from "../observability/interru
 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";
+import { DAG_TELEMETRY_SESSION_ID_ENV, isTelemetrySessionId, } from "../../shared/wizard-local-telemetry.js";
 const MUTATION_GATE_ACTIONS = new Set([
     // 2026-08-11: standaloneTaskRerun / workerTaskRetry are autonomous (server
     // run-facts checks). Destructive DAG reconciliation, live cooperative
@@ -565,7 +566,11 @@ export async function acceptOperation(ctx, input) {
         events: ctx.events,
         client: ctx.client,
         repoRoot: ctx.repoRoot,
-        env: { ...process.env, LOOP_CONSOLE_APP_DATA: ctx.appData.root },
+        env: {
+            ...process.env,
+            LOOP_CONSOLE_APP_DATA: ctx.appData.root,
+            ...input.env,
+        },
         runCommand: ctx.runCommand,
         beforeTerminal: input.beforeTerminal,
         onSettled: async (operation, state, info) => {
@@ -822,6 +827,21 @@ async function acceptConsoleUpdateAndInit(ctx, clientRequestId, channel) {
         },
     };
 }
+async function resolvePreparedDagTelemetrySessionId(ctx) {
+    if (!ctx.chatSessionRef || !ctx.sddDataAlignment)
+        return undefined;
+    if (!(await ctx.sddDataAlignment.isEligible()))
+        return undefined;
+    return ctx.sddDataAlignment.ensureTelemetrySessionId(ctx.chatSessionRef);
+}
+async function resolveDagTelemetryEnv(ctx, telemetrySessionId) {
+    if (!isTelemetrySessionId(telemetrySessionId) ||
+        !ctx.sddDataAlignment ||
+        !(await ctx.sddDataAlignment.isEligible())) {
+        return undefined;
+    }
+    return { [DAG_TELEMETRY_SESSION_ID_ENV]: telemetrySessionId };
+}
 export async function dispatchOperatorAction(ctx, req) {
     const action = req.action?.trim();
     if (!action) {
@@ -1668,8 +1688,10 @@ export async function dispatchOperatorAction(ctx, req) {
                 canonicalizerVersion: ref.canonicalizerVersion,
                 taskConfigSchemaVersion: ref.taskConfigSchemaVersion,
             };
+            const telemetrySessionId = await resolvePreparedDagTelemetrySessionId(ctx);
             const confirmation = await ctx.confirmations.prepare({
                 operatorSessionId: ctx.operatorSessionId,
+                ...(telemetrySessionId ? { telemetrySessionId } : {}),
                 dagHandle,
                 dagBytes: dagText,
                 dagBytesPath: staged.path,
@@ -1910,8 +1932,10 @@ export async function dispatchOperatorAction(ctx, req) {
                     }),
                 };
             }
+            const telemetrySessionId = await resolvePreparedDagTelemetrySessionId(ctx);
             const prepared = await ctx.dagExecutionReceipts.prepare({
                 operatorSessionId: ctx.operatorSessionId,
+                ...(telemetrySessionId ? { telemetrySessionId } : {}),
                 taskId,
                 dagHandle: "staged-dag.json",
                 dagBytes: dagText,
@@ -2350,7 +2374,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 if (!confirmationId) {
                     return invalid(action, "runDag requires executionId (autonomous) or confirmationId (browser Human Gate)");
                 }
-                // Preserved browser Human Gate flow (dag-confirmation.ts untouched).
+                // Preserved browser Human Gate flow.
                 const conf = await ctx.confirmations.get(confirmationId);
                 if (!conf) {
                     return {
@@ -2409,12 +2433,14 @@ export async function dispatchOperatorAction(ctx, req) {
                 }
                 const taskId = conf.taskContractBinding.taskId;
                 const gateToken = readWriteSetGateToken(conf.reviewPacket);
+                const dagTelemetryEnv = await resolveDagTelemetryEnv(ctx, conf.telemetrySessionId);
                 if (gateToken) {
                     return acceptOperation(ctx, {
                         action,
                         actionParams: { confirmationId },
                         clientRequestId,
                         taskId,
+                        env: dagTelemetryEnv,
                         cliArgs: [
                             "task",
                             "advance",
@@ -2430,6 +2456,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     actionParams: { confirmationId },
                     clientRequestId,
                     taskId,
+                    env: dagTelemetryEnv,
                     cliArgs: [
                         "dag",
                         "execute",
@@ -2503,6 +2530,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const gateToken = readWriteSetGateToken(receipt.reviewPacket);
+            const dagTelemetryEnv = await resolveDagTelemetryEnv(ctx, receipt.telemetrySessionId);
             const dispatchRun = async () => {
                 if (gateToken) {
                     // Standard lifecycle path: the execution receipt replaces the
@@ -2512,6 +2540,7 @@ export async function dispatchOperatorAction(ctx, req) {
                         actionParams: { executionId },
                         clientRequestId,
                         taskId,
+                        env: dagTelemetryEnv,
                         cliArgs: [
                             "task",
                             "advance",
@@ -2528,6 +2557,7 @@ export async function dispatchOperatorAction(ctx, req) {
                     actionParams: { executionId },
                     clientRequestId,
                     taskId,
+                    env: dagTelemetryEnv,
                     cliArgs: [
                         "dag",
                         "execute",
@@ -2759,7 +2789,6 @@ export async function dispatchOperatorAction(ctx, req) {
                     reconcileAction,
                     "--reason",
                     reason,
-                    "--json",
                 ],
             });
             await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);

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

@@ -114,7 +114,7 @@ const CONTEXT_TRANSFER_CODE_COPY = [
     },
     {
         pattern: /\bOPERATION_NEEDS_RECONCILE\b/,
-        copy: "操作记录需要先恢复核对（OPERATION_NEEDS_RECONCILE）：上次执行未确认结束，请刷新操作状态后重试。",
+        copy: "当前操作的执行结果尚未确认，需要先核对（OPERATION_NEEDS_RECONCILE）。请查看操作记录和相关任务状态，核对实际执行结果后再决定后续操作；确认前请勿重复提交。"
     },
     {
         pattern: /\bCONTEXT_EXPORT_FAILED\b/,
@@ -169,6 +169,33 @@ const CONTEXT_TRANSFER_CODE_COPY = [
         pattern: /\bINVALID_VERSION\b/,
         copy: "安装版本或渠道版本号无法解析（INVALID_VERSION），请重试；若持续出现请反馈。",
     },
+    // 源绑定漂移（dag-confirmation.ts / dag-execution-receipt.ts 的英文原文）
+    // 与 frontend split CAS 冲突（operator-actions.ts）原本会原样透传到操作者
+    // 横幅，这里给出可执行的中文说明。
+    {
+        pattern: /\bBINDING_DRIFT\b|\bbinding drift\b|\bbinding drifted\b/i,
+        copy: "这次确认所依据的内容已经变了（任务契约、源文件、程序版本或校验结果在确认之后被修改），因此旧确认不能再使用。这是保护措施，不是故障：请回到任务页重新生成确认，然后重新开始运行。",
+    },
+    {
+        pattern: /frontend split CAS conflict/i,
+        copy: "前端拆分任务的状态在你操作期间被其他操作改过了（通常是另一个标签页或并发操作），为避免覆盖对方的结果，本次修改没有生效。请刷新页面，确认当前状态后重试。",
+    },
+    {
+        pattern: /\bCONFIRMATION_EXPIRED\b/,
+        copy: "这次确认已经超时失效。请回到任务页重新生成确认后再继续。",
+    },
+    {
+        pattern: /\bCONFIRMATION_STALE\b/,
+        copy: "这次确认对应的是改动之前的内容，已经过期作废。请回到任务页重新生成确认后再继续。",
+    },
+    {
+        pattern: /\bCONFIRMATION_CONSUMED\b/,
+        copy: "这次确认已经被使用过了，不能重复提交。如需再次执行，请重新生成确认。",
+    },
+    {
+        pattern: /\bHUMAN_CONFIRMATION_REQUIRED\b/,
+        copy: "这一步需要你先在页面上确认一次才能继续。请按提示完成确认后再重试。",
+    },
 ];
 /** Map internal spawn/controller errors to actionable Chinese copy. */
 export function formatOperatorUserError(message) {