@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

package/src/tui/dialogs/status-dialog-render.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Renders the shipped, compiled `/ctx-status` dialog for every status payload
+ * the dialog can receive, and checks that each one draws and none throws.
+ *
+ * Previously the dialog read the RPC reply unchecked: a reply without
+ * `usagePercentage` (the server's `{ disabled: true }` answer for a home
+ * directory or a paused project identity) threw inside the view memo, and
+ * OpenCode's crash screen then reported the follow-on
+ * "undefined is not an object (evaluating 'view().headline')".
+ *
+ * It also checks that the dialog stays inside the surface the host gives it.
+ * The dialog sized its section grid from the terminal width instead of its own
+ * laid-out width (it listened for an event plain boxes never emit), so inside
+ * OpenCode's 60-column dialog the two fixed-width section columns ran past the
+ * dialog's right edge (issue 605).
+ *
+ * The rendering happens in `scripts/render-compiled-status-dialog.ts`, a child
+ * process, because it has to register OpenCode's runtime module registry and
+ * that registration cannot be undone inside this test process. The child runs
+ * with the `browser` condition so `solid-js` is the reactive build OpenCode
+ * runs; the server build Bun picks by default never re-renders after layout.
+ */
+import { beforeAll, describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import { checkStatusDetailPayload, statusRpcFailure } from "../../shared/status-view-check";
+import type { StatusDetailResult } from "../data/context-db";
+
+const UI = "0.44.5";
+
+const COMPLETE = {
+    sessionId: "ses_complete",
+    pluginVersion: UI,
+    usagePercentage: 12.5,
+    inputTokens: 25_000,
+    contextLimit: 200_000,
+    executeThreshold: 65,
+    systemPromptTokens: 5_000,
+    docsTokens: 0,
+    compartmentTokens: 0,
+    compartmentCount: 0,
+    factTokens: 0,
+    memoryTokens: 0,
+    memoryBlockCount: 0,
+    profileTokens: 0,
+    conversationTokens: 20_000,
+    toolCallTokens: 0,
+    toolDefinitionTokens: 0,
+    activeTags: 0,
+    droppedTags: 0,
+    totalTags: 0,
+    activeBytes: 0,
+    lastNudgeTokens: 0,
+    pendingOpsCount: 0,
+    protectedTagCount: 0,
+    isSubagent: false,
+    cacheTtl: "5m",
+    lastResponseTime: 0,
+    cacheRemainingMs: 0,
+    cacheExpired: false,
+    historyBlockTokens: 0,
+    compressionBudget: null,
+    compressionUsage: null,
+    memoryCount: 0,
+};
+const { pluginVersion: _omitted, ...OLDER_SERVER } = COMPLETE;
+
+const CASES: Array<{ name: string; status: StatusDetailResult; expected: string[] }> = [
+    {
+        name: "a complete snapshot",
+        status: checkStatusDetailPayload(COMPLETE, UI),
+        expected: ["Magic Context Status", "12.5% / 65%"],
+    },
+    {
+        name: "an RPC transport failure",
+        status: statusRpcFailure("connect ECONNREFUSED"),
+        expected: ["Status unavailable", "server did not answer"],
+    },
+    {
+        name: "an error envelope",
+        status: checkStatusDetailPayload({ error: "unavailable" }, UI),
+        expected: ["Status unavailable", "server did not answer"],
+    },
+    {
+        name: "the home-directory reply",
+        status: checkStatusDetailPayload({ sessionId: "s", disabled: true }, UI),
+        expected: ["Status unavailable", "home directory"],
+    },
+    {
+        name: "the paused-identity reply",
+        status: checkStatusDetailPayload({ sessionId: "s", disabled: true, paused: true }, UI),
+        expected: ["Status unavailable", "memory paused"],
+    },
+    {
+        name: "an empty reply",
+        status: checkStatusDetailPayload({}, UI),
+        expected: ["Status unavailable", "incomplete status data"],
+    },
+    {
+        name: "an older server's snapshot",
+        status: checkStatusDetailPayload(OLDER_SERVER, UI),
+        expected: ["12.5% / 65%", "An older Magic Context server"],
+    },
+];
+
+/**
+ * Layout cases: the dialog inside a host surface of `dialogWidth` columns on a
+ * terminal of `terminalWidth` columns. OpenCode's dialog is 60 columns unless a
+ * dialog asks to be wider, and never wider than the terminal minus 2; 88 is its
+ * "large" size. The child process's stdout is a pipe, so the dialog sees no
+ * terminal width at all, the same fallback it takes on a very wide terminal.
+ */
+type LayoutCase = {
+    name: string;
+    status: StatusDetailResult;
+    terminalWidth: number;
+    dialogWidth: number;
+    expected: string[];
+    /**
+     * Label/value pairs that must each be drawn whole on one line, the label
+     * followed by its complete value. A value cut off at a column edge fails.
+     */
+    rows?: Array<[label: string, value: string]>;
+};
+
+/** Rows of the complete snapshot drawn from both section columns. */
+const COMPLETE_ROWS: Array<[string, string]> = [
+    ["Active", "0 (~0 B)"],
+    ["Execute threshold", "65%"],
+    ["Last reduce anchor", "0 tok"],
+    ["Subagent", "no"],
+    ["History block", "~0 tok"],
+    ["Auto-execute", "at TTL or ≥65%"],
+];
+
+const LONG_MODEL_KEY =
+    "openrouter/anthropic/claude-sonnet-4.5-20250929-thinking-extended-context-preview";
+const LONG_VALUE_STATUS = checkStatusDetailPayload(
+    { ...COMPLETE, cacheTtlSource: "config", cacheTtlModelKey: LONG_MODEL_KEY },
+    UI,
+);
+
+const LAYOUT_CASES: LayoutCase[] = [
+    ...[80, 100, 120].map((terminalWidth) => ({
+        name: `a complete snapshot in the default 60-column dialog, terminal ${terminalWidth} columns wide`,
+        status: checkStatusDetailPayload(COMPLETE, UI),
+        terminalWidth,
+        dialogWidth: 60,
+        expected: ["Magic Context Status", "Execute threshold", "History block", "Esc to close"],
+        rows: COMPLETE_ROWS,
+    })),
+    ...[100, 120].map((terminalWidth) => ({
+        name: `a complete snapshot in an 88-column dialog, terminal ${terminalWidth} columns wide`,
+        status: checkStatusDetailPayload(COMPLETE, UI),
+        terminalWidth,
+        dialogWidth: 88,
+        expected: ["Magic Context Status", "Execute threshold", "History block", "Esc to close"],
+        rows: COMPLETE_ROWS,
+    })),
+    {
+        // The value is longer than the dialog: it has to wrap inside the value
+        // column, and its end still has to be drawn.
+        name: "a long cache TTL model key in the default 60-column dialog, terminal 80 columns wide",
+        status: LONG_VALUE_STATUS,
+        terminalWidth: 80,
+        dialogWidth: 60,
+        expected: ["Configured", "context-preview)", "Execute threshold", "Esc to close"],
+        rows: COMPLETE_ROWS,
+    },
+];
+
+/**
+ * The same dialog when its width update never lands: the first frame, drawn
+ * before the dialog has measured itself, or a render (like a bare component
+ * render on Bun's non-reactive `solid-js` build) where nothing re-runs after
+ * layout. The section grid is then chosen against the terminal-width fallback,
+ * and the columns still have to stay inside the dialog.
+ */
+const STALE_WIDTH_CASES: LayoutCase[] = [
+    {
+        name: "a complete snapshot laid out before the dialog measured itself",
+        status: checkStatusDetailPayload(COMPLETE, UI),
+        terminalWidth: 80,
+        dialogWidth: 60,
+        expected: ["Magic Context Status", "Tags", "Esc to close"],
+    },
+    {
+        name: "a long cache TTL model key laid out before the dialog measured itself",
+        status: LONG_VALUE_STATUS,
+        terminalWidth: 80,
+        dialogWidth: 60,
+        expected: ["Magic Context Status", "Configured", "Esc to close"],
+    },
+];
+
+/**
+ * Lines of `frame` that draw anything at or past `rightEdge`, the first column
+ * of the dialog's right padding. The dialog surface starts at column 0, so a
+ * line that stays inside the dialog is blank from that column on.
+ */
+function linesPastEdge(frame: string, rightEdge: number): string[] {
+    return frame.split("\n").filter((line) => line.slice(rightEdge).trim() !== "");
+}
+
+function escapeRegExp(text: string): string {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** Pairs from `rows` that no line of `frame` draws as `label  value` whole. */
+function rowsNotDrawnWhole(frame: string, rows: Array<[string, string]>): string[] {
+    const lines = frame.split("\n");
+    return rows
+        .filter(([label, value]) => {
+            const pattern = new RegExp(`${escapeRegExp(label)} +${escapeRegExp(value)}(\\s|$)`);
+            return !lines.some((line) => pattern.test(line));
+        })
+        .map(([label, value]) => `${label}: ${value}`);
+}
+
+type RenderResult = { frame?: string; error?: string };
+
+/** Runs the render script on `input`, with extra Bun flags before the script. */
+function renderInChild(input: unknown[], bunFlags: string[]): RenderResult[] {
+    const script = join(import.meta.dir, "../../../scripts/render-compiled-status-dialog.ts");
+    const child = Bun.spawnSync(["bun", ...bunFlags, script], {
+        stdin: new TextEncoder().encode(JSON.stringify(input)),
+        stdout: "pipe",
+        stderr: "pipe",
+        windowsHide: true,
+    });
+    if (child.exitCode !== 0) {
+        throw new Error(`render script failed: ${child.stderr.toString()}`);
+    }
+    return JSON.parse(child.stdout.toString());
+}
+
+const layoutInput = (cases: LayoutCase[]) =>
+    cases.map(({ status, terminalWidth, dialogWidth }) => ({ status, terminalWidth, dialogWidth }));
+
+let results: RenderResult[] = [];
+let staleResults: RenderResult[] = [];
+
+beforeAll(() => {
+    results = renderInChild(
+        [...CASES.map((entry) => ({ status: entry.status })), ...layoutInput(LAYOUT_CASES)],
+        ["--conditions=browser"],
+    );
+    // No `browser` condition: Bun's server build of solid-js, where the dialog
+    // keeps the layout it chose before it knew its own width.
+    staleResults = renderInChild(layoutInput(STALE_WIDTH_CASES), []);
+}, 60_000);
+
+describe("compiled /ctx-status dialog", () => {
+    for (const [index, entry] of CASES.entries()) {
+        test(`draws ${entry.name} without throwing`, () => {
+            const result = results[index];
+            expect(result?.error).toBeUndefined();
+            for (const text of entry.expected) expect(result?.frame).toContain(text);
+        });
+    }
+});
+
+function expectInsideDialog(entry: LayoutCase, result: RenderResult | undefined): void {
+    expect(result?.error).toBeUndefined();
+    const frame = result?.frame ?? "";
+    for (const text of entry.expected) expect(frame).toContain(text);
+    // The dialog's own right padding is 2 columns, so its content ends 2
+    // columns before the surface's edge.
+    const surfaceWidth = Math.min(entry.dialogWidth, entry.terminalWidth - 2);
+    expect(linesPastEdge(frame, surfaceWidth - 2)).toEqual([]);
+    if (entry.rows) expect(rowsNotDrawnWhole(frame, entry.rows)).toEqual([]);
+}
+
+describe("compiled /ctx-status dialog layout", () => {
+    for (const [index, entry] of LAYOUT_CASES.entries()) {
+        test(`keeps ${entry.name} inside the dialog`, () => {
+            expectInsideDialog(entry, results[CASES.length + index]);
+        });
+    }
+    for (const [index, entry] of STALE_WIDTH_CASES.entries()) {
+        test(`keeps ${entry.name} inside the dialog`, () => {
+            expectInsideDialog(entry, staleResults[index]);
+        });
+    }
+});

package/src/tui/dialogs/status-dialog.tsx

@@ -12,18 +12,16 @@
 import { createMemo, createSignal, onCleanup } from "solid-js"
 import type { TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import packageJson from "../../../package.json"
-import { statusSummaryFromDetail } from "../../shared/status-summary"
 import {
-    buildStatusView,
+    buildStatusViewFor,
     distributeBarWidths,
     statusColumnsFor,
     type StatusRow,
     type StatusSection,
     type StatusTone,
-    type StatusViewSource,
 } from "../../shared/status-view"
 import { RUST_MODE_HOST_PATHS_LINE } from "../../shared/rust-mode-status"
-import type { StatusDetail } from "../data/context-db"
+import type { StatusDetailResult } from "../data/context-db"
 
 const R = (props: { t: TuiThemeCurrent; l: string; v: string; fg?: string }) => (
     <box width="100%" flexDirection="row" justifyContent="space-between">
@@ -48,10 +46,13 @@ function toneColor(theme: TuiThemeCurrent, tone: StatusTone): string {
 
 /**
  * Width the dialog is actually laid out at, which is NOT the terminal width:
- * each host sizes its own dialog surface (OpenCode 2's widest is 88 columns on
- * a 200-column terminal), and that is the width the sections have to fit into.
- * Renderables carry their laid-out width and emit "resized" when it changes, so
- * the component reads it from its own root box.
+ * each host sizes its own dialog surface (OpenCode 1's default is 60 columns,
+ * OpenCode 2's widest is 88 columns on a 200-column terminal), and that is the
+ * width the sections have to fit into. Renderables carry their laid-out width
+ * and emit "resize" when a layout pass changes it, so the component reads it
+ * from its own root box. ("resized", with a d, is emitted only by the
+ * renderer's root; a box never sends it, and listening for it left the dialog
+ * sizing its sections from the terminal width forever.)
  *
  * Until the first layout there is no width to read; the terminal width is the
  * fallback, and an unknown terminal keeps the wide layout the dialog has always
@@ -83,35 +84,27 @@ const StatusSectionView = (props: { t: TuiThemeCurrent; section: StatusSection }
     </box>
 )
 
-export const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
+/**
+ * `status` is the checked result of the status RPC (`loadStatusDetail`), never
+ * the raw reply: a reply the view cannot draw arrives as the reason it cannot,
+ * and the shared model turns that into a "status unavailable" view. An
+ * unchecked reply used to reach the view model directly, where a missing field
+ * threw inside this component's first render and crashed the whole TUI.
+ */
+export const StatusDialog = (props: { api: TuiPluginApi; status: StatusDetailResult }) => {
     const theme = createMemo(() => (props.api as any).theme.current)
     const t = () => theme()
-    const s = () => props.s
-    const compactionOff = () => s().compaction_enabled === false
-
-    // Prefer the RPC-provided model context limit (what the sidebar shows) so the
-    // two surfaces never disagree. Fall back to deriving from usage% only when the
-    // RPC limit is absent (0) — and that derivation is itself undefined at 0%, so
-    // it stays "?" rather than showing a number inconsistent with the sidebar.
-    const contextLimit = () =>
-        s().contextLimit > 0
-            ? s().contextLimit
-            : s().usagePercentage > 0
-              ? Math.round(s().inputTokens / (s().usagePercentage / 100))
-              : 0
+    const ready = () => (props.status.state === "ready" ? props.status : null)
+    const compactionOff = () => ready()?.source.compaction_enabled === false
+    const recompProgress = () => ready()?.extras.recompProgress ?? null
+    const hostBackendsModuleSide = () => ready()?.extras.hostBackendsModuleSide === true
 
     // Which rows exist, what they are called and which colour they carry is
     // decided by the shared model, so this dialog and Pi's overlay cannot drift
-    // apart. This component only draws what the model returns.
+    // apart. This component only draws what the model returns, and the model
+    // never throws: a result it cannot draw becomes the unavailable view.
     const view = createMemo(() =>
-        buildStatusView(
-            {
-                ...(s() as unknown as StatusViewSource),
-                contextLimit: contextLimit(),
-                warnings: statusSummaryFromDetail(s()).warnings,
-            },
-            { version: packageJson.version },
-        ),
+        buildStatusViewFor(props.status, { version: packageJson.version }),
     )
     // The dialog's own laid-out width, which is what the sections have to fit
     // into; the terminal width is only the pre-layout fallback.
@@ -122,8 +115,8 @@ export const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
             if (Number.isFinite(width) && width > 0) setDialogWidth(width)
         }
         read()
-        element?.on?.("resized", read)
-        onCleanup(() => element?.off?.("resized", read))
+        element?.on?.("resize", read)
+        onCleanup(() => element?.off?.("resize", read))
     }
     // paddingLeft + paddingRight below; what the sections get is what is left.
     const contentWidth = () => (dialogWidth() > 0 ? dialogWidth() - 4 : terminalColumns())
@@ -206,8 +199,8 @@ export const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 running or just finished — dogfood 2026-05-30). This is live run
                 state rather than status content, so it stays out of the shared
                 section model. */}
-            {!compactionOff() && s().recompProgress && (() => {
-                const p = s().recompProgress!
+            {!compactionOff() && recompProgress() && (() => {
+                const p = recompProgress()!
                 // Label follows the flow that started the run, so a plain
                 // /ctx-recomp never reads as an "Upgrade" (dogfood 2026-06-04).
                 const verb = p.kind === "upgrade" ? "Upgrade" : p.kind === "embed" ? "Embed" : "Recomp"
@@ -242,21 +235,31 @@ export const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 )
             })()}
 
-            {s().hostBackendsModuleSide && (
+            {hostBackendsModuleSide() && (
                 <box marginTop={1} width="100%" flexDirection="column">
                     <text fg={t().text}><b>Rust Mode</b></text>
                     <text fg={t().textMuted}>{RUST_MODE_HOST_PATHS_LINE}</text>
                 </box>
             )}
 
+            {/* Each column asks for the width its sections need, but may
+                shrink: until the dialog has measured itself the grid is chosen
+                against the terminal width, and a column that could not shrink
+                would then run past the dialog's right edge. Shrinking wraps a
+                value inside its column instead, and anything still wider
+                than a squeezed column (a fixed-width label) is clipped at the
+                column's edge rather than drawn past the dialog. The request is
+                a flexBasis, not a width: OpenTUI turns flexShrink back to 0
+                whenever a box gets a numeric width, so a fixed-width column
+                never shrinks. */}
             {columns().twoColumn ? (
                 <box flexDirection="row" width="100%" gap={4}>
-                    <box flexDirection="column" width={columns().leftWidth} flexShrink={0}>
+                    <box flexDirection="column" flexBasis={columns().leftWidth} flexGrow={0} flexShrink={1} minWidth={0} overflow="hidden">
                         {columnSections(0).map((section) => (
                             <StatusSectionView t={t()} section={section} />
                         ))}
                     </box>
-                    <box flexDirection="column" width={columns().rightWidth} flexShrink={0}>
+                    <box flexDirection="column" flexBasis={columns().rightWidth} flexGrow={0} flexShrink={1} minWidth={0} overflow="hidden">
                         {columnSections(1).map((section) => (
                             <StatusSectionView t={t()} section={section} />
                         ))}

package/src/tui/index.tsx

@@ -3,13 +3,13 @@
 import { createMemo } from "solid-js"
 import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
 import { StatusDialog } from "./dialogs/status-dialog"
-import { renderUserFacingFailure, userFacingFailureCode } from '../shared/user-facing-codes';
 import {
     createSidebarContentSlot,
     kickRecompProgressRefresh,
     refreshSidebarSnapshot,
 } from "./slots/sidebar-content"
-import { closeRpc, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, type EmbedDetail, type StatusDetail } from "./data/context-db"
+import { closeRpc, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, type EmbedDetail } from "./data/context-db"
+import { directoryForSession } from "./data/session-directory"
 import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
 import { isCompactionEnabled } from "../config/agent-disable"
 import { loadPluginConfig } from "../config"
@@ -125,6 +125,20 @@ function getSessionId(api: TuiPluginApi): string | null {
     return null
 }
 
+/**
+ * The directory whose Magic Context server owns this session, which is not
+ * necessarily the directory the TUI started in (see `directoryForSession`).
+ */
+function sessionDirectory(api: TuiPluginApi, sessionId: string): string {
+    let reported: unknown
+    try {
+        reported = api.state.session.get(sessionId)?.directory
+    } catch {
+        // Session state not available yet: fall back to the startup directory.
+    }
+    return directoryForSession(reported, api.state.path.directory ?? "")
+}
+
 function getModelKeyFromMessages(api: TuiPluginApi, sessionId: string): string | undefined {
     try {
         const msgs = api.state.session.messages(sessionId)
@@ -156,7 +170,7 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
         return false
     }
 
-    const countResult = await getCompartmentCount(sessionId, api.state.path.directory ?? "")
+    const countResult = await getCompartmentCount(sessionId, sessionDirectory(api, sessionId))
     // Ack only after the dialog is actually shown for the same active session;
     // route switches while the RPC detail load is in flight must leave it pending.
     if (getSessionId(api) !== sessionId) return false
@@ -180,7 +194,7 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
                 "Proceed?",
             ].join("\n")}
             onConfirm={async () => {
-                const requested = await requestRecomp(sessionId)
+                const requested = await requestRecomp(sessionId, sessionDirectory(api, sessionId))
                 if (!requested) {
                     showToast(api, { message: "Recomp request failed", variant: "error" })
                     return
@@ -206,22 +220,15 @@ async function showStatusDialog(
         return false
     }
 
-    const directory = api.state.path.directory ?? ""
+    const directory = sessionDirectory(api, sessionId)
     const modelKey = getModelKeyFromMessages(api, sessionId)
     const result = await loadStatusDetail(sessionId, directory, modelKey)
     if (getSessionId(api) !== sessionId) return false
-    if (!result.ok) {
-        console.error(
-            `[magic-context] status unavailable code=${userFacingFailureCode("status_unavailable")}: ${result.error}`,
-        )
-        showToast(api, {
-            message: renderUserFacingFailure("status_unavailable"),
-            variant: "warning",
-        })
-        return false
-    }
-
-    api.ui.dialog.replace(() => <StatusDialog api={api} s={result.detail} />)
+    // A result without a usable snapshot still opens the dialog: it shows the
+    // "status unavailable" view naming the reason (RPC error, a directory the
+    // server keeps no state for, missing fields, a server/UI version
+    // difference) instead of a toast that disappears.
+    api.ui.dialog.replace(() => <StatusDialog api={api} status={result} />)
     return true
 }
 
@@ -247,7 +254,7 @@ async function showEmbedDialog(api: TuiPluginApi, targetSessionId = getSessionId
         api.ui.toast({ message: "No active session", variant: "warning" })
         return false
     }
-    const directory = api.state.path.directory ?? ""
+    const directory = sessionDirectory(api, sessionId)
     const detail = await loadEmbedDetail(sessionId, directory)
     if (getSessionId(api) !== sessionId) return false
     api.ui.dialog.replace(() => <EmbedDialog api={api} detail={detail} />)
@@ -747,6 +754,11 @@ const tui: TuiPlugin = async (api, _options, meta) => {
 
     startNotificationSocket({
         getSessionId: () => getSessionId(api),
+        // Follow the shown session's own server, whose commands push its dialogs.
+        getSessionDirectory: () => {
+            const sessionId = getSessionId(api)
+            return sessionId ? sessionDirectory(api, sessionId) : null
+        },
         onNotification: handleNotification,
     })
 

package/src/tui/slots/sidebar-content.tsx

@@ -4,6 +4,7 @@ import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/
 import packageJson from "../../../package.json"
 import { badgeTextColor } from '../badge-contrast';
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
+import { directoryForSession } from "../data/session-directory"
 import { formatThresholdPercent } from "../../shared/format-threshold"
 import { renderUserFacingFailure } from "../../shared/user-facing-codes"
 import { compactionOffSidebarRows, nativeCompactionContextLabel } from "../compaction-off"
@@ -534,7 +535,10 @@ const SidebarContent = (props: {
         const sid = props.sessionID()
         if (!sid) return
         const sequence = ++snapshotRequestSequence
-        const directory = props.api.state.path.directory ?? ""
+        const directory = directoryForSession(
+            props.api.state.session?.get?.(sid)?.directory,
+            props.api.state.path.directory ?? "",
+        )
         void loadSidebarSnapshot(sid, directory)
             .then((data) => {
                 // Guard against a session switch while this load was in flight:
@@ -600,7 +604,10 @@ const SidebarContent = (props: {
             return
         }
         const sequence = ++snapshotRequestSequence
-        const directory = props.api.state.path.directory ?? ""
+        const directory = directoryForSession(
+            props.api.state.session?.get?.(sid)?.directory,
+            props.api.state.path.directory ?? "",
+        )
         void loadSidebarSnapshot(sid, directory)
             .then((data) => {
                 if (