@tea-agent/loop-agent 0.44.0-next.6 → 0.44.0-next.8

package/dist/worker/console/chat/routes.js

@@ -19,6 +19,7 @@ import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_
 import { InvalidChatSessionModeError, SESSION_MODE_ACTION_DENIED_CODE, SESSION_MODE_ACTION_DENIED_MESSAGE, SESSION_MODE_IMMUTABLE_CODE, UnknownChatSessionModeError, isWorkflowSessionMode, parseCreateSessionMode, readStoredSessionMode, shouldAcceptOperatorSnapshot, } from "./session-mode.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle, acceptedOperationIdFromResult, isBlankChatSession } from "./session-store.js";
+import { projectUserTurnOutline } from "./user-turn-outline.js";
 import { hashChatTurnPayload, projectChatToolEventPayload, projectUnknownChatEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { projectDeferredTurnSummary, projectDeferredTurnSummaries, } from "./deferred-turn.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
@@ -231,6 +232,43 @@ function turnSummary(turn) {
         abortRequestedAt: turn.abortRequestedAt ?? null,
     };
 }
+function turnStateSummary(turn) {
+    return {
+        turnId: turn.turnId,
+        state: turn.state === "queued" ? "running" : turn.state,
+    };
+}
+function turnStatesForIds(events, sessionId, turnIds) {
+    const projected = new Map();
+    for (const turnId of turnIds) {
+        if (!turnId || projected.has(turnId))
+            continue;
+        const turn = events.getTurn(sessionId, turnId);
+        if (turn)
+            projected.set(turnId, turnStateSummary(turn));
+    }
+    return [...projected.values()];
+}
+const MAX_STATE_QUERY_TURN_IDS = 8;
+const MAX_STATE_QUERY_TURN_ID_CHARS = 240;
+function requestedStateTurnIds(req) {
+    const result = [];
+    const seen = new Set();
+    const url = new URL(req.url ?? "/", "http://localhost");
+    for (const raw of url.searchParams.getAll("turnId")) {
+        const turnId = raw.trim();
+        if (!turnId ||
+            turnId.length > MAX_STATE_QUERY_TURN_ID_CHARS ||
+            seen.has(turnId)) {
+            continue;
+        }
+        seen.add(turnId);
+        result.push(turnId);
+        if (result.length >= MAX_STATE_QUERY_TURN_IDS)
+            break;
+    }
+    return result;
+}
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
@@ -421,6 +459,20 @@ export function turnEventToStorePartial(event) {
                         : {}),
                 }),
             };
+        case "tool_update":
+            return {
+                kind: "tool_update",
+                data: projectChatToolEventPayload({
+                    kind: "tool_update",
+                    toolCallId: String(event.toolCallId ?? ""),
+                    toolName: String(event.toolName ?? ""),
+                    value: event.partialResult,
+                    ...(typeof event.step === "number" ? { step: event.step } : {}),
+                    ...(typeof event.parentToolCallId === "string"
+                        ? { parentToolCallId: event.parentToolCallId }
+                        : {}),
+                }),
+            };
         case "tool_result": {
             // Plan A (2026-08-16): surface the accepted-operation link on the live
             // SSE frame so the frontend semantic event can resolve operation:<id>.
@@ -924,25 +976,47 @@ export async function handleForkChatSession(req, res, deps, sourceSessionId) {
         });
         return;
     }
+    let forkedHandle;
+    let forkPersisted = false;
     try {
+        const body = await readJsonBody(req);
+        const throughMessageId = typeof body.throughMessageId === "string" && body.throughMessageId.trim()
+            ? body.throughMessageId.trim()
+            : undefined;
+        const throughUserMessageIndex = throughMessageId
+            ? source.messages
+                .filter((message) => message.role === "user")
+                .findIndex((message) => message.id === throughMessageId)
+            : undefined;
+        if (throughMessageId && throughUserMessageIndex === -1) {
+            throw new Error("FORK_MESSAGE_NOT_FOUND");
+        }
         const handle = await deps.runtime.forkSession({
             sourceSessionFile: source.sessionFile ?? "",
             sessionMode: source.sessionMode,
             ...(source.modelProvider && source.modelId
                 ? { model: { provider: source.modelProvider, modelId: source.modelId } }
                 : {}),
+            ...(throughUserMessageIndex !== undefined
+                ? { throughUserMessageIndex }
+                : {}),
         });
+        forkedHandle = handle;
         await deps.store.forkFrom({
             sourceSessionId,
             targetSessionId: handle.sessionId,
             targetSessionFile: handle.sessionFile,
+            ...(throughMessageId ? { throughMessageId } : {}),
         });
+        forkPersisted = true;
         await deps.attachSession?.(handle.sessionId).catch(() => undefined);
-        const copied = deps.events.forkContextRefs({
-            sourceSessionId,
-            targetSessionId: handle.sessionId,
-            targetTurnId: `${handle.sessionId}:fork`,
-        });
+        const copied = throughMessageId
+            ? { copiedCount: 0 }
+            : deps.events.forkContextRefs({
+                sourceSessionId,
+                targetSessionId: handle.sessionId,
+                targetTurnId: `${handle.sessionId}:fork`,
+            });
         await deps.operationLinker.recoverSession(handle.sessionId);
         sendJson(res, 201, {
             ok: true,
@@ -956,6 +1030,12 @@ export async function handleForkChatSession(req, res, deps, sourceSessionId) {
         });
     }
     catch (error) {
+        if (forkedHandle && !forkPersisted) {
+            deps.runtime.dispose(forkedHandle.sessionId);
+            await deps.store
+                .discardUnownedSession(forkedHandle.sessionId, forkedHandle.sessionFile)
+                .catch(() => undefined);
+        }
         sendJson(res, 409, {
             ok: false,
             error: {
@@ -1105,12 +1185,18 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
     const sddSessionIdentity = deps.sddDataAlignment && (await deps.sddDataAlignment.isEligible())
         ? { telemetrySessionId: record.telemetrySessionId ?? null }
         : undefined;
+    const projectedMessages = projectStoredMessagesWithEventOrder(messagePage.messages, snapshot);
+    const turnStates = turnStatesForIds(deps.events, sessionId, [
+        ...projectedMessages.map((message) => message.turnId),
+        ...snapshot.map((event) => event.turnId),
+    ]);
     sendJson(res, 200, {
         ok: true,
         eventEpoch: deps.events.epoch(sessionId),
         session: {
             ...projectBrowserChatSession(record),
-            messages: projectStoredMessagesWithEventOrder(messagePage.messages, snapshot),
+            messages: projectedMessages,
+            turnStates,
             composerDraft,
             activeTurnId: activeTurn?.turnId,
             turnPhase: activeTurn
@@ -1130,6 +1216,7 @@ export async function handleGetChatSession(_req, res, deps, sessionId) {
         sessionStats: telemetry.stats,
         usage: telemetry.usage,
         turnTelemetry: deriveChatTurnTelemetry(snapshot),
+        userTurnOutline: projectUserTurnOutline(record.messages ?? []),
         ...(sddSessionIdentity
             ? { sddDataAlignment: sddSessionIdentity }
             : {}),
@@ -1408,7 +1495,14 @@ function emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientReques
         data: {
             ...(clientRequestId ? { clientRequestId } : {}),
             ...(steering ? { steering: true } : {}),
-            message: { id: userMessage.id, text: userMessage.text, at: userMessage.at },
+            message: {
+                id: userMessage.id,
+                text: userMessage.text,
+                at: userMessage.at,
+                ...(userMessage.attachments?.length
+                    ? { attachments: userMessage.attachments }
+                    : {}),
+            },
         },
     });
 }
@@ -1416,7 +1510,7 @@ function emitUserMessageEvent(deps, sessionId, turnId, userMessage, clientReques
  *  get_state equivalent): exposes the active turn + the latest turn's durable
  *  outcome WITHOUT the full message payload, so the UI can poll it on an
  *  interval / visibility / online without paying for session detail. */
-export async function handleGetChatSessionState(_req, res, deps, sessionId) {
+export async function handleGetChatSessionState(req, res, deps, sessionId) {
     const record = await deps.store.get(sessionId);
     if (!record) {
         sendJson(res, 404, {
@@ -1447,9 +1541,15 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
         : runtimeBusy
             ? "running"
             : "idle";
+    const turnStates = turnStatesForIds(deps.events, sessionId, [
+        active?.turnId,
+        latest?.turnId,
+        ...requestedStateTurnIds(req),
+    ]);
     sendJson(res, 200, {
         ok: true,
         state: {
+            turnStates,
             // Legacy flat fields retained for older clients.
             activeTurnId: active?.turnId ?? null,
             activeTurnState: active?.state ?? null,
@@ -4484,7 +4584,14 @@ export async function handleChatMessages(res, deps, sessionId, url) {
             limit: Number.isFinite(limit) ? limit : 30,
             beforeId: url.searchParams.get("beforeId") ?? undefined,
         });
-        sendJson(res, 200, { ok: true, ...page });
+        const snapshot = deps.events.snapshot(sessionId);
+        const messages = projectStoredMessagesWithEventOrder(page.messages, snapshot);
+        sendJson(res, 200, {
+            ok: true,
+            ...page,
+            messages,
+            turnStates: turnStatesForIds(deps.events, sessionId, messages.map((message) => message.turnId)),
+        });
     }
     catch (error) {
         sendJson(res, 404, {
@@ -4496,6 +4603,23 @@ export async function handleChatMessages(res, deps, sessionId, url) {
         });
     }
 }
+export async function handleChatAttachment(res, deps, sessionId, attachmentId) {
+    const attachment = await deps.store.readAttachment(sessionId, attachmentId);
+    if (!attachment) {
+        sendJson(res, 404, {
+            ok: false,
+            error: { code: "NOT_FOUND", message: "chat attachment not found" },
+        });
+        return;
+    }
+    res.writeHead(200, {
+        "content-type": attachment.metadata.mimeType,
+        "content-length": String(attachment.bytes.length),
+        "cache-control": "private, max-age=31536000, immutable",
+        "x-content-type-options": "nosniff",
+    });
+    res.end(attachment.bytes);
+}
 /**
  * Dispatch a chat HTTP request. Returns true if handled.
  * Mounted under /api/operator/v1/chat/*.
@@ -4933,6 +5057,11 @@ async function dispatchChatRequest(req, res, deps, pathname, workspaceScope) {
         await handleChatMessages(res, deps, decodeURIComponent(sessionMessages[1]), url);
         return true;
     }
+    const sessionAttachment = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/attachments\/([^/]+)$/);
+    if (method === "GET" && sessionAttachment) {
+        await handleChatAttachment(res, deps, decodeURIComponent(sessionAttachment[1]), decodeURIComponent(sessionAttachment[2]));
+        return true;
+    }
     const sessionPrompt = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/prompt$/);
     if (method === "POST" && sessionPrompt) {
         await handleChatPrompt(req, res, deps, decodeURIComponent(sessionPrompt[1]));

package/dist/worker/console/chat/session-store.js

@@ -11,7 +11,8 @@
  * operator action call. Every invocation is re-authorized here.
  */
 import path from "node:path";
-import { readdir, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { copyFile, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { readJsonIfExists, writeSecureJson, } from "../../../infrastructure/console/app-data.js";
 import { dispatchOperatorAction } from "../operator-actions.js";
 import { authorizeOperatorChatTool } from "./tools.js";
@@ -19,6 +20,18 @@ import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, readStored
 import { projectOperationForChat } from "./chat-event-store.js";
 import { scrubSecrets } from "./explore-tools.js";
 import { hashDeferredTurnPayload, parseDeferredTurns, } from "./deferred-turn.js";
+const CHAT_IMAGE_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+function isChatImageMimeType(value) {
+    return typeof value === "string" && CHAT_IMAGE_MIME_TYPES.has(value);
+}
+function isChatAttachmentId(value) {
+    return typeof value === "string" && /^[0-9a-f-]{36}$/i.test(value);
+}
 /** True only for a durable session that has never received user work. */
 export function isBlankChatSession(record) {
     return (record.state === "active" &&
@@ -48,6 +61,11 @@ export function cleanChatTitle(value) {
 function recordPath(appData, sessionId) {
     return path.join(appData.chats, `${sessionId}.json`);
 }
+function attachmentDir(appData, sessionId) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(sessionId))
+        throw new Error("invalid chat session id");
+    return path.join(appData.chats, "attachments", sessionId);
+}
 /** True when `sessionFile` lives inside this store's dedicated Pi JSONL dir. */
 export function isConsoleOwnedSessionFile(appData, sessionFile) {
     const value = sessionFile?.trim();
@@ -196,6 +214,12 @@ export class ChatSessionStore {
         const source = await this.get(input.sourceSessionId);
         if (!source)
             throw new Error(`chat session not found: ${input.sourceSessionId}`);
+        const throughIndex = input.throughMessageId
+            ? source.messages.findIndex((message) => message.id === input.throughMessageId && message.role === "user")
+            : -1;
+        if (input.throughMessageId && throughIndex < 0) {
+            throw new Error("FORK_MESSAGE_NOT_FOUND");
+        }
         return this.serialize(input.targetSessionId, async () => {
             const now = new Date().toISOString();
             const record = {
@@ -208,11 +232,30 @@ export class ChatSessionStore {
                 updatedAt: now,
                 deferredTurns: [],
                 deferredQueueRevision: 0,
-                messages: structuredClone(source.messages),
-                toolInvocations: structuredClone(source.toolInvocations),
+                messages: structuredClone(throughIndex >= 0
+                    ? source.messages.slice(0, throughIndex + 1)
+                    : source.messages),
+                toolInvocations: throughIndex >= 0 ? [] : structuredClone(source.toolInvocations),
             };
-            await this.persist(record);
-            return record;
+            const attachmentIds = record.messages.flatMap((message) => Array.isArray(message.attachments)
+                ? message.attachments.map((attachment) => attachment.id)
+                : []);
+            if (!attachmentIds.every(isChatAttachmentId)) {
+                throw new Error("INVALID_CHAT_ATTACHMENT_REFERENCE");
+            }
+            try {
+                if (attachmentIds.length > 0) {
+                    const targetDir = attachmentDir(this.appData, input.targetSessionId);
+                    await mkdir(targetDir, { recursive: true });
+                    await Promise.all(attachmentIds.map((attachmentId) => copyFile(path.join(attachmentDir(this.appData, input.sourceSessionId), attachmentId), path.join(targetDir, attachmentId))));
+                }
+                await this.persist(record);
+                return record;
+            }
+            catch (error) {
+                await this.removeAttachmentFiles(input.targetSessionId).catch(() => undefined);
+                throw error;
+            }
         });
     }
     /** Atomically backfill the per-conversation simulated identity on first use. */
@@ -286,17 +329,84 @@ export class ChatSessionStore {
             const record = await this.get(sessionId);
             if (!record)
                 return false;
-            const sessionFile = record.sessionFile;
-            await rm(recordPath(this.appData, sessionId), { force: true });
-            this.options.onRecordChange?.(sessionId, undefined);
-            // Record first, then best-effort JSONL unlink. Final consistency is
-            // "both gone" — a leftover JSONL is harmless, a leftover record is not.
-            if (isConsoleOwnedSessionFile(this.appData, sessionFile) && sessionFile) {
-                await rm(sessionFile, { force: true }).catch(() => undefined);
-            }
+            await this.removeSessionArtifacts(sessionId, record.sessionFile);
             return true;
         });
     }
+    /** Roll back a runtime-created session that never acquired a durable owner. */
+    async discardUnownedSession(sessionId, sessionFile) {
+        await this.serialize(sessionId, () => this.removeSessionArtifacts(sessionId, sessionFile));
+    }
+    async removeSessionArtifacts(sessionId, sessionFile) {
+        await rm(recordPath(this.appData, sessionId), { force: true });
+        await this.removeAttachmentFiles(sessionId).catch(() => undefined);
+        this.options.onRecordChange?.(sessionId, undefined);
+        // Record first, then best-effort JSONL unlink. Final consistency is
+        // "both gone" — a leftover JSONL is harmless, a leftover record is not.
+        if (isConsoleOwnedSessionFile(this.appData, sessionFile) && sessionFile) {
+            await rm(sessionFile, { force: true }).catch(() => undefined);
+        }
+    }
+    async removeAttachmentFiles(sessionId, attachmentIds) {
+        const dir = attachmentDir(this.appData, sessionId);
+        if (!attachmentIds) {
+            await rm(dir, { recursive: true, force: true });
+            return;
+        }
+        await Promise.all(attachmentIds.map((attachmentId) => rm(path.join(dir, attachmentId), { force: true })));
+    }
+    async saveAttachments(sessionId, images) {
+        if (images.length === 0)
+            return [];
+        if (!(await this.get(sessionId)))
+            throw new Error(`chat session not found: ${sessionId}`);
+        const dir = attachmentDir(this.appData, sessionId);
+        await mkdir(dir, { recursive: true });
+        const stored = [];
+        try {
+            for (const [index, image] of images.entries()) {
+                if (!isChatImageMimeType(image.mimeType)) {
+                    throw new Error("unsupported chat attachment mime type");
+                }
+                const id = randomUUID();
+                const bytes = Buffer.from(image.data, "base64");
+                await writeFile(path.join(dir, id), bytes, { flag: "wx", mode: 0o600 });
+                stored.push({
+                    id,
+                    name: `图片 ${index + 1}`,
+                    mimeType: image.mimeType,
+                    byteLength: bytes.length,
+                });
+            }
+        }
+        catch (error) {
+            await this.removeAttachmentFiles(sessionId, stored.map((attachment) => attachment.id)).catch(() => undefined);
+            throw error;
+        }
+        return stored;
+    }
+    async readAttachment(sessionId, attachmentId) {
+        if (!isChatAttachmentId(attachmentId))
+            return undefined;
+        const record = await this.get(sessionId);
+        const metadata = record?.messages
+            .flatMap((message) => Array.isArray(message.attachments) ? message.attachments : [])
+            .find((attachment) => attachment.id === attachmentId);
+        if (!metadata || !isChatImageMimeType(metadata.mimeType))
+            return undefined;
+        try {
+            return {
+                metadata,
+                bytes: await readFile(path.join(attachmentDir(this.appData, sessionId), attachmentId)),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async removeAttachments(sessionId, attachments) {
+        await this.removeAttachmentFiles(sessionId, attachments.map((attachment) => attachment.id));
+    }
     async putDeferredTurn(sessionId, input) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -454,11 +564,13 @@ export class ChatSessionStore {
             const deferredTurn = index >= 0 ? queue[index] : undefined;
             if (!deferredTurn || deferredTurn.state !== "dispatching")
                 return undefined;
+            const attachments = await this.saveAttachments(sessionId, deferredTurn.images);
             const message = {
                 id: `m_${record.messages.length + 1}_${Math.random().toString(36).slice(2, 8)}`,
                 role: "user",
                 text,
                 at: new Date().toISOString(),
+                ...(attachments.length > 0 ? { attachments } : {}),
             };
             queue.splice(index, 1);
             record.messages.push(message);
@@ -468,7 +580,13 @@ export class ChatSessionStore {
             if (!record.displayTitle)
                 record.displayTitle = cleanChatTitle(message.text);
             record.updatedAt = message.at;
-            await this.persist(record);
+            try {
+                await this.persist(record);
+            }
+            catch (error) {
+                await this.removeAttachments(sessionId, attachments).catch(() => undefined);
+                throw error;
+            }
             return {
                 record,
                 message,
@@ -623,11 +741,20 @@ export async function runChatTurn(options) {
         };
     }
     if (options.persistUserMessage !== false) {
-        const userMessage = await store.appendMessage(sessionId, {
-            role: "user",
-            text,
-            ...(options.clientRequestId ? { clientRequestId: options.clientRequestId } : {}),
-        });
+        const attachments = await store.saveAttachments(sessionId, options.images ?? []);
+        let userMessage;
+        try {
+            userMessage = await store.appendMessage(sessionId, {
+                role: "user",
+                text,
+                ...(options.clientRequestId ? { clientRequestId: options.clientRequestId } : {}),
+                ...(attachments.length > 0 ? { attachments } : {}),
+            });
+        }
+        catch (error) {
+            await store.removeAttachments(sessionId, attachments).catch(() => undefined);
+            throw error;
+        }
         const afterUserMessage = await store.get(sessionId);
         if (afterUserMessage)
             await options.onUserMessagePersisted?.(afterUserMessage, userMessage);
@@ -687,6 +814,7 @@ export async function runChatTurn(options) {
                 // persisted + framed above. Nothing further to persist here.
                 break;
             case "tool_call":
+            case "tool_update":
                 // Forwarded to the caller (SSE) for UI feedback. The actual tool
                 // execution happens in the SDK's customTools[].execute(), which
                 // routes to dispatchChatToolCall (Gate 3). Do NOT dispatch here —

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

@@ -51,7 +51,7 @@ export function projectTurnFlow(group) {
         (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")
+        .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));
@@ -86,6 +86,19 @@ export function projectTurnFlow(group) {
     }
     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,
@@ -94,6 +107,7 @@ function emptyGroup(key, turnId) {
         tools: [],
         processItems: [],
         conversationItems: [],
+        turnClosed: false,
         live: false,
     };
 }
@@ -129,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;
         }
@@ -225,12 +240,17 @@ function flushToolBuffer(processItems, buffer) {
         };
         const dagProgress = dagProgressActivityForTool(tool);
         if (dagProgress) {
-            processItems.push({ kind: "dag-progress", progress: dagProgress, ...order });
+            processItems.push({
+                kind: "dag-progress",
+                progress: dagProgress,
+                toolCallCount: 1,
+                ...order,
+            });
             continue;
         }
         const activity = semanticActivityForTool(tool);
         if (activity) {
-            processItems.push({ kind: "activity", activity, ...order });
+            processItems.push({ kind: "activity", activity, toolCallCount: 1, ...order });
         }
         else {
             processItems.push({ kind: "tool", tool, ...order });
@@ -238,15 +258,28 @@ function flushToolBuffer(processItems, buffer) {
     }
 }
 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();
@@ -289,6 +322,7 @@ function fillProcessDetails(group) {
                     items.push({
                         kind: "text",
                         text: block.text,
+                        assistantMessageId: assistant.id,
                         ...(anchorSeq === undefined ? {} : { eventSeq: anchorSeq }),
                         createdAt: anchorAt,
                     });
@@ -353,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);
     }
@@ -391,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);
@@ -404,9 +442,6 @@ function fillProcessDetails(group) {
         content: split.answerBlocks,
     };
 }
-/**
- * Build user → process → answer groups for the message timeline.
- */
 export function buildTurnProcessGroups(input) {
     const visible = ensureLinkedSubmissionOrder(input.messages
         .filter((m) => m.role === "user" || m.role === "assistant")
@@ -523,10 +558,21 @@ export function buildTurnProcessGroups(input) {
             }
             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)