@cortexkit/opencode-magic-context 0.44.4 → 0.45.0

package/src/tui-compiled/data/context-db.ts

@@ -3,14 +3,38 @@
  * All data is fetched from the server plugin via HTTP RPC.
  */
 import { getMagicContextStorageDir } from "../../shared/data-path";
-import { MagicContextRpcClient } from "../../shared/rpc-client";
+import { pluginPackageVersion } from "../../shared/plugin-package-version";
+import { MagicContextRpcClient, RpcServerNotFoundError } from "../../shared/rpc-client";
 import type { EmbedDetail, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
+import {
+    checkStatusDetailPayload,
+    type OpenCodeStatusExtras,
+    type StatusCheck,
+    statusRpcFailure,
+} from "../../shared/status-view-check";
 
 export type { EmbedDetail, SidebarSnapshot, StatusDetail };
 
 let rpcClient: MagicContextRpcClient | null = null;
+let rpcClientDirectory: string | null = null;
 let rpcGeneration = 0;
 
+/**
+ * Clients for session directories other than the one the TUI started in.
+ *
+ * OpenCode runs one Magic Context server instance per directory, and each one
+ * writes its RPC discovery file under that directory's hash. A TUI started in
+ * one directory (commonly the home directory) can show a session whose
+ * directory is another project; asking the startup directory's server about
+ * that session returns the startup directory's answer (for the home directory:
+ * no project state at all), so the sidebar and `/ctx-status` showed nothing.
+ * Session-scoped calls therefore go to the client for the session's own
+ * directory. The startup client stays as it is for the notification socket and
+ * the process-wide calls.
+ */
+const sessionDirectoryClients = new Map<string, MagicContextRpcClient>();
+const MAX_SESSION_DIRECTORY_CLIENTS = 16;
+
 /** Initialize the RPC client. Call once on TUI startup. */
 export function initRpcClient(directory: string): void {
     const storageDir = getMagicContextStorageDir();
@@ -19,6 +43,127 @@ export function initRpcClient(directory: string): void {
     // new generation and abandons its in-flight connect).
     rpcGeneration += 1;
     rpcClient = new MagicContextRpcClient(storageDir, directory);
+    rpcClientDirectory = directory;
+    resetSessionDirectoryClients();
+}
+
+function resetSessionDirectoryClients(): void {
+    for (const client of sessionDirectoryClients.values()) client.reset();
+    sessionDirectoryClients.clear();
+}
+
+/**
+ * The client for the server instance that owns `directory`: the startup client
+ * when the directory is the one the TUI started in (or unknown), otherwise a
+ * client discovering that directory's own server. Null before init.
+ */
+function clientForDirectory(directory: string): MagicContextRpcClient | null {
+    if (!rpcClient) return null;
+    if (!directory || directory === rpcClientDirectory) return rpcClient;
+    const existing = sessionDirectoryClients.get(directory);
+    if (existing) return existing;
+    if (sessionDirectoryClients.size >= MAX_SESSION_DIRECTORY_CLIENTS) {
+        const oldest = sessionDirectoryClients.keys().next().value;
+        if (oldest !== undefined) {
+            sessionDirectoryClients.get(oldest)?.reset();
+            sessionDirectoryClients.delete(oldest);
+        }
+    }
+    // Short resolution: when this directory has no discovery file the caller
+    // falls back to asking every local server (see `callSessionRpc`) instead of
+    // retrying the miss for fifteen seconds.
+    const client = new MagicContextRpcClient(getMagicContextStorageDir(), directory, {
+        resolveAttempts: 2,
+        reresolveAttempts: 1,
+    });
+    sessionDirectoryClients.set(directory, client);
+    return client;
+}
+
+/**
+ * The server the notification socket should subscribe to: the one that owns
+ * the shown session's directory, so a push from the command that session runs
+ * (for example `/ctx-status` asking to open its dialog) reaches this TUI. That
+ * is the startup directory's server when no session is shown or the session is
+ * in the startup directory. A session directory with no discovery file falls
+ * back to the server that claims the session, then to the startup server so
+ * session-less notifications still arrive.
+ */
+export async function resolveNotificationTarget(
+    sessionDirectory: string | null,
+    sessionId: string | null,
+): Promise<{
+    client: MagicContextRpcClient;
+    directory: string;
+    endpoint: { port: number; token: string | null; instanceId: string | null };
+} | null> {
+    const startup = rpcClient;
+    if (!startup) return null;
+    const directory = sessionDirectory ?? "";
+    let client = clientForDirectory(directory) ?? startup;
+    let endpoint = await client.resolveEndpoint();
+    if (!endpoint && client !== startup && sessionId) {
+        const owner = await MagicContextRpcClient.findSessionOwner(
+            getMagicContextStorageDir(),
+            sessionId,
+        );
+        if (owner) {
+            sessionDirectoryClients.get(directory)?.reset();
+            sessionDirectoryClients.set(directory, owner);
+            client = owner;
+            endpoint = await owner.resolveEndpoint();
+        }
+    }
+    if (endpoint) {
+        return {
+            client,
+            directory: client === startup ? (rpcClientDirectory ?? "") : directory,
+            endpoint,
+        };
+    }
+    if (client === startup) return null;
+    const startupEndpoint = await startup.resolveEndpoint();
+    return startupEndpoint
+        ? { client: startup, directory: rpcClientDirectory ?? "", endpoint: startupEndpoint }
+        : null;
+}
+
+/** The directory whose server a notification subscription for `sessionDirectory` targets first. */
+export function notificationDirectoryFor(sessionDirectory: string | null): string {
+    const directory = sessionDirectory ?? "";
+    if (!directory || directory === rpcClientDirectory) return rpcClientDirectory ?? "";
+    return directory;
+}
+
+/**
+ * Call a session-scoped RPC on the server that owns the session's directory.
+ * When no server is filed under that directory (the host spelled it in a way
+ * the canonical form still does not match), every live local server is asked
+ * whether it owns the session, and the owner, if any, answers this call and
+ * later ones for the directory. Only when no server claims the session does
+ * the call fail as before.
+ */
+async function callSessionRpc<T>(
+    directory: string,
+    sessionId: string,
+    method: string,
+    params: Record<string, unknown>,
+): Promise<T> {
+    const client = clientForDirectory(directory);
+    if (!client) throw new Error("RPC client is not initialized");
+    try {
+        return await client.call<T>(method, params);
+    } catch (error) {
+        if (!(error instanceof RpcServerNotFoundError) || client === rpcClient) throw error;
+        const owner = await MagicContextRpcClient.findSessionOwner(
+            getMagicContextStorageDir(),
+            sessionId,
+        );
+        if (!owner) throw error;
+        sessionDirectoryClients.get(directory)?.reset();
+        sessionDirectoryClients.set(directory, owner);
+        return owner.call<T>(method, params);
+    }
 }
 
 export function getRpcGeneration(): number {
@@ -38,6 +183,8 @@ export function closeRpc(): void {
     rpcGeneration += 1;
     rpcClient?.reset();
     rpcClient = null;
+    rpcClientDirectory = null;
+    resetSessionDirectoryClients();
 }
 
 const EMPTY_SNAPSHOT: SidebarSnapshot = {
@@ -134,10 +281,15 @@ export async function loadSidebarSnapshot(
     const empty: SidebarSnapshot = { ...EMPTY_SNAPSHOT, sessionId };
     if (!rpcClient) return recallSidebarSnapshot(sessionId, empty);
     try {
-        const result = await rpcClient.call<SidebarSnapshot>("sidebar-snapshot", {
-            sessionId,
+        const result = await callSessionRpc<SidebarSnapshot>(
             directory,
-        });
+            sessionId,
+            "sidebar-snapshot",
+            {
+                sessionId,
+                directory,
+            },
+        );
         if ((result as unknown as Record<string, unknown>).error) {
             // Snapshot-build errors are explicit failure envelopes, equivalent to
             // a transport failure: retain the last known-good client snapshot.
@@ -162,26 +314,29 @@ export async function loadSidebarSnapshot(
     }
 }
 
-export type StatusDetailResult = { ok: true; detail: StatusDetail } | { ok: false; error: string };
+export type StatusDetailResult = StatusCheck<OpenCodeStatusExtras>;
 
-/** Fetch full status detail without presenting transport failure as an empty session. */
+/**
+ * Fetch the status for the `/ctx-status` dialog. Every reply, including a
+ * transport failure, comes back as a checked result: either a snapshot the
+ * view model can draw, or the reason there is none. The dialog never receives
+ * an unchecked payload.
+ */
 export async function loadStatusDetail(
     sessionId: string,
     directory: string,
     modelKey?: string,
 ): Promise<StatusDetailResult> {
-    if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
+    if (!rpcClient) return statusRpcFailure("RPC client is not initialized");
     try {
-        const result = await rpcClient.call<StatusDetail>("status-detail", {
+        const reply = await callSessionRpc<unknown>(directory, sessionId, "status-detail", {
             sessionId,
             directory,
             modelKey,
         });
-        const error = (result as unknown as Record<string, unknown>).error;
-        if (typeof error === "string") return { ok: false, error };
-        return { ok: true, detail: result };
+        return checkStatusDetailPayload(reply, pluginPackageVersion() ?? "unknown");
     } catch (error) {
-        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        return statusRpcFailure(error instanceof Error ? error.message : String(error));
     }
 }
 
@@ -199,7 +354,7 @@ const EMPTY_EMBED_DETAIL: EmbedDetail = {
 export async function loadEmbedDetail(sessionId: string, directory: string): Promise<EmbedDetail> {
     if (!rpcClient) return EMPTY_EMBED_DETAIL;
     try {
-        const result = await rpcClient.call<EmbedDetail>("embed-detail", {
+        const result = await callSessionRpc<EmbedDetail>(directory, sessionId, "embed-detail", {
             sessionId,
             directory,
         });
@@ -221,9 +376,14 @@ export async function getCompartmentCount(
 ): Promise<CompartmentCountResult> {
     if (!rpcClient) return { ok: false, error: "RPC client is not initialized" };
     try {
-        const result = await rpcClient.call<{ count?: number; error?: string }>(
+        const result = await callSessionRpc<{ count?: number; error?: string }>(
+            directory ?? "",
+            sessionId,
             "compartment-count",
-            { sessionId, directory },
+            {
+                sessionId,
+                directory,
+            },
         );
         if (typeof result.error === "string") return { ok: false, error: result.error };
         if (typeof result.count !== "number" || !Number.isFinite(result.count)) {
@@ -235,11 +395,17 @@ export async function getCompartmentCount(
     }
 }
 
-/** Send recomp request to server via RPC. */
-export async function requestRecomp(sessionId: string): Promise<boolean> {
+/**
+ * Send recomp request to server via RPC. `directory` is the session's
+ * directory, so the request reaches the server instance that owns the session
+ * (the same one the recomp dialog read its compartment count from).
+ */
+export async function requestRecomp(sessionId: string, directory?: string): Promise<boolean> {
     if (!rpcClient) return false;
     try {
-        const result = await rpcClient.call<{ ok: boolean }>("recomp", { sessionId });
+        const result = await callSessionRpc<{ ok: boolean }>(directory ?? "", sessionId, "recomp", {
+            sessionId,
+        });
         return result.ok ?? false;
     } catch {
         return false;

package/src/tui-compiled/data/notification-socket.ts

@@ -18,7 +18,11 @@
  * unlike the old poll it does no network work at idle.
  */
 
-import { getRpcClient, getRpcGeneration } from "./context-db";
+import {
+    getRpcGeneration,
+    notificationDirectoryFor,
+    resolveNotificationTarget,
+} from "./context-db";
 
 export interface SocketNotification {
     id: number;
@@ -30,6 +34,12 @@ export interface SocketNotification {
 interface NotificationSocketOptions {
     /** Current active session id (re-read cheaply to follow session switches). */
     getSessionId: () => string | null;
+    /**
+     * Directory of the active session, when the host reports it. The socket
+     * subscribes to that directory's server, because that is the server whose
+     * commands push this session's notifications; null means the startup one.
+     */
+    getSessionDirectory?: () => string | null;
     /** Handle one delivered notification. Returns true only after it is fully
      *  consumed and can be acknowledged. Async because dialog handlers await. */
     onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
@@ -47,6 +57,13 @@ let sessionWatchTimer: ReturnType<typeof setInterval> | undefined;
 let reconnectAttempt = 0;
 let closed = false;
 let helloedSession: string | null = null;
+/** Directory whose server the open socket is subscribed to. */
+let connectedDirectory: string | null = null;
+/** Last time the socket was moved to follow a session's directory. */
+let lastRetargetAt = 0;
+/** Minimum spacing between moves, so a session whose server is not up yet does
+ *  not reconnect the socket every watcher tick. */
+const RETARGET_MIN_INTERVAL_MS = 10_000;
 let opts: NotificationSocketOptions | null = null;
 let activeToken: string | null = null;
 /** Generation of the rpc client used by the active socket. */
@@ -110,6 +127,8 @@ export function stopNotificationSocket(): void {
     opts = null;
     activeToken = null;
     helloedSession = null;
+    connectedDirectory = null;
+    lastRetargetAt = 0;
     reconnectAttempt = 0;
     activeInstanceId = null;
     notificationProtocolMode = null;
@@ -136,24 +155,22 @@ function scheduleReconnect(): void {
 async function connect(): Promise<void> {
     if (closed || socket || inFlightAttemptId !== null) return;
 
-    const client = getRpcClient();
-    if (!client) {
-        scheduleReconnect();
-        return;
-    }
-
     const attemptId = ++nextAttemptId;
     const rpcGeneration = getRpcGeneration();
     inFlightAttemptId = attemptId;
-    const endpoint = await client.resolveEndpoint();
+    const target = await resolveNotificationTarget(
+        opts?.getSessionDirectory?.() ?? null,
+        opts?.getSessionId() ?? null,
+    );
     if (closed || inFlightAttemptId !== attemptId || getRpcGeneration() !== rpcGeneration) {
         return;
     }
     inFlightAttemptId = null;
-    if (!endpoint) {
+    if (!target) {
         scheduleReconnect();
         return;
     }
+    const { client, endpoint } = target;
 
     let ws: WebSocket;
     try {
@@ -171,6 +188,7 @@ async function connect(): Promise<void> {
         return;
     }
     connectGeneration = rpcGeneration;
+    connectedDirectory = target.directory;
     activeToken = endpoint.token;
     notificationProtocolMode = null;
     bufferedNotifications.length = 0;
@@ -457,6 +475,26 @@ export function _resetNotificationSocketStateForTesting(): void {
  *  actually changes. Reads a property; no network at idle. */
 function watchSession(): void {
     if (closed || !socket || socket.readyState !== WebSocket.OPEN) return;
+    // The shown session belongs to another directory's server: move the socket
+    // there, or that server's pushes for this session never reach this TUI.
+    const wanted = notificationDirectoryFor(opts?.getSessionDirectory?.() ?? null);
+    if (wanted !== connectedDirectory && Date.now() - lastRetargetAt >= RETARGET_MIN_INTERVAL_MS) {
+        lastRetargetAt = Date.now();
+        const previous = socket;
+        socket = null;
+        activeToken = null;
+        helloedSession = null;
+        connectedDirectory = null;
+        notificationProtocolMode = null;
+        bufferedNotifications.length = 0;
+        try {
+            previous.close();
+        } catch {
+            // best-effort
+        }
+        void connect();
+        return;
+    }
     const current = opts?.getSessionId() ?? null;
     if (current === helloedSession) return;
     // Re-hello with the token authenticated by this socket; no rediscovery or

package/src/tui-compiled/data/session-directory.ts

@@ -0,0 +1,19 @@
+/**
+ * The directory whose Magic Context server owns a session.
+ *
+ * OpenCode starts one Magic Context server instance per directory. The TUI
+ * starts in one directory but can show a session from another one (non-git
+ * directories share OpenCode's global project, so a TUI started in the home
+ * directory lists sessions from any of them). The sidebar and `/ctx-status`
+ * must ask the server for the session's directory, not the startup one.
+ *
+ * `sessionDirectory` is what the host reports for the session (OpenCode 1:
+ * `api.state.session.get(id).directory`; OpenCode 2:
+ * `context.data.session.get(id).location.directory`). The startup directory is
+ * the fallback while the host has not loaded the session yet.
+ */
+export function directoryForSession(sessionDirectory: unknown, startupDirectory: string): string {
+    return typeof sessionDirectory === "string" && sessionDirectory.length > 0
+        ? sessionDirectory
+        : startupDirectory;
+}

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

@@ -22,8 +22,7 @@ import { createElement as _$createElement } from "opentui:runtime-module:%40open
  */
 import { createMemo, createSignal, onCleanup } from "opentui:runtime-module:solid-js";
 import packageJson from "../../../package.json";
-import { statusSummaryFromDetail } from "../../shared/status-summary";
-import { buildStatusView, distributeBarWidths, statusColumnsFor } from "../../shared/status-view";
+import { buildStatusViewFor, distributeBarWidths, statusColumnsFor } from "../../shared/status-view";
 import { RUST_MODE_HOST_PATHS_LINE } from "../../shared/rust-mode-status";
 const R = props => (() => {
   var _el$ = _$createElement("box"),
@@ -65,10 +64,13 @@ function toneColor(theme, tone) {
 
 /**
  * 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
@@ -132,26 +134,27 @@ const StatusSectionView = props => (() => {
   _$effect(_$p => _$setProp(_el$9, "fg", props.t.text, _$p));
   return _el$8;
 })();
+
+/**
+ * `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 => {
   const theme = createMemo(() => props.api.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.
-  const view = createMemo(() => buildStatusView({
-    ...s(),
-    contextLimit: contextLimit(),
-    warnings: statusSummaryFromDetail(s()).warnings
-  }, {
+  // 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(() => buildStatusViewFor(props.status, {
     version: packageJson.version
   }));
   // The dialog's own laid-out width, which is what the sections have to fit
@@ -163,8 +166,8 @@ export const StatusDialog = props => {
       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();
@@ -307,9 +310,9 @@ export const StatusDialog = props => {
       });
     })(), null);
     _$insert(_el$1, (() => {
-      var _c$3 = _$memo(() => !!(!compactionOff() && s().recompProgress));
+      var _c$3 = _$memo(() => !!(!compactionOff() && recompProgress()));
       return () => _c$3() && (() => {
-        const p = s().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";
@@ -429,7 +432,7 @@ export const StatusDialog = props => {
       })();
     })(), _el$20);
     _$insert(_el$1, (() => {
-      var _c$4 = _$memo(() => !!s().hostBackendsModuleSide);
+      var _c$4 = _$memo(() => !!hostBackendsModuleSide());
       return () => _c$4() && (() => {
         var _el$30 = _$createElement("box"),
           _el$31 = _$createElement("text"),
@@ -468,7 +471,10 @@ export const StatusDialog = props => {
         _$setProp(_el$35, "width", "100%");
         _$setProp(_el$35, "gap", 4);
         _$setProp(_el$36, "flexDirection", "column");
-        _$setProp(_el$36, "flexShrink", 0);
+        _$setProp(_el$36, "flexGrow", 0);
+        _$setProp(_el$36, "flexShrink", 1);
+        _$setProp(_el$36, "minWidth", 0);
+        _$setProp(_el$36, "overflow", "hidden");
         _$insert(_el$36, () => columnSections(0).map(section => _$createComponent(StatusSectionView, {
           get t() {
             return t();
@@ -476,7 +482,10 @@ export const StatusDialog = props => {
           section: section
         })));
         _$setProp(_el$37, "flexDirection", "column");
-        _$setProp(_el$37, "flexShrink", 0);
+        _$setProp(_el$37, "flexGrow", 0);
+        _$setProp(_el$37, "flexShrink", 1);
+        _$setProp(_el$37, "minWidth", 0);
+        _$setProp(_el$37, "overflow", "hidden");
         _$insert(_el$37, () => columnSections(1).map(section => _$createComponent(StatusSectionView, {
           get t() {
             return t();
@@ -486,8 +495,8 @@ export const StatusDialog = props => {
         _$effect(_p$ => {
           var _v$14 = columns().leftWidth,
             _v$15 = columns().rightWidth;
-          _v$14 !== _p$.e && (_p$.e = _$setProp(_el$36, "width", _v$14, _p$.e));
-          _v$15 !== _p$.t && (_p$.t = _$setProp(_el$37, "width", _v$15, _p$.t));
+          _v$14 !== _p$.e && (_p$.e = _$setProp(_el$36, "flexBasis", _v$14, _p$.e));
+          _v$15 !== _p$.t && (_p$.t = _$setProp(_el$37, "flexBasis", _v$15, _p$.t));
           return _p$;
         }, {
           e: undefined,

package/src/tui-compiled/index.tsx

@@ -9,9 +9,9 @@ import { createComponent as _$createComponent } from "opentui:runtime-module:%40
 // @ts-nocheck
 import { createMemo } from "opentui:runtime-module:solid-js";
 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 } from "./data/context-db";
+import { directoryForSession } from "./data/session-directory";
 import { startNotificationSocket, stopNotificationSocket } from "./data/notification-socket";
 import { isCompactionEnabled } from "../config/agent-disable";
 import { loadPluginConfig } from "../config";
@@ -106,6 +106,20 @@ function getSessionId(api) {
   }
   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, sessionId) {
+  let reported;
+  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, sessionId) {
   try {
     const msgs = api.state.session.messages(sessionId);
@@ -138,7 +152,7 @@ async function showRecompDialog(api, targetSessionId = getSessionId(api)) {
     });
     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;
@@ -156,7 +170,7 @@ async function showRecompDialog(api, targetSessionId = getSessionId(api)) {
       return [count === 0 ? "This session has no compartments yet — recomp will build them from raw history." : `You have ${count} compartments.`, "", "Recomp will rebuild the compressed history from raw history. Saved memories are not changed.", "This may take a long time and consume significant tokens.", "", "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",
@@ -189,23 +203,17 @@ async function showStatusDialog(api, targetSessionId = getSessionId(api)) {
     });
     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;
-  }
+  // 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(() => _$createComponent(StatusDialog, {
     api: api,
-    get s() {
-      return result.detail;
-    }
+    status: result
   }));
   return true;
 }
@@ -250,7 +258,7 @@ async function showEmbedDialog(api, targetSessionId = getSessionId(api)) {
     });
     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(() => _$createComponent(EmbedDialog, {
@@ -673,6 +681,11 @@ const tui = 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
   });