npm - @tea-agent/loop-agent - Versions diffs - 0.33.7-beta.0 → 0.34.0 - Mend

@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-CteJFFL2.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CnUXAqxG.css">
+    <script type="module" crossorigin src="/assets/index-CMHovlqG.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BQkhJpV8.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -9,20 +9,47 @@ import { requestId } from "./format.js";
  * original request would have. `assistantId` is the in-flight assistant
  * message id to patch for streaming text; reconnect creates one if none. */
 export function createChatSseEventApplier(deps) {
-    const { refs, setError, setProcessOpen, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setProcessOpen, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
     return (eventName, data, assistantId, options) => {
+        if (options?.generation !== undefined &&
+            refs.sessionGenerationRef.current !== options.generation)
+            return;
         const replay = options?.replay === true;
+        if (eventName === "stream_ready")
+            return;
         if (eventName === "reconcile") {
-            // Cursor aged out of the server ring: history may be incomplete.
-            // Surface a non-fatal notice rather than silently rendering a gap.
+            // Cursor aged out of the server ring (or the turn changed under us):
+            // retained history may be incomplete. Surface recovery via the callback
+            // (reload canonical facts -> new cursor -> reconnect) instead of a fatal
+            // 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";
-            setError(`会话事件窗口已过期（${reason}），建议刷新历史或新建会话。`);
+            onReconcile?.({
+                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 }
+                        : {}),
+            });
             return;
         }
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
+        if (turnId &&
+            (eventName === "agent_start" || eventName === "message_update") &&
+            refs.settledTurnIdsRef.current.has(turnId)) {
+            // A delayed start/text frame from a completed turn must not create a
+            // ghost bubble or set streaming again (M5.4).
+            return;
+        }
         let resolvedAssistantId = assistantId;
         if (turnId) {
             const mapped = refs.turnAssistantIdsRef.current.get(turnId);
@@ -102,16 +129,26 @@ export function createChatSseEventApplier(deps) {
                 turnId !== refs.activeTurnIdRef.current) {
                 return;
             }
-            if (turnId)
+            if (turnId) {
+                refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
+            }
+            refs.streamingRef.current = true;
             setStreaming(true);
             setStreamingAssistantId(resolvedAssistantId);
             return;
         }
         if (eventName === "agent_settled" || eventName === "agent_end") {
-            // Both are terminal: agent_end = SDK run finished, agent_settled =
-            // post-turn continuation idle. Clear streaming and drop an empty
-            // placeholder bubble so a settled turn never shows a stuck "…" row.
+            if (turnId)
+                refs.settledTurnIdsRef.current.add(turnId);
+            // `agent_end` means the SDK run ended, but the Console keeps the only
+            // GET stream through an idle grace for agent_settled/state reconciliation
+            // (M4.4). It must not prematurely close the visible turn.
+            if (eventName === "agent_end")
+                return;
+            if (turnId === refs.activeTurnIdRef.current)
+                refs.activeTurnIdRef.current = null;
+            refs.streamingRef.current = false;
             setStreaming(false);
             setStreamingAssistantId(null);
             if (eventName === "agent_settled" &&

package/dist/worker/console/static-src/operator-chat/landing-density.js ADDED Viewed

@@ -0,0 +1,23 @@
+/** Landing density resolved from measured empty-container height. */
+/** Height thresholds in CSS px against `.oc-messages.is-empty`. */
+export const LANDING_DENSITY_THRESHOLDS = {
+    comfortableMin: 620,
+    compactMin: 480,
+};
+/**
+ * Resolve Landing visual density from empty-container block size.
+ * comfortable >=620, compact 480-619, extra-compact <480.
+ */
+export function resolveLandingDensity(heightPx) {
+    if (!Number.isFinite(heightPx) || heightPx < 0)
+        return "extra-compact";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.comfortableMin)
+        return "comfortable";
+    if (heightPx >= LANDING_DENSITY_THRESHOLDS.compactMin)
+        return "compact";
+    return "extra-compact";
+}
+/** CSS class suffix for density attribute binding. */
+export function landingDensityClass(density) {
+    return `is-landing-${density}`;
+}

package/dist/worker/console/static-src/operator-chat/refs.js CHANGED Viewed

@@ -7,6 +7,9 @@ export function useChatRefs() {
     const inlineStreamSessionIdsRef = useRef(new Set());
     const assistantIdRef = useRef(null);
     const lastEventIdRef = useRef(null);
+    const sessionGenerationRef = useRef(0);
+    const eventsStreamStateRef = useRef(null);
+    const settledTurnIdsRef = useRef(new Set());
     const seenEventIdsRef = useRef(new Set());
     const turnAssistantIdsRef = useRef(new Map());
     const reconnectAbortRef = useRef(null);
@@ -24,6 +27,9 @@ export function useChatRefs() {
         inlineStreamSessionIdsRef,
         assistantIdRef,
         lastEventIdRef,
+        sessionGenerationRef,
+        eventsStreamStateRef,
+        settledTurnIdsRef,
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,
@@ -39,6 +45,9 @@ export function useChatRefs() {
         inlineStreamSessionIdsRef,
         assistantIdRef,
         lastEventIdRef,
+        sessionGenerationRef,
+        eventsStreamStateRef,
+        settledTurnIdsRef,
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,

package/dist/worker/console/static-src/operator-chat/runtime-snapshot-store.js ADDED Viewed

@@ -0,0 +1,257 @@
+/**
+ * Operator Chat — runtime snapshot store (design §2.2 / AC-04/05/06).
+ *
+ * A pure, framework-free state machine for the unified Live Runtime Snapshot.
+ * The browser treats the current Pi session as the single source of truth:
+ *
+ *   status: idle → loading → ready | error
+ *   reload: reloading (single-flight; no silent queueing) → success | failure
+ *
+ * `createRuntimeSnapshotStore` is intentionally side-effect free so it can be
+ * unit-tested in a plain Node environment; the React binding (fetch + attach)
+ * lives in `useRuntimeSnapshot.ts`.
+ */
+export const runtimeSnapshotInitialState = {
+    status: "idle",
+    snapshot: null,
+    error: null,
+    reloading: false,
+    reloadError: null,
+    mutationBusy: false,
+    mutationToken: null,
+};
+/** Parse a failed HTTP body into a structured snapshot error (never empty). */
+export function parseRuntimeSnapshotError(body) {
+    if (!body || typeof body !== "object") {
+        return { message: "runtime snapshot request failed" };
+    }
+    const record = body;
+    const err = record.error;
+    if (err && typeof err === "object") {
+        const e = err;
+        return {
+            ...(typeof e.code === "string" && e.code ? { code: e.code } : {}),
+            ...(typeof record.status === "number" ? { status: record.status } : {}),
+            message: typeof e.message === "string" && e.message
+                ? e.message
+                : "runtime snapshot request failed",
+        };
+    }
+    return {
+        ...(typeof record.status === "number" ? { status: record.status } : {}),
+        message: typeof record === "object" && "message" in record &&
+            typeof record.message === "string" &&
+            record.message
+            ? record.message
+            : "runtime snapshot request failed",
+    };
+}
+export function runtimeSnapshotReducer(state, action) {
+    switch (action.type) {
+        case "load-start":
+            // Stale replies are dropped by the fetch layer (sessionId guard); the
+            // reducer stays a deterministic state machine. The previous snapshot
+            // remains visible during a background refresh.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "loading",
+                error: null,
+            };
+        case "load-success":
+            // RF-04: monotonic revision guard — a stale (lower-revision) reply for
+            // the current session must never overwrite a newer snapshot, so a slow
+            // refresh cannot reorder-overwrite the current session selection. The
+            // fetch layer already drops replies for other sessions (sessionId guard).
+            if (state.snapshot &&
+                state.sessionId === action.sessionId &&
+                action.snapshot.revision < state.snapshot.revision) {
+                return state;
+            }
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "load-failure":
+            // AC-06: a failed load is a STRUCTURED error state — never folded
+            // into a fake empty snapshot.
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "error",
+                error: action.error,
+                snapshot: null,
+            };
+        case "reload-start":
+            // Single-flight: a reload already in progress is NOT queued (AC-06).
+            if (state.reloading)
+                return state;
+            return {
+                ...state,
+                reloading: true,
+                reloadError: null,
+                ...(state.status === "error" ? { error: null } : {}),
+            };
+        case "reload-success":
+            // Atomic replacement: the new snapshot supersedes the old one and
+            // every open panel reads the same revision.
+            return {
+                ...state,
+                status: "ready",
+                snapshot: action.snapshot,
+                reloading: false,
+                reloadError: null,
+                error: null,
+                sessionId: action.snapshot.sessionId || state.sessionId,
+            };
+        case "reload-failure":
+            return {
+                ...state,
+                reloading: false,
+                reloadError: action.error,
+            };
+        case "mutation-start":
+            return {
+                ...state,
+                mutationBusy: true,
+                mutationToken: action.token,
+            };
+        case "mutation-adopt":
+            // RF2-02: atomic adoption of a mutation response snapshot. Three
+            // guards are evaluated BEFORE any write:
+            //   - mutationToken: only the LATEST mutation may adopt — a stale
+            //     out-of-order response is dropped entirely;
+            //   - sessionId: never adopt a mutation response into a state that
+            //     belongs to a different session;
+            //   - revision monotonic: equal/higher revisions adopt, lower reject
+            //     (a stale reply can never reorder-overwrite the selection).
+            // The action NEVER settles mutationBusy (mutation-settle owns that)
+            // and never passes through an intermediate stale/loading state.
+            if (state.mutationToken !== action.token)
+                return state;
+            if (state.sessionId !== undefined &&
+                state.sessionId !== action.sessionId)
+                return state;
+            if (state.snapshot &&
+                action.snapshot.revision < state.snapshot.revision)
+                return state;
+            return {
+                ...state,
+                sessionId: action.sessionId,
+                status: "ready",
+                snapshot: action.snapshot,
+                error: null,
+                reloadError: null,
+                reloading: false,
+            };
+        case "mutation-settle":
+            // RF-04: only the LATEST request token settles the busy state; a
+            // stale (earlier) settle must not clear busy while a newer mutation
+            // is still in flight.
+            if (state.mutationToken !== action.token)
+                return state;
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "mutation-reset":
+            // RF3-02: a session switch immediately abandons the in-flight
+            // mutation lifecycle — the new session must not inherit the old
+            // session's busy state. The adopted snapshot/status stay untouched
+            // (a load-start for the new session follows); stale adopt/settle
+            // actions then become no-ops via the token + sessionId guards.
+            return {
+                ...state,
+                mutationBusy: false,
+                mutationToken: null,
+            };
+        case "reset":
+            return { ...runtimeSnapshotInitialState };
+        default:
+            return state;
+    }
+}
+/**
+ * Derive the session/runtimeContext selection patch from an ADOPTED snapshot
+ * (RF3-01). The hydrate effect in `useRuntimeControls` feeds this patch into
+ * `mergeSessionRuntime` / `runtimeContext`, so derived state only ever comes
+ * from a snapshot the reducer guards accepted — the mutation success branch
+ * never writes session/runtimeContext directly. Missing fields are omitted;
+ * `auto` resolves to the Pi effective thinking level.
+ */
+export function runtimeSelectionFromSnapshot(snapshot) {
+    const selection = snapshot.selection;
+    return {
+        ...(selection.model
+            ? {
+                model: {
+                    provider: selection.model.provider,
+                    modelId: selection.model.id,
+                },
+            }
+            : {}),
+        ...(selection.thinkingSelection === "auto"
+            ? selection.effectiveThinkingLevel
+                ? { thinkingLevel: selection.effectiveThinkingLevel }
+                : {}
+            : { thinkingLevel: selection.thinkingSelection }),
+    };
+}
+/**
+ * RF4: merge an incoming `/runtime-context` response with the ADOPTED snapshot
+ * (coordination seam genuinely called by the production `useRuntimeControls`
+ * context hydration effect; tests import this same symbol — no copied logic).
+ *
+ * Content fields (systemPrompt/resources/suffix/readOnly) always come from the
+ * response. model/thinkingLevel NEVER come from the response body — the
+ * backend returns them without revision semantics, so a late reply for the
+ * same session could carry a stale selection. Selection is derived exclusively
+ * from the adopted snapshot when it matches the current session (same
+ * derivation as the snapshot hydration effect: `runtimeSelectionFromSnapshot`,
+ * `auto` resolves to the Pi effective level); otherwise the current derived
+ * values are preserved, or omitted when absent. The store is never written
+ * here, so the snapshot hydration effect never re-runs.
+ */
+export function mergeRuntimeContextWithSnapshot(current, context, snapshot, sessionId) {
+    const selection = snapshot && snapshot.sessionId === sessionId
+        ? runtimeSelectionFromSnapshot(snapshot)
+        : {};
+    const model = selection.model ?? current?.model;
+    const thinkingLevel = selection.thinkingLevel ?? current?.thinkingLevel;
+    return {
+        readOnly: context.readOnly,
+        systemPrompt: context.systemPrompt,
+        resources: context.resources,
+        suffix: context.suffix,
+        ...(model ? { model } : {}),
+        ...(thinkingLevel ? { thinkingLevel } : {}),
+    };
+}
+/** Create a fresh snapshot store (framework-free; React binding adds fetch). */
+export function createRuntimeSnapshotStore(initial = runtimeSnapshotInitialState) {
+    let state = initial;
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        dispatch: (action) => {
+            state = runtimeSnapshotReducer(state, action);
+            for (const listener of listeners)
+                listener();
+            return state;
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+/** True when the given error is the busy 409 (PI_SESSION_BUSY). */
+export function isSnapshotBusyError(error) {
+    return error?.code === "PI_SESSION_BUSY";
+}

package/dist/worker/console/static-src/operator-chat/session-title-watcher.js ADDED Viewed

@@ -0,0 +1,128 @@
+/**
+ * Owns title-only SSE lifecycles. It is deliberately independent from the
+ * timeline SSE applier: title frames update the session index only.
+ */
+export class SessionTitleWatcher {
+    options;
+    eligible = new Set();
+    controllers = new Map();
+    fetchFn;
+    backoffMs;
+    deadlineMs;
+    constructor(options) {
+        this.options = options;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.backoffMs = options.backoffMs ?? 1_000;
+        this.deadlineMs = options.deadlineMs ?? 30_000;
+    }
+    markEligible(sessionId) {
+        this.eligible.add(sessionId);
+    }
+    startIfEligible(sessionId) {
+        if (!this.eligible.delete(sessionId) || this.controllers.has(sessionId))
+            return;
+        const controller = new AbortController();
+        this.controllers.set(sessionId, controller);
+        void this.run(sessionId, controller);
+    }
+    cancel(sessionId) {
+        this.eligible.delete(sessionId);
+        this.controllers.get(sessionId)?.abort();
+        this.controllers.delete(sessionId);
+    }
+    reconcile(sessionIds) {
+        const current = new Set(sessionIds);
+        for (const sessionId of this.controllers.keys()) {
+            if (!current.has(sessionId))
+                this.cancel(sessionId);
+        }
+    }
+    dispose() {
+        for (const controller of this.controllers.values())
+            controller.abort();
+        this.controllers.clear();
+        this.eligible.clear();
+    }
+    async run(sessionId, controller) {
+        let lastEventId;
+        const seen = new Set();
+        let deadlineReached = false;
+        const deadline = window.setTimeout(() => {
+            deadlineReached = true;
+            controller.abort();
+        }, this.deadlineMs);
+        try {
+            while (!controller.signal.aborted) {
+                try {
+                    const headers = { Accept: "text/event-stream" };
+                    if (lastEventId)
+                        headers["Last-Event-ID"] = lastEventId;
+                    const response = await this.fetchFn(`${this.options.origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`, { headers, credentials: "include", signal: controller.signal });
+                    if (response.status === 404 || !response.body)
+                        return;
+                    if (!response.ok)
+                        throw new Error(`HTTP ${response.status}`);
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = "";
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done || controller.signal.aborted)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const blocks = buffer.split("\n\n");
+                        buffer = blocks.pop() ?? "";
+                        for (const block of blocks) {
+                            const eventId = block.split("\n").find((line) => line.startsWith("id: "))?.slice(4);
+                            if (eventId)
+                                lastEventId = eventId;
+                            if (!eventId || seen.has(eventId) || !block.includes("event: session_title"))
+                                continue;
+                            const data = block.split("\n").find((line) => line.startsWith("data: "))?.slice(6);
+                            if (!data)
+                                continue;
+                            try {
+                                const parsed = JSON.parse(data);
+                                const title = parsed.data?.title?.trim();
+                                if (!title)
+                                    continue;
+                                seen.add(eventId);
+                                if (!this.options.hasSession(sessionId))
+                                    return;
+                                this.options.onTitle(sessionId, { title, automatic: Boolean(parsed.data?.automatic) });
+                                if (parsed.data?.automatic)
+                                    return;
+                            }
+                            catch { /* malformed title frames are ignored */ }
+                        }
+                    }
+                }
+                catch {
+                    if (controller.signal.aborted)
+                        return;
+                }
+                if (!controller.signal.aborted)
+                    await abortableSleep(this.backoffMs, controller.signal);
+            }
+        }
+        finally {
+            window.clearTimeout(deadline);
+            if (this.controllers.get(sessionId) === controller)
+                this.controllers.delete(sessionId);
+            if (deadlineReached || !this.options.hasSession(sessionId))
+                void this.options.refresh();
+        }
+    }
+}
+function abortableSleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = window.setTimeout(done, ms);
+        const onAbort = () => done();
+        function done() {
+            window.clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/worker/console/static-src/operator-chat/sidebar-split.js ADDED Viewed

@@ -0,0 +1,90 @@
+/** Session/repo vertical split percent with versioned localStorage. */
+export const SIDEBAR_SPLIT_STORAGE_KEY = "loop-console.operator-chat.sidebar-split.v1";
+export const SIDEBAR_SPLIT_DEFAULT = 45;
+export const SIDEBAR_SPLIT_MIN = 28;
+export const SIDEBAR_SPLIT_MAX = 70;
+export const SIDEBAR_SPLIT_STEP = 5;
+export const SIDEBAR_SPLIT_STEP_LARGE = 10;
+/** Clamp session share percent into the legal 28–70 band. */
+export function clampSplit(percent) {
+    if (!Number.isFinite(percent))
+        return SIDEBAR_SPLIT_DEFAULT;
+    return Math.min(SIDEBAR_SPLIT_MAX, Math.max(SIDEBAR_SPLIT_MIN, Math.round(percent)));
+}
+/** Parse a stored value; only integers in 28–70 are accepted. */
+export function parseStoredSplit(raw) {
+    if (raw == null || raw === "")
+        return null;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return null;
+    const rounded = Math.round(n);
+    if (rounded < SIDEBAR_SPLIT_MIN || rounded > SIDEBAR_SPLIT_MAX)
+        return null;
+    return rounded;
+}
+/** Load session percent or fall back to 45 on missing/corrupt storage. */
+export function loadSidebarSplit(storage = defaultStorage()) {
+    if (!storage)
+        return SIDEBAR_SPLIT_DEFAULT;
+    try {
+        const parsed = parseStoredSplit(storage.getItem(SIDEBAR_SPLIT_STORAGE_KEY));
+        return parsed ?? SIDEBAR_SPLIT_DEFAULT;
+    }
+    catch {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+}
+/** Persist a clamped session percent; ignore storage failures. */
+export function saveSidebarSplit(percent, storage = defaultStorage()) {
+    const value = clampSplit(percent);
+    if (!storage)
+        return value;
+    try {
+        storage.setItem(SIDEBAR_SPLIT_STORAGE_KEY, String(value));
+    }
+    catch {
+        // localStorage may be unavailable; keep in-memory value.
+    }
+    return value;
+}
+/** Map keyboard keys on the separator to a next session percent. */
+export function adjustSplitByKey(current, key, shiftKey = false) {
+    const base = clampSplit(current);
+    switch (key) {
+        case "ArrowUp":
+            return clampSplit(base - (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "ArrowDown":
+            return clampSplit(base + (shiftKey ? SIDEBAR_SPLIT_STEP_LARGE : SIDEBAR_SPLIT_STEP));
+        case "Home":
+            return SIDEBAR_SPLIT_MIN;
+        case "End":
+            return SIDEBAR_SPLIT_MAX;
+        case "Enter":
+            return SIDEBAR_SPLIT_DEFAULT;
+        default:
+            return null;
+    }
+}
+/**
+ * Compute session percent from a pointer Y within a split track rect.
+ * top of track → min session share; bottom → max session share.
+ */
+export function splitPercentFromPointer(clientY, trackTop, trackHeight) {
+    if (!Number.isFinite(trackHeight) || trackHeight <= 0) {
+        return SIDEBAR_SPLIT_DEFAULT;
+    }
+    const ratio = (clientY - trackTop) / trackHeight;
+    return clampSplit(ratio * 100);
+}
+function defaultStorage() {
+    try {
+        if (typeof globalThis === "undefined")
+            return null;
+        const storage = globalThis.localStorage;
+        return storage ?? null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Mutual-exclusion state for large spatial overlays in Operator Chat.
+ * At most one of: sidebar drawer, process, runtime context, tools.
+ * Small composer menus (model/thinking) are out of scope.
+ */
+export function createSpatialOverlayState(active = "none") {
+    return { active };
+}
+/** Open one overlay; closes any other spatial overlay. */
+export function openSpatialOverlay(_state, kind) {
+    return { active: kind };
+}
+/** Close the active overlay (or no-op when already none). */
+export function closeSpatialOverlay(_state = { active: "none" }) {
+    return { active: "none" };
+}
+/** Close only when the named overlay is active. */
+export function closeSpatialOverlayIf(state, kind) {
+    return state.active === kind ? { active: "none" } : state;
+}
+export function isSpatialOverlayOpen(state, kind) {
+    if (kind)
+        return state.active === kind;
+    return state.active !== "none";
+}
+/**
+ * Derive exclusive UI flags for the four large panels from a single source.
+ * Opening one forces the others closed.
+ */
+export function spatialOverlayFlags(state) {
+    return {
+        sidebarDrawerOpen: state.active === "sidebar-drawer",
+        processOpen: state.active === "process",
+        runtimeContextOpen: state.active === "runtime-context",
+        toolsOpen: state.active === "tools",
+    };
+}