@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

package/dist/worker/console/static-src/operator-chat/file-palette-nav.js

@@ -0,0 +1,81 @@
+/**
+ * Composer `@` file palette helpers: 1-column movement, crumbs, row labels,
+ * and keyboard decisions. DOM-free so keyboard/AT behavior can be unit-tested.
+ */
+export const FILE_PALETTE_AVAILABLE_HEIGHT_VAR = "--oc-file-palette-available-height";
+export const FILE_PALETTE_MAX_HEIGHT_PX = 400;
+export function fileOptionId(index) {
+    return `oc-file-option-${index}`;
+}
+export function filePaletteBasename(path) {
+    const trimmed = path.endsWith("/") ? path.slice(0, -1) : path;
+    const slash = trimmed.lastIndexOf("/");
+    const name = slash < 0 ? trimmed : trimmed.slice(slash + 1);
+    return path.endsWith("/") ? `${name}/` : name;
+}
+export function filePaletteParent(path) {
+    const trimmed = path.endsWith("/") ? path.slice(0, -1) : path;
+    const slash = trimmed.lastIndexOf("/");
+    return slash < 0 ? "" : trimmed.slice(0, slash);
+}
+export function moveFilePaletteIndex(current, length, direction) {
+    if (!Number.isFinite(length) || length <= 0)
+        return 0;
+    if (!Number.isFinite(current) || current < 0)
+        return 0;
+    if (direction === "up")
+        return current <= 0 ? 0 : current - 1;
+    return current >= length - 1 ? length - 1 : current + 1;
+}
+/**
+ * Breadcrumbs exist only after a Tab/chevron drill. A path the user typed
+ * already shows its context in the draft, so it gets no header.
+ */
+export function filePaletteCrumbs(query, drilled) {
+    if (!drilled)
+        return undefined;
+    const slash = query.lastIndexOf("/");
+    if (slash < 0)
+        return undefined;
+    const segments = query
+        .slice(0, slash)
+        .split("/")
+        .filter((segment) => segment !== "");
+    if (segments.length === 0)
+        return undefined;
+    const crumbs = [
+        { label: "工作区", value: "", current: false },
+    ];
+    for (const [index, segment] of segments.entries()) {
+        crumbs.push({
+            label: segment,
+            value: `${segments.slice(0, index + 1).join("/")}/`,
+            current: index === segments.length - 1,
+        });
+    }
+    return crumbs;
+}
+export function decideFilePaletteKey(input) {
+    if (input.shortcutOpen || input.composing || input.optionCount <= 0) {
+        return { type: "none" };
+    }
+    if (input.key === "ArrowUp") {
+        return {
+            type: "move",
+            index: moveFilePaletteIndex(input.activeIndex, input.optionCount, "up"),
+        };
+    }
+    if (input.key === "ArrowDown") {
+        return {
+            type: "move",
+            index: moveFilePaletteIndex(input.activeIndex, input.optionCount, "down"),
+        };
+    }
+    if (input.key === "Escape")
+        return { type: "dismiss" };
+    if (input.key === "Tab")
+        return input.activeIsDir ? { type: "drill" } : { type: "pick" };
+    if (input.key === "Enter" && !input.shiftKey)
+        return { type: "pick" };
+    return { type: "none" };
+}

package/dist/worker/console/static-src/operator-chat/pending-user-message.js

@@ -6,7 +6,11 @@
 export function appendPendingSubmission(messages, pending) {
     if (messages.some((message) => message.clientRequestId === pending.clientRequestId))
         return [...messages];
-    return [...messages, { ...pending.user, pending: true }, pending.assistant];
+    return [
+        ...messages,
+        { ...pending.user, pending: true },
+        { ...pending.assistant, clientRequestId: pending.clientRequestId },
+    ];
 }
 /** Merge a durable user message into its optimistic or snapshot row in place.
  *
@@ -18,7 +22,8 @@ export function replacePendingUserMessage(messages, clientRequestId, durable) {
     let replaced = false;
     const next = [];
     for (const message of messages) {
-        const matches = message.clientRequestId === clientRequestId || message.id === durable.id;
+        const matches = message.role === "user" &&
+            (message.clientRequestId === clientRequestId || message.id === durable.id);
         if (!matches) {
             next.push(message);
             continue;
@@ -37,7 +42,16 @@ export function replacePendingUserMessage(messages, clientRequestId, durable) {
             clientRequestId,
         });
     }
-    return replaced ? next : [...next, durable];
+    if (replaced)
+        return next;
+    const assistantIndex = next.findIndex((message) => message.role === "assistant" && message.clientRequestId === clientRequestId);
+    if (assistantIndex < 0)
+        return [...next, durable];
+    return [
+        ...next.slice(0, assistantIndex),
+        durable,
+        ...next.slice(assistantIndex),
+    ];
 }
 /** Keep an unconfirmed optimistic bubble when a recovery snapshot lacks it. */
 export function mergePendingSubmissionOnHydration(canonical, pending) {

package/dist/worker/console/static-src/operator-chat/process-label.js

@@ -1,18 +1,25 @@
 import { isSubagentTool } from "../../chat/tool-preview.js";
 /**
  * Count the collapsed-turn disclosure buckets exactly like DSH
- * `TurnProcessNodeView`: tool calls, process messages and subagents, in that
- * order. Built-in subagent delegations (`Agent` tool) count as subagents, not
- * as ordinary tool calls (2026-09-08 alignment).
+ * `TurnProcessNodeView`: tool calls, durable assistant replies and subagents,
+ * in that order. Built-in subagent delegations (`Agent` tool) count as
+ * subagents, not as ordinary tool calls (2026-09-08 alignment).
  *
  * @param items - ordered process nodes of one turn.
  * @returns the three bucket counts.
  */
 export function countTurnProcessItems(items) {
+    return countEntries(items.map((item) => ({ source: "process", item })));
+}
+function countEntries(entries) {
     let toolCalls = 0;
     let messages = 0;
     let subagents = 0;
-    for (const item of items) {
+    const assistantMessageIds = new Set();
+    for (const entry of entries) {
+        if (entry.source !== "process")
+            continue;
+        const item = entry.item;
         if (item.kind === "tool") {
             if (isSubagentTool(item.tool.toolName))
                 subagents += 1;
@@ -20,10 +27,25 @@ export function countTurnProcessItems(items) {
                 toolCalls += 1;
             continue;
         }
-        messages += 1;
+        if (item.kind === "activity" || item.kind === "dag-progress") {
+            toolCalls += item.toolCallCount ?? 0;
+            continue;
+        }
+        if (item.kind !== "text" || item.text.trim() === "")
+            continue;
+        if (item.assistantMessageId)
+            assistantMessageIds.add(item.assistantMessageId);
+        else
+            messages += 1;
     }
+    messages += assistantMessageIds.size;
     return { toolCalls, messages, subagents };
 }
+/** Count only the ordered process window; prelude/post-answer nodes are kept
+ * visible but do not inflate the DSH compact disclosure summary. */
+export function countTurnFlowItems(entries) {
+    return countEntries(entries);
+}
 /**
  * Summary label for a completed turn's process disclosure.
  *

package/dist/worker/console/static-src/operator-chat/tools-catalog.js

@@ -70,13 +70,22 @@ const FALLBACK_AGENT_ENTRY = {
 export function buildToolCatalog(capabilities) {
     if (!capabilities)
         return null;
-    const operatorTools = (capabilities.tools ?? []).map((t) => ({
-        toolId: t.toolId,
-        action: t.action,
-        description: t.description,
-        kind: t.kind ?? "read",
-        cli: t.cli,
-    }));
+    const operatorToolsById = new Map();
+    for (const tool of [
+        ...(capabilities.tools ?? []),
+        ...(capabilities.builtinCustomTools ?? []),
+    ]) {
+        if (operatorToolsById.has(tool.toolId))
+            continue;
+        operatorToolsById.set(tool.toolId, {
+            toolId: tool.toolId,
+            action: tool.action,
+            description: tool.description,
+            kind: tool.kind ?? "read",
+            cli: tool.cli,
+        });
+    }
+    const operatorTools = [...operatorToolsById.values()];
     // ADR 0022: subagents come from the server's builtinSubagents field;
     // static entries never duplicate a server-advertised toolId.
     const subagentTools = (capabilities.builtinSubagents ?? []).map((s) => ({

package/dist/worker/console/static-src/operator-chat/transcript-mode.js

@@ -0,0 +1,21 @@
+export const TRANSCRIPT_MODE_STORAGE_KEY = "loop-console.operator-chat.transcript-mode.v1";
+export function parseTranscriptMode(value) {
+    return value === "compact" || value === "full" ? value : null;
+}
+export function loadTranscriptMode(storage) {
+    try {
+        return parseTranscriptMode(storage?.getItem(TRANSCRIPT_MODE_STORAGE_KEY)) ?? "compact";
+    }
+    catch {
+        return "compact";
+    }
+}
+export function saveTranscriptMode(mode, storage) {
+    try {
+        storage?.setItem(TRANSCRIPT_MODE_STORAGE_KEY, mode);
+    }
+    catch {
+        // Preference storage is optional.
+    }
+    return mode;
+}

package/dist/worker/console/static-src/operator-chat/turn-group-equality.js

@@ -7,7 +7,10 @@ function sameReferences(previous, next) {
 export function sameTurnGroupInputs(previous, next) {
     return (previous.key === next.key &&
         previous.user === next.user &&
+        previous.turnState === next.turnState &&
+        previous.turnClosed === next.turnClosed &&
         previous.live === next.live &&
         sameReferences(previous.assistants, next.assistants) &&
-        sameReferences(previous.tools, next.tools));
+        sameReferences(previous.tools, next.tools) &&
+        sameReferences(previous.conversationItems ?? [], next.conversationItems ?? []));
 }

package/dist/worker/console/static-src/operator-chat/turn-process-disclosure.js

@@ -2,9 +2,17 @@ export function turnProcessDisclosureKey(groupKey, answerId) {
     return `${groupKey}:generation-${answerId ?? "none"}`;
 }
 export function isTurnProcessCompact(input) {
-    return (!input.historyHasMore &&
-        !input.live &&
-        !input.hasError &&
-        input.processItemCount > 0 &&
-        !input.expanded);
+    const eligible = !input.historyHasMore &&
+        input.turnClosed &&
+        input.hasFinalAnswer &&
+        input.processItemCount > 0;
+    if (!eligible)
+        return false;
+    if (input.manualOpen)
+        return false;
+    if (input.manualClosed)
+        return true;
+    if (input.mode === "full")
+        return false;
+    return true;
 }

package/dist/worker/console/static-src/operator-chat/turn-state-projection.js

@@ -0,0 +1,166 @@
+export const TURN_STATE_RECONCILE_DELAYS_MS = [0, 75, 200, 500];
+export const TURN_STATE_QUEUE_RETRY_DELAYS_MS = [0, 75, 200, 500, 2_000];
+const MAX_TURN_STATE_QUERY_BATCH = 8;
+/** Normalize server turn facts. Queued is externally still an open/running Turn. */
+export function normalizeDurableTurnState(state) {
+    if (state === "queued" || state === "running")
+        return "running";
+    if (state === "settled" || state === "aborted" || state === "failed") {
+        return state;
+    }
+    return undefined;
+}
+/** Merge authoritative summaries without deleting older paginated Turn facts. */
+export function mergeTurnStateSummaries(current, summaries) {
+    if (!summaries?.length)
+        return current;
+    let next;
+    for (const summary of summaries) {
+        if (typeof summary.turnId !== "string" || !summary.turnId)
+            continue;
+        const state = normalizeDurableTurnState(summary.state);
+        const previous = next?.[summary.turnId] ?? current[summary.turnId];
+        const merged = mergeDurableTurnState(previous, state);
+        if (!merged || previous === merged)
+            continue;
+        next ??= { ...current };
+        next[summary.turnId] = merged;
+    }
+    return next ?? current;
+}
+export function setProjectedTurnState(current, turnId, state) {
+    if (!turnId)
+        return current;
+    const normalized = normalizeDurableTurnState(state);
+    const merged = mergeDurableTurnState(current[turnId], normalized);
+    if (!merged || current[turnId] === merged) {
+        return current;
+    }
+    return { ...current, [turnId]: merged };
+}
+function mergeDurableTurnState(current, incoming) {
+    if (!incoming)
+        return current;
+    if (!current)
+        return incoming;
+    if (current === "failed" || current === "aborted")
+        return current;
+    if (current === "settled" && incoming === "running")
+        return current;
+    return incoming;
+}
+export function turnStateReconcileTrigger(replay, eventName) {
+    if (eventName !== "agent_settled")
+        return undefined;
+    return replay ? "after-replay" : "immediate";
+}
+export async function reconcileTurnStateWithBackoff(input) {
+    const delays = input.delaysMs ?? TURN_STATE_RECONCILE_DELAYS_MS;
+    const wait = input.wait ??
+        ((delayMs) => new Promise((resolve) => globalThis.setTimeout(resolve, delayMs)));
+    for (const delayMs of delays) {
+        if (delayMs > 0)
+            await wait(delayMs);
+        if (input.isCancelled?.())
+            return "cancelled";
+        let snapshot = null;
+        try {
+            snapshot = await input.read();
+        }
+        catch {
+            // A transport failure consumes one bounded attempt; later attempts or an
+            // SSE reconnect retain ownership of the pending reconciliation.
+        }
+        if (input.isCancelled?.())
+            return "cancelled";
+        if (!snapshot?.turnStates)
+            continue;
+        input.apply(snapshot.turnStates);
+        const state = snapshot.turnStates
+            .filter((summary) => summary.turnId === input.turnId)
+            .map((summary) => normalizeDurableTurnState(summary.state))
+            .find((candidate) => candidate !== undefined);
+        if (state && state !== "running")
+            return "terminal";
+    }
+    return "pending";
+}
+/** Serialize targeted Turn-state reads, batching replay work and retaining
+ * unresolved Turns until durable terminal truth arrives or the owner ends. */
+export function createTurnStateReconcileQueue(input) {
+    const pending = new Set();
+    const wait = input.wait ??
+        ((delayMs) => new Promise((resolve) => globalThis.setTimeout(resolve, delayMs)));
+    const retryDelays = input.retryDelaysMs?.length
+        ? input.retryDelaysMs
+        : TURN_STATE_QUEUE_RETRY_DELAYS_MS;
+    let worker = null;
+    const run = async () => {
+        let retryIndex = 0;
+        while (pending.size > 0 && !input.isCancelled?.()) {
+            const delayMs = retryDelays[Math.min(retryIndex, retryDelays.length - 1)] ?? 0;
+            if (delayMs > 0) {
+                try {
+                    await wait(delayMs);
+                }
+                catch {
+                    if (input.isCancelled?.())
+                        return;
+                }
+            }
+            if (input.isCancelled?.())
+                return;
+            const batch = [...pending].slice(0, MAX_TURN_STATE_QUERY_BATCH);
+            let snapshot = null;
+            try {
+                snapshot = await input.read(batch);
+            }
+            catch {
+                // The queue owns retry cadence; a transient read failure keeps the batch pending.
+            }
+            if (input.isCancelled?.())
+                return;
+            const summaries = snapshot?.turnStates;
+            if (summaries?.length)
+                input.apply(summaries);
+            let completed = 0;
+            for (const turnId of batch) {
+                const state = summaries
+                    ?.filter((summary) => summary.turnId === turnId)
+                    .map((summary) => normalizeDurableTurnState(summary.state))
+                    .find((candidate) => candidate !== undefined);
+                if (state && state !== "running") {
+                    pending.delete(turnId);
+                    completed += 1;
+                    continue;
+                }
+                // Rotate unresolved ids so batches larger than the server query cap cannot starve.
+                pending.delete(turnId);
+                pending.add(turnId);
+            }
+            retryIndex = completed > 0 ? 0 : retryIndex + 1;
+        }
+    };
+    const start = () => {
+        if (worker)
+            return worker;
+        if (pending.size === 0 || input.isCancelled?.())
+            return Promise.resolve();
+        worker = run().finally(() => {
+            worker = null;
+            if (pending.size > 0 && !input.isCancelled?.())
+                void start();
+        });
+        return worker;
+    };
+    return {
+        enqueue: (turnId, options) => {
+            if (!turnId || input.isCancelled?.())
+                return;
+            pending.add(turnId);
+            if (!options?.defer)
+                void start();
+        },
+        start,
+    };
+}

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -19,11 +19,65 @@ export const OPERATOR_CHAT_REAL_PATHS = {
     events: "/api/operator/v1/chat/sessions/:sessionId/events",
     abort: "/api/operator/v1/chat/sessions/:sessionId/turns/:turnId/abort",
 };
+const MAX_STATE_TURN_IDS = 8;
+const MAX_STATE_TURN_ID_CHARS = 240;
+function boundedStateTurnIds(turnIds) {
+    const result = [];
+    const seen = new Set();
+    for (const raw of turnIds ?? []) {
+        const turnId = raw.trim();
+        if (!turnId ||
+            turnId.length > MAX_STATE_TURN_ID_CHARS ||
+            seen.has(turnId)) {
+            continue;
+        }
+        seen.add(turnId);
+        result.push(turnId);
+        if (result.length >= MAX_STATE_TURN_IDS)
+            break;
+    }
+    return result;
+}
 export function operatorChatTurnsUrl(origin, sessionId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns`;
 }
-export function operatorChatStateUrl(origin, sessionId) {
-    return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`;
+export function operatorChatStateUrl(origin, sessionId, turnIds) {
+    const base = `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`;
+    const bounded = boundedStateTurnIds(turnIds);
+    if (bounded.length === 0)
+        return base;
+    const query = new URLSearchParams();
+    for (const turnId of bounded)
+        query.append("turnId", turnId);
+    return `${base}?${query.toString()}`;
+}
+/** Compose session ownership with a short request timeout and explicit cleanup. */
+export function createBoundedOwnerSignal(input) {
+    const controller = new AbortController();
+    const abortFromOwner = () => controller.abort(input.ownerSignal?.reason);
+    if (input.ownerSignal?.aborted)
+        abortFromOwner();
+    else
+        input.ownerSignal?.addEventListener("abort", abortFromOwner, { once: true });
+    const schedule = input.schedule ??
+        ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+    const cancel = input.cancel ??
+        ((handle) => globalThis.clearTimeout(handle));
+    const timer = controller.signal.aborted
+        ? undefined
+        : schedule(() => controller.abort(new Error("Operator Chat state request timed out")), input.timeoutMs);
+    let disposed = false;
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (timer !== undefined)
+                cancel(timer);
+            input.ownerSignal?.removeEventListener("abort", abortFromOwner);
+        },
+    };
 }
 export function operatorChatEventsUrl(origin, sessionId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`;