@tea-agent/loop-agent 0.35.3 → 0.36.0

package/dist/worker/console/static-src/operator-chat/chat-sse-events.js

@@ -25,25 +25,30 @@ export function createChatSseEventApplier(deps) {
             // global error; the snapshot replay frames that follow are still applied
             // as ordinary blocks (deduped by eventId, replay text skipped).
             const reason = typeof data.reason === "string" ? data.reason : "cursor_expired";
-            onReconcile?.({
+            const reconcileInfo = {
                 reason,
                 ...(typeof data.minSeq === "number" ? { minSeq: data.minSeq } : {}),
                 ...(typeof data.epoch === "string" ? { epoch: data.epoch } : {}),
                 ...(typeof data.latestTurnId === "string"
                     ? { latestTurnId: data.latestTurnId }
                     : {}),
-                ...(typeof data.latestEventId === "string"
-                    ? { latestEventId: data.latestEventId }
-                    : data.latestEventId === null
-                        ? { latestEventId: null }
-                        : {}),
-            });
+            };
+            if (typeof data.latestEventId === "string" || data.latestEventId === null) {
+                reconcileInfo.latestEventId = data.latestEventId;
+            }
+            onReconcile?.(reconcileInfo);
             return;
         }
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
+        const eventSeq = typeof data.seq === "number" && Number.isFinite(data.seq)
+            ? data.seq
+            : undefined;
+        const eventAt = typeof data.at === "string" && Number.isFinite(Date.parse(data.at))
+            ? Date.parse(data.at)
+            : Date.now();
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -108,14 +113,26 @@ export function createChatSseEventApplier(deps) {
         }
         if (eventName === "human-gate-card") {
             const card = humanGateCardFromEventPayload(payload);
-            if (card)
-                setHumanGateCards((current) => mergeHumanGateCardState(current, card));
+            if (card) {
+                setHumanGateCards((current) => mergeHumanGateCardState(current, {
+                    ...card,
+                    ...(eventSeq === undefined ? {} : { eventSeq }),
+                    ...(turnId ? { turnId } : {}),
+                    activityRef: `gate:${card.cardId}`,
+                }));
+            }
             return;
         }
         if (eventName === "artifact-ref") {
             const artifact = artifactFromEventPayload(payload);
-            if (artifact)
-                setArtifactCards((current) => mergeArtifactCardState(current, artifact));
+            if (artifact) {
+                setArtifactCards((current) => mergeArtifactCardState(current, {
+                    ...artifact,
+                    ...(eventSeq === undefined ? {} : { eventSeq }),
+                    ...(turnId ? { turnId } : {}),
+                    activityRef: `artifact:${artifact.artifactId}`,
+                }));
+            }
             return;
         }
         if (eventName === "agent_start") {
@@ -172,7 +189,18 @@ export function createChatSseEventApplier(deps) {
         if (eventName === "operation-ref" || eventName === "operation-status") {
             const operation = operationFromEventPayload(payload);
             if (operation) {
-                setOperationCards((current) => mergeOperationCardState(current, operation));
+                const toolCallId = typeof payload.toolCallId === "string"
+                    ? payload.toolCallId
+                    : undefined;
+                setOperationCards((current) => mergeOperationCardState(current, {
+                    ...operation,
+                    ...(eventSeq === undefined
+                        ? {}
+                        : { eventSeq, updatedSeq: eventSeq }),
+                    ...(turnId ? { turnId } : {}),
+                    ...(toolCallId ? { toolCallId } : {}),
+                    activityRef: `operation:${operation.operationId}`,
+                }));
             }
             return;
         }
@@ -229,13 +257,15 @@ export function createChatSseEventApplier(deps) {
             setMessages((m) => {
                 const exists = m.some((msg) => msg.id === assistantIdForEvent);
                 if (exists) {
-                    return m.map((msg) => msg.id === assistantIdForEvent
-                        ? {
+                    return m.map((msg) => {
+                        if (msg.id !== assistantIdForEvent)
+                            return msg;
+                        return {
                             ...msg,
                             text,
                             ...(content ? { content } : {}),
-                        }
-                        : msg);
+                        };
+                    });
                 }
                 // Reconnect path: the assistant message may not exist yet
                 // (e.g. only tool_call events arrived). Append a placeholder.
@@ -245,7 +275,7 @@ export function createChatSseEventApplier(deps) {
                         id: assistantIdForEvent,
                         role: "assistant",
                         text,
-                        createdAt: Date.now(),
+                        createdAt: eventAt,
                         ...(content ? { content } : {}),
                     },
                 ];
@@ -259,18 +289,20 @@ export function createChatSseEventApplier(deps) {
                 : requestId("t");
             const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
             const argsPreview = typeof payload.argsPreview === "string" ? payload.argsPreview : "{}";
-            const now = Date.now();
             setToolCalls((prev) => {
                 if (prev.some((t) => t.id === id)) {
-                    return prev.map((t) => t.id === id
-                        ? {
+                    return prev.map((t) => {
+                        if (t.id !== id)
+                            return t;
+                        return {
                             ...t,
                             args: argsPreview,
                             status: "running",
                             turnId: turnId ?? t.turnId,
                             assistantMessageId: resolvedAssistantId,
-                        }
-                        : t);
+                            ...(eventSeq === undefined ? {} : { eventSeq }),
+                        };
+                    });
                 }
                 return [
                     ...prev,
@@ -279,7 +311,8 @@ export function createChatSseEventApplier(deps) {
                         toolName,
                         args: argsPreview,
                         status: "running",
-                        createdAt: now,
+                        createdAt: eventAt,
+                        ...(eventSeq === undefined ? {} : { eventSeq }),
                         turnId,
                         assistantMessageId: resolvedAssistantId,
                     },
@@ -295,21 +328,23 @@ export function createChatSseEventApplier(deps) {
             const resultText = typeof payload.resultPreview === "string"
                 ? payload.resultPreview
                 : "{}";
-            const now = Date.now();
             setToolCalls((prev) => {
                 const exists = prev.find((t) => t.id === id);
                 if (exists) {
-                    return prev.map((t) => t.id === id
-                        ? {
+                    return prev.map((t) => {
+                        if (t.id !== id)
+                            return t;
+                        return {
                             ...t,
                             result: resultText,
                             resultText,
                             status: isError ? "error" : "ok",
-                            finishedAt: now,
+                            finishedAt: eventAt,
+                            ...(eventSeq === undefined ? {} : { finishedSeq: eventSeq }),
                             turnId: turnId ?? t.turnId,
                             assistantMessageId: t.assistantMessageId ?? resolvedAssistantId,
-                        }
-                        : t);
+                        };
+                    });
                 }
                 return [
                     ...prev,
@@ -319,8 +354,11 @@ export function createChatSseEventApplier(deps) {
                         result: resultText,
                         resultText,
                         status: isError ? "error" : "ok",
-                        createdAt: now,
-                        finishedAt: now,
+                        createdAt: eventAt,
+                        finishedAt: eventAt,
+                        ...(eventSeq === undefined
+                            ? {}
+                            : { eventSeq, finishedSeq: eventSeq }),
                         turnId,
                         assistantMessageId: resolvedAssistantId,
                     },

package/dist/worker/console/static-src/operator-chat/slash-palette-layout.js

@@ -0,0 +1,24 @@
+export const SHORTCUT_PALETTE_AVAILABLE_HEIGHT_VAR = "--oc-shortcut-palette-available-height";
+export const SHORTCUT_PALETTE_TOP_INSET = 8;
+export const SHORTCUT_PALETTE_ANCHOR_GAP = 8;
+/**
+ * Resolve the real vertical room above the composer anchor. The palette is
+ * clipped by `.oc-main`, while a shifted VisualViewport (for example when the
+ * browser UI or virtual keyboard changes) can impose a lower visible top edge.
+ */
+export function resolveShortcutPaletteAvailableHeight(geometry) {
+    const viewportTop = geometry.viewportTop ?? 0;
+    const topInset = geometry.topInset ?? SHORTCUT_PALETTE_TOP_INSET;
+    const anchorGap = geometry.anchorGap ?? SHORTCUT_PALETTE_ANCHOR_GAP;
+    const values = [
+        geometry.boundaryTop,
+        geometry.anchorTop,
+        viewportTop,
+        topInset,
+        anchorGap,
+    ];
+    if (values.some((value) => !Number.isFinite(value)))
+        return null;
+    const visibleTop = Math.max(geometry.boundaryTop, viewportTop);
+    return Math.max(0, Math.floor(geometry.anchorTop - visibleTop - topInset - anchorGap));
+}

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

@@ -0,0 +1,141 @@
+/**
+ * Slash palette display + navigation model (UI-12 card grid).
+ *
+ * Display order (SLASH_GROUP_DISPLAY_ORDER) is intentionally decoupled from
+ * the conflict/priority order in shortcuts.ts (SOURCE_PRIORITY): merge and
+ * dedupe keep SOURCE_PRIORITY semantics (skill 3 < prompt 4), while rendering
+ * follows the display order (prompt group before skill group). buildPaletteModel
+ * models that divergence explicitly — every card carries its flat-list
+ * globalIndex so keyboard/AT state round-trips from the rendered position back
+ * to filteredShortcuts[globalIndex]. shortcuts.ts itself stays untouched.
+ *
+ * All functions here are pure/DOM-free so the geometric and row-aware
+ * navigation can be unit-tested in node with fixture rects.
+ */
+import { SLASH_SOURCE_LABEL, } from "../../chat/shortcuts.js";
+/** Group render order (independent from SOURCE_PRIORITY conflict order). */
+export const SLASH_GROUP_DISPLAY_ORDER = [
+    "operator",
+    "web",
+    "extension",
+    "prompt",
+    "skill",
+];
+/** Group filtered candidates by display order, skipping empty groups. */
+export function buildPaletteModel(entries) {
+    const groups = [];
+    for (const source of SLASH_GROUP_DISPLAY_ORDER) {
+        const items = [];
+        for (let i = 0; i < entries.length; i += 1) {
+            if (entries[i].source === source) {
+                items.push({ entry: entries[i], globalIndex: i });
+            }
+        }
+        if (items.length === 0)
+            continue;
+        groups.push({ source, label: SLASH_SOURCE_LABEL[source], items });
+    }
+    return groups;
+}
+/** Keep the active option index inside the current candidate range. */
+export function clampShortcutIndex(index, length) {
+    if (!Number.isFinite(length) || length <= 0)
+        return 0;
+    if (!Number.isFinite(index) || index < 0)
+        return 0;
+    if (index >= length)
+        return length - 1;
+    return index;
+}
+/** CSS grid columns per workspace layout mode (single source: layoutMode). */
+export function paletteColumnCount(mode) {
+    if (mode === "comfortable")
+        return 3;
+    if (mode === "compact")
+        return 2;
+    return 1;
+}
+/**
+ * Group- and row-aware movement on the displayed card grid.
+ *
+ * Left/Right move to the adjacent card in the current row and stay inside the
+ * current group (row start/end stick; group headers are never entered; narrow
+ * 1-column layout is a no-op). Up/Down move within the same column to the
+ * adjacent row, may cross group boundaries, and stick at grid edges — never
+ * wrapping around and never leaving [0, entries.length - 1].
+ */
+export function movePaletteIndex(currentIndex, model, columns, direction) {
+    const groupPos = model.findIndex((group) => group.items.some((card) => card.globalIndex === currentIndex));
+    if (groupPos < 0)
+        return currentIndex;
+    const group = model[groupPos];
+    const offset = group.items.findIndex((card) => card.globalIndex === currentIndex);
+    if (offset < 0)
+        return currentIndex;
+    const row = Math.floor(offset / columns);
+    const col = offset % columns;
+    if (direction === "left" || direction === "right") {
+        if (columns <= 1)
+            return currentIndex;
+        const delta = direction === "left" ? -1 : 1;
+        const targetOffset = offset + delta;
+        if (targetOffset < 0 || targetOffset >= group.items.length) {
+            return currentIndex;
+        }
+        if (Math.floor(targetOffset / columns) !== row)
+            return currentIndex;
+        return group.items[targetOffset].globalIndex;
+    }
+    const delta = direction === "up" ? -1 : 1;
+    const targetOffset = offset + delta * columns;
+    if (targetOffset >= 0 && targetOffset < group.items.length) {
+        return group.items[targetOffset].globalIndex;
+    }
+    // Cross-group: walk to the previous/next non-empty group and target the
+    // same column on its last (up) / first (down) row; stick when that column
+    // does not exist in the partial edge row.
+    for (let cursor = groupPos + delta; cursor >= 0 && cursor < model.length; cursor += delta) {
+        const candidate = model[cursor];
+        if (candidate.items.length === 0)
+            continue;
+        const lastRowStart = Math.floor((candidate.items.length - 1) / columns) * columns;
+        const target = direction === "up" ? lastRowStart + col : col;
+        if (target >= candidate.items.length)
+            return currentIndex;
+        return candidate.items[target].globalIndex;
+    }
+    return currentIndex;
+}
+/**
+ * Geometry-first Up/Down targeting: from the active card's measured rect,
+ * pick the adjacent row's candidate whose horizontal center is nearest the
+ * active card's center (group boundaries may be crossed). Returns null when
+ * no candidate exists above/below (or the layout was not measured), so the
+ * caller falls back to movePaletteIndex. globalIndex comes from
+ * data-shortcut-index — never from the DOM list position.
+ */
+export function pickAdjacentRowTarget(activeRect, cells, direction) {
+    const activeCenterX = (activeRect.left + activeRect.right) / 2;
+    let best = null;
+    for (const cell of cells) {
+        if (cell.globalIndex === activeRect.globalIndex)
+            continue;
+        const gap = direction === "up"
+            ? activeRect.top - cell.bottom
+            : cell.top - activeRect.bottom;
+        // Same-row cells overlap vertically (gap < 0) and must be ignored.
+        if (gap < 0)
+            continue;
+        const centerX = (cell.left + cell.right) / 2;
+        const dist = Math.abs(centerX - activeCenterX);
+        if (best === null ||
+            gap < best.gap ||
+            (gap === best.gap && dist < best.dist) ||
+            (gap === best.gap &&
+                dist === best.dist &&
+                cell.globalIndex < best.index)) {
+            best = { gap, dist, index: cell.globalIndex };
+        }
+    }
+    return best?.index ?? null;
+}

package/dist/worker/console/static-src/operator-chat/spatial-overlay.js

@@ -1,6 +1,6 @@
 /**
  * Mutual-exclusion state for large spatial overlays in Operator Chat.
- * At most one of: sidebar drawer, process, runtime context, tools.
+ * At most one of: sidebar drawer, process, runtime context, tools, activity.
  * Small composer menus (model/thinking) are out of scope.
  */
 export function createSpatialOverlayState(active = "none") {
@@ -33,5 +33,6 @@ export function spatialOverlayFlags(state) {
         processOpen: state.active === "process",
         runtimeContextOpen: state.active === "runtime-context",
         toolsOpen: state.active === "tools",
+        activityOpen: state.active === "activity",
     };
 }

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

@@ -0,0 +1,59 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+export const ACTIVITY_RAIL_ENTER_MS = 160;
+export const ACTIVITY_RAIL_LEAVE_MS = 120;
+export const ACTIVITY_RAIL_SWITCH_MS = 120;
+export function activityRailSnapshotTotal(snapshot) {
+    if (!snapshot)
+        return 0;
+    return (snapshot.operationCards.length +
+        snapshot.humanGateCards.length +
+        snapshot.artifactCards.length);
+}
+/**
+ * Keep the Rail shell independent from ChatMain while sessions change. Old
+ * content is non-interactive during the short switching/leaving phase, then is
+ * replaced or removed without ever changing conversation geometry.
+ */
+export function useActivityRailTransition(current) {
+    const currentTotal = activityRailSnapshotTotal(current);
+    const [state, setState] = useState(() => currentTotal > 0
+        ? { phase: "visible", snapshot: current }
+        : { phase: "hidden", snapshot: null });
+    const stateRef = useRef(state);
+    stateRef.current = state;
+    const currentKey = useMemo(() => `${current?.sessionId ?? "none"}:${currentTotal}`, [current?.sessionId, currentTotal]);
+    useEffect(() => {
+        const timers = [];
+        const displayed = stateRef.current.snapshot;
+        if (!current || currentTotal === 0) {
+            if (!displayed) {
+                setState({ phase: "hidden", snapshot: null });
+                return;
+            }
+            setState({ phase: "leaving", snapshot: displayed });
+            timers.push(window.setTimeout(() => {
+                setState({ phase: "hidden", snapshot: null });
+            }, ACTIVITY_RAIL_LEAVE_MS));
+        }
+        else if (!displayed) {
+            setState({ phase: "entering", snapshot: current });
+            timers.push(window.setTimeout(() => {
+                setState({ phase: "visible", snapshot: current });
+            }, ACTIVITY_RAIL_ENTER_MS));
+        }
+        else if (displayed.sessionId !== current.sessionId) {
+            setState({ phase: "switching", snapshot: current });
+            timers.push(window.setTimeout(() => {
+                setState({ phase: "visible", snapshot: current });
+            }, ACTIVITY_RAIL_SWITCH_MS));
+        }
+        else {
+            setState({ phase: "visible", snapshot: current });
+        }
+        return () => {
+            for (const timer of timers)
+                window.clearTimeout(timer);
+        };
+    }, [current, currentKey, currentTotal]);
+    return state;
+}

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

@@ -146,8 +146,6 @@ export function useChatSessions(params) {
         }
     }, [origin, refs, resetActiveProjection, setSession]);
     const deleteSession = useCallback(async (sessionId) => {
-        if (!window.confirm("确定删除该会话？删除后不可恢复。"))
-            return;
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}`, {
                 method: "DELETE",
@@ -158,7 +156,7 @@ export function useChatSessions(params) {
             });
             if (!res.ok) {
                 setError("删除会话失败");
-                return;
+                return false;
             }
             titleWatcherRef.current?.cancel(sessionId);
             if (refs.sessionRef.current?.sessionId === sessionId) {
@@ -169,9 +167,11 @@ export function useChatSessions(params) {
                 window.localStorage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
             }
             await refreshSessionList();
+            return true;
         }
         catch (error) {
             setError(error instanceof Error ? error.message : String(error));
+            return false;
         }
     }, [
         origin,
@@ -372,15 +372,26 @@ export function useChatSessions(params) {
         createSessionAndPrimeTitleWatcherForHook,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
-    const compactSession = useCallback(async () => {
+    /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */
+    const compactSession = useCallback(async (instructions) => {
         const current = refs.sessionRef.current;
         if (!current || refs.streamingRef.current)
             return;
+        const trimmed = typeof instructions === "string" ? instructions.trim() : "";
         try {
+            const headers = {
+                "x-loop-console-confirmation": confirmationToken(),
+            };
+            if (trimmed) {
+                headers["content-type"] = "application/json";
+            }
             const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/compact`, {
                 method: "POST",
                 credentials: "include",
-                headers: { "x-loop-console-confirmation": confirmationToken() },
+                headers,
+                ...(trimmed
+                    ? { body: JSON.stringify({ instructions: trimmed }) }
+                    : {}),
             });
             const body = (await response.json().catch(() => ({})));
             if (!response.ok) {

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

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
 import { filterSlashCommands, mergeSlashCommands, } from "../../chat/shortcuts.js";
 import { confirmationToken } from "./format.js";
+import { clampShortcutIndex } from "./slash-palette-nav.js";
 import { attachRuntimeSnapshotController } from "./useRuntimeSnapshot.js";
 /** Composer state: input text, @file palette, image attachments, /shortcuts,
  *  IME composition guards, auto-grow and server-side draft sync. */
@@ -30,12 +31,22 @@ export function useComposer(params) {
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
     const textareaRef = useRef(null);
-    const commandsSessionRef = useRef(undefined);
+    /** Active session generation for /commands; bumped immediately on switch (AC-2). */
+    const commandsSessionRef = useRef(sessionId);
+    const commandsGenerationRef = useRef(0);
     const handleInputChange = useCallback((value) => {
         setInput(value);
         setShortcutOpen(value.startsWith("/"));
         setShortcutIndex(0);
     }, []);
+    // Immediate invalidation on A→B even when B palette never opens (AC-2).
+    useLayoutEffect(() => {
+        commandsSessionRef.current = sessionId;
+        commandsGenerationRef.current += 1;
+        setDynamicCommands([]);
+        setDynamicCommandsError(null);
+        setDynamicCommandsLoading(false);
+    }, [sessionId]);
     const loadDynamicCommands = useCallback(async () => {
         if (!sessionId) {
             setDynamicCommands([]);
@@ -44,12 +55,15 @@ export function useComposer(params) {
             return;
         }
         const target = sessionId;
+        const generation = commandsGenerationRef.current;
         commandsSessionRef.current = target;
         setDynamicCommandsLoading(true);
         setDynamicCommandsError(null);
+        const isCurrent = () => commandsSessionRef.current === target &&
+            commandsGenerationRef.current === generation;
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(target)}/commands`, { credentials: "include" });
-            if (commandsSessionRef.current !== target)
+            if (!isCurrent())
                 return;
             if (!res.ok) {
                 setDynamicCommandsError("动态命令加载失败");
@@ -75,26 +89,27 @@ export function useComposer(params) {
                     source,
                 });
             }
-            if (commandsSessionRef.current !== target)
+            if (!isCurrent())
                 return;
             setDynamicCommands(items);
+            // Compact server fail-soft / partial-source warning; local Operator/Web still merge.
+            const warning = typeof body?.warning === "string" ? body.warning.trim() : "";
+            setDynamicCommandsError(warning ? warning.slice(0, 160) : null);
         }
         catch {
-            if (commandsSessionRef.current !== target)
+            if (!isCurrent())
                 return;
             setDynamicCommandsError("动态命令加载失败");
             setDynamicCommands([]);
         }
         finally {
-            if (commandsSessionRef.current === target) {
+            if (isCurrent()) {
                 setDynamicCommandsLoading(false);
             }
         }
     }, [origin, sessionId]);
     // Lazy-load dynamic commands when slash palette opens or session changes.
     useEffect(() => {
-        setDynamicCommands([]);
-        setDynamicCommandsError(null);
         if (!sessionId)
             return;
         if (!shortcutOpen && commandsEpoch === 0)
@@ -186,6 +201,14 @@ export function useComposer(params) {
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
         : [], [input, mergedCommands]);
+    // Keep the active option index inside the current candidate range (UI-12
+    // AC-011): dynamic loads completing/failing empty, retries, session
+    // switches, late responses and search shrink all funnel through
+    // filteredShortcuts.length. The clamped index always matches a rendered
+    // `oc-shortcut-option-${globalIndex}` id (same source of truth).
+    useEffect(() => {
+        setShortcutIndex((index) => clampShortcutIndex(index, filteredShortcuts.length));
+    }, [filteredShortcuts.length]);
     const onCompositionStart = useCallback(() => {
         refs.isComposingRef.current = true;
     }, [refs]);

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

@@ -17,9 +17,13 @@ export function resolveWorkspaceLayoutMode(widthPx) {
         return "compact";
     return "narrow";
 }
-/** Whether process should render as a right overlay (no main reflow). */
-export function processUsesOverlay(mode) {
-    return mode === "compact" || mode === "narrow";
+/**
+ * Tool-call history always uses the original right overlay panel.
+ * Reflowing it as a comfortable-mode third column moves ChatMain and also
+ * invalidates Activity Rail's fixed ChatMain anchor.
+ */
+export function processUsesOverlay(_mode) {
+    return true;
 }
 /** Whether the permanent full sidebar is allowed. */
 export function fullSidebarAllowed(mode) {

package/dist/worker/observe/static/operator-chrome.js

@@ -1,7 +1,7 @@
 /**
  * Operator Chrome — 统一壳（Operate React 与 Inspect vanilla 共用唯一实现）。
  *
- * 设计真源：docs/design/active/2026-08-09-unified-operator-chrome.md
+ * 设计真源：docs/design/archive/2026-08-09-unified-operator-chrome.md
  * - 一条 chrome 两条带：Band1 全局（品牌/仓库身份/模式分段控件/对象上下文/状态格），
  *   Band2 工作区（下划线 tab，随模式切换内容）。
  * - 模式语义：操作=做，观测=看同一对象；模式切换在持有 DAG 选中时不丢对象。