@wolfx/opencode-magic-context 0.30.1 → 0.30.3

package/dist/shared/rpc-client.d.ts

@@ -9,6 +9,14 @@ export declare class MagicContextRpcClient {
     call<T = Record<string, unknown>>(method: string, params?: Record<string, unknown>): Promise<T>;
     /** Check if the RPC server is reachable. */
     isAvailable(): Promise<boolean>;
+    /** Resolve the live server's port + bearer token (for opening the WS push
+     *  channel). Reuses the same health-checked port-file discovery as `call`,
+     *  so the WS client and the HTTP client always agree on which server instance
+     *  (and token) to use. Returns null when no live server is found. */
+    resolveEndpoint(): Promise<{
+        port: number;
+        token: string | null;
+    } | null>;
     private resolvePort;
     private readPortFile;
     private healthCheck;

package/dist/shared/rpc-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-client.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-client.ts"],"names":[],"mappings":"AAiBA,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,aAAa,CAAS;gBAElB,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,iFAAiF;IAC3E,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,OAAO,CAAC,CAAC,CAAC;IAwDb,4CAA4C;IACtC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;YASvB,WAAW;IAmCzB,OAAO,CAAC,YAAY;YA4BN,WAAW;YAWX,gBAAgB;IAU9B,KAAK,IAAI,IAAI;CAKhB"}
+{"version":3,"file":"rpc-client.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-client.ts"],"names":[],"mappings":"AAiBA,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,aAAa,CAAS;gBAElB,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,iFAAiF;IAC3E,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,OAAO,CAAC,CAAC,CAAC;IAwDb,4CAA4C;IACtC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IASrC;;;yEAGqE;IAC/D,eAAe,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;YAUjE,WAAW;IAmCzB,OAAO,CAAC,YAAY;YA4BN,WAAW;YAWX,gBAAgB;IAU9B,KAAK,IAAI,IAAI;CAKhB"}

package/dist/shared/rpc-notifications.d.ts

@@ -12,16 +12,33 @@ export interface RpcNotification {
     payload: Record<string, unknown>;
     sessionId?: string;
 }
-/** Push a notification for TUI to pick up via polling. */
+/**
+ * A connected TUI notification sink — one per authenticated WebSocket. The RPC
+ * server registers a sink when a TUI socket authenticates (hello) and removes
+ * it on close. `send` is sink-agnostic (the server owns the actual WS socket)
+ * so this module stays free of Bun/WS types.
+ */
+export interface NotificationSink {
+    /** The TUI's active session at connect time (its hello scope). */
+    sessionId?: string;
+    /** Deliver one notification over this sink's live socket. */
+    send: (notification: RpcNotification) => void;
+}
+/** Register a live TUI sink. Returns an unregister fn (call on socket close). */
+export declare function registerNotificationSink(sink: NotificationSink): () => void;
+/** Push a notification to the TUI. Fans out to any live WS sink immediately and
+ *  also enqueues it so a TUI that is momentarily disconnected (reconnecting, or
+ *  not yet connected) still receives it on its next hello via the backlog drain.
+ *  At-least-once: a live push that the socket drops is re-delivered from the
+ *  queue on reconnect (pruned only when the client acks via `lastReceivedId`). */
 export declare function pushNotification(type: string, payload: Record<string, unknown>, sessionId?: string): void;
 /** Return pending notifications after acking the client's last received id.
- *  Updates lastDrainAt so isTuiConnected() reflects recent activity.
  *
  *  Session scoping: when `sessionId` is provided, only notifications tagged for
  *  that session (or session-less/global ones) are returned and pruned — a
  *  notification tagged for a DIFFERENT session is never handed to this client
  *  and is never pruned by this client's ack. This matters because the in-memory
- *  queue is per-process but a TUI can end up draining a process that also serves
+ *  queue is per-process but a TUI can end up bound to a process that also serves
  *  OTHER sessions: e.g. opening OpenCode Desktop on the same project starts a
  *  newer RPC server that the TUI's port discovery (newest-pid-wins) then selects,
  *  so a Desktop-session upgrade-dialog action would otherwise surface in an
@@ -31,16 +48,17 @@ export declare function pushNotification(type: string, payload: Record<string, u
  *
  *  Delivery is at-least-once (non-destructive return + prune-on-ack): a returned
  *  notification stays queued until a later call acks it via a higher
- *  `lastReceivedId`, so a lost poll response re-delivers on the next poll. */
+ *  `lastReceivedId`, so a dropped WS socket re-delivers the backlog on reconnect
+ *  (the client sends its `lastReceivedId` in the hello). */
 export declare function drainNotifications(lastReceivedId?: number, sessionId?: string): RpcNotification[];
-/** Whether a TUI client is actively polling for notifications.
- *  Returns true only if a TUI has drained within the last 3 seconds.
+/** Whether a TUI client is connected via a live notification socket.
+ *  Now exact socket liveness (a registered WS sink), not a poll-drain timestamp.
  *
- *  Pass `sessionId` (preferred) to ask whether a TUI is polling FOR THAT
+ *  Pass `sessionId` (preferred) to ask whether a TUI is connected FOR THAT
  *  SESSION — this is what producers (`/ctx-status`, `/ctx-recomp`, the upgrade
  *  reminder) must use to decide dialog-vs-message, so a TUI on a different
- *  session in the same process does not misroute their delivery. Omit it only
- *  for legacy/global callers that genuinely have no session context; they fall
- *  back to "any session recently drained" (the pre-per-session behavior). */
+ *  session in the same process does not misroute their delivery. A session-less
+ *  sink (legacy/global) counts for any session query. Omit `sessionId` only for
+ *  callers with no session context; they get "any sink connected". */
 export declare function isTuiConnected(sessionId?: string): boolean;
 //# sourceMappingURL=rpc-notifications.d.ts.map

package/dist/shared/rpc-notifications.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-notifications.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-notifications.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAsBD,0DAA0D;AAC1D,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,SAAS,CAAC,EAAE,MAAM,GACnB,IAAI,CAwBN;AAED;;;;;;;;;;;;;;;;;8EAiB8E;AAC9E,wBAAgB,kBAAkB,CAAC,cAAc,SAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE,CAkB5F;AAED;;;;;;;;6EAQ6E;AAC7E,wBAAgB,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAO1D"}
+{"version":3,"file":"rpc-notifications.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-notifications.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC7B,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,IAAI,EAAE,CAAC,YAAY,EAAE,eAAe,KAAK,IAAI,CAAC;CACjD;AAYD,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAK3E;AAcD;;;;kFAIkF;AAClF,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,SAAS,CAAC,EAAE,MAAM,GACnB,IAAI,CAoCN;AAED;;;;;;;;;;;;;;;;;4DAiB4D;AAC5D,wBAAgB,kBAAkB,CAAC,cAAc,SAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE,CAe5F;AAED;;;;;;;;sEAQsE;AACtE,wBAAgB,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAO1D"}

package/dist/shared/rpc-server.d.ts

@@ -1,4 +1,16 @@
 type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+/**
+ * Plugin-private localhost RPC server for TUI ↔ server-plugin communication.
+ *
+ * Runs on Bun (the OpenCode server runner is a Bun Worker), so it uses
+ * `Bun.serve` to host BOTH:
+ *  - HTTP request/reply routes (`/health`, `/rpc/<method>`) — the TUI's snapshot
+ *    and dialog-result calls, which are event-driven, not idle; and
+ *  - a WebSocket endpoint (`/ws`) — a single persistent connection per TUI over
+ *    which the server PUSHES notifications (dialog/toast actions). This replaces
+ *    the old 500ms HTTP poll, whose new-connection-per-tick cost was the source
+ *    of idle TUI CPU (#200). Pi never imports this module, so `Bun.serve` is safe.
+ */
 export declare class MagicContextRpcServer {
     private server;
     private port;
@@ -6,16 +18,23 @@ export declare class MagicContextRpcServer {
     private portFilePath;
     private portDir;
     private startedAt;
+    /** Every authenticated WS socket, so dispose can close them all. */
+    private sockets;
     private readonly token;
     constructor(storageDir: string, directory: string);
     /** Register an RPC method handler. */
     handle(method: string, handler: RpcHandler): void;
     /** Start the server on a random port, write port to disk. */
     start(): Promise<number>;
-    private warnIfOtherLiveInstance;
-    /** Stop the server and clean up port file. */
+    /** Stop the server: close every socket, stop accepting, remove port file. */
     stop(): void;
-    private dispatch;
+    private warnIfOtherLiveInstance;
+    /** HTTP route handler (Bun fetch). Returns a Response, or undefined when the
+     *  request was upgraded to a WebSocket. */
+    private handleFetch;
+    /** WS message handler: hello (auth + sink registration + backlog drain) and
+     *  ack (cursor advance → queue prune). All other messages are ignored. */
+    private handleWsMessage;
 }
 export {};
 //# sourceMappingURL=rpc-server.d.ts.map

package/dist/shared/rpc-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-server.ts"],"names":[],"mappings":"AAgBA,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAexF,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAc;IAK/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;gBAE7C,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,sCAAsC;IACtC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAIjD,6DAA6D;IACvD,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAiF9B,OAAO,CAAC,uBAAuB;IAgB/B,8CAA8C;IAC9C,IAAI,IAAI,IAAI;IAYZ,OAAO,CAAC,QAAQ;CA6EnB"}
+{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/shared/rpc-server.ts"],"names":[],"mappings":"AAqBA,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAiCxF;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAc;IAC/B,oEAAoE;IACpE,OAAO,CAAC,OAAO,CAAsC;IAMrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;gBAE7C,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAKjD,sCAAsC;IACtC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAIjD,6DAA6D;IACvD,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAmF9B,6EAA6E;IAC7E,IAAI,IAAI,IAAI;IAuBZ,OAAO,CAAC,uBAAuB;IAgB/B;+CAC2C;YAC7B,WAAW;IAuDzB;8EAC0E;IAC1E,OAAO,CAAC,eAAe;CA0D1B"}

package/dist/tui/data/context-db.d.ts

@@ -1,8 +1,12 @@
+import { MagicContextRpcClient } from "../../shared/rpc-client";
 import type { EmbedDetail, SidebarSnapshot, StatusDetail } from "../../shared/rpc-types";
 export type { EmbedDetail, SidebarSnapshot, StatusDetail };
 /** Initialize the RPC client. Call once on TUI startup. */
 export declare function initRpcClient(directory: string): void;
 export declare function getRpcGeneration(): number;
+/** The live RPC client (for the WS notification socket's endpoint discovery).
+ *  Null before init / after close. */
+export declare function getRpcClient(): MagicContextRpcClient | null;
 /** Clean up the RPC client. */
 export declare function closeRpc(): void;
 /** Fetch sidebar snapshot from the server via RPC. */
@@ -24,12 +28,6 @@ export declare function requestUpgrade(sessionId: string): Promise<boolean>;
 export declare function dismissUpgradeReminder(sessionId: string): Promise<boolean>;
 /** Resolve global toast duration from server config via RPC. */
 export declare function loadToastDurationMs(): Promise<number>;
-export interface TuiMessage {
-    id: number;
-    type: string;
-    payload: Record<string, unknown>;
-    sessionId?: string;
-}
 /**
  * Fetch the current startup announcement from the server, if any.
  * Returns `{show: false}` when there's nothing to announce or when the
@@ -44,12 +42,4 @@ export interface AnnouncementResponse {
 export declare function getAnnouncement(): Promise<AnnouncementResponse>;
 /** Mark the current ANNOUNCEMENT_VERSION as dismissed on the server. */
 export declare function markAnnounced(): Promise<boolean>;
-/** Poll for pending server→TUI notifications via RPC. */
-export declare function consumeTuiMessages(sessionId: string): Promise<TuiMessage[]>;
-/**
- * Advance the delivered-message cursor for one active TUI session.
- * Callers must pass only the contiguous handled prefix of the drained batch;
- * this helper remains empty-safe and monotonic for that prefix.
- */
-export declare function markTuiMessagesHandled(sessionId: string, messages: TuiMessage[]): void;
 //# sourceMappingURL=context-db.d.ts.map

package/dist/tui/data/context-db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-db.d.ts","sourceRoot":"","sources":["../../../src/tui/data/context-db.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACR,WAAW,EAEX,eAAe,EACf,YAAY,EACf,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC;AAe3D,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAOrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,+BAA+B;AAC/B,wBAAgB,QAAQ,IAAI,IAAI,CAO/B;AA4FD,sDAAsD;AACtD,wBAAsB,mBAAmB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,wDAAwD;AACxD,wBAAsB,gBAAgB,CAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,CAAC,CA0CvB;AAYD,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAchG;AAED,qCAAqC;AACrC,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5E;AAED,6CAA6C;AAC7C,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvE;AAED;mFACmF;AACnF,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQxE;AAED;;iDAEiD;AACjD,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhF;AAED,gEAAgE;AAChE,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQ3D;AAED,MAAM,WAAW,UAAU;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAkBrE;AAED,wEAAwE;AACxE,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAQtD;AAED,yDAAyD;AACzD,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAyBjF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI,CAWtF"}
+{"version":3,"file":"context-db.d.ts","sourceRoot":"","sources":["../../../src/tui/data/context-db.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEzF,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC;AAc3D,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAOrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;sCACsC;AACtC,wBAAgB,YAAY,IAAI,qBAAqB,GAAG,IAAI,CAE3D;AAED,+BAA+B;AAC/B,wBAAgB,QAAQ,IAAI,IAAI,CAM/B;AA4FD,sDAAsD;AACtD,wBAAsB,mBAAmB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,eAAe,CAAC,CA4B1B;AAED,wDAAwD;AACxD,wBAAsB,gBAAgB,CAClC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,YAAY,CAAC,CA0CvB;AAYD,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAchG;AAED,qCAAqC;AACrC,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ5E;AAED,6CAA6C;AAC7C,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvE;AAED;mFACmF;AACnF,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQxE;AAED;;iDAEiD;AACjD,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhF;AAED,gEAAgE;AAChE,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAQ3D;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAkBrE;AAED,wEAAwE;AACxE,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAQtD"}

package/dist/tui/data/notification-socket.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Persistent WebSocket to the server plugin's RPC server, replacing the old
+ * 500ms HTTP notification poll.
+ *
+ * Why this exists: the TUI plugin and the server plugin run in separate Bun
+ * runners in the same process, so they bridge over a localhost socket. The old
+ * bridge polled `pending-notifications` over HTTP every 500ms — and each poll
+ * opened a NEW loopback TCP connection (Bun's fetch isn't pooled to our server),
+ * which was the entire source of idle TUI CPU (#200). A single long-lived WS
+ * carries server→TUI pushes with zero per-event connection cost, and the server
+ * pushes notifications the instant they're queued (no polling latency).
+ *
+ * Session scope: the socket carries the TUI's active session in its `hello` so
+ * the server delivers only that session's (plus global) notifications and its
+ * `isTuiConnected(session)` routing stays correct. The active session is tracked
+ * with a cheap watcher that only reads `api.route.current` (a property access,
+ * no IPC) and re-scopes the socket ONLY when the session actually changes — so
+ * unlike the old poll it does no network work at idle.
+ */
+export interface SocketNotification {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}
+interface NotificationSocketOptions {
+    /** Current active session id (re-read cheaply to follow session switches). */
+    getSessionId: () => string | null;
+    /** Handle one delivered notification. Returns true if it was consumed (so its
+     *  id can advance the ack cursor). Async because dialog handlers await. */
+    onNotification: (notification: SocketNotification) => boolean | Promise<boolean>;
+}
+/** Open the persistent notification socket. Idempotent: a second call while open
+ *  is a no-op. Reconnects on its own after any drop. */
+export declare function startNotificationSocket(options: NotificationSocketOptions): void;
+/** Close the socket and stop reconnecting. Call on TUI dispose. */
+export declare function stopNotificationSocket(): void;
+export {};
+//# sourceMappingURL=notification-socket.d.ts.map

package/dist/tui/data/notification-socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-socket.d.ts","sourceRoot":"","sources":["../../../src/tui/data/notification-socket.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,yBAAyB;IAC/B,8EAA8E;IAC9E,YAAY,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC;+EAC2E;IAC3E,cAAc,EAAE,CAAC,YAAY,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF;AAsBD;wDACwD;AACxD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI,CAQhF;AAED,mEAAmE;AACnE,wBAAgB,sBAAsB,IAAI,IAAI,CAkB7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wolfx/opencode-magic-context",
-  "version": "0.30.1",
+  "version": "0.30.3",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -29,7 +29,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --external @opencode-ai/plugin --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external @opencode-ai/plugin --external @huggingface/transformers --external onnxruntime-web --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.scripts.json",
     "test": "bun test",
     "lint": "biome check .",

package/src/shared/announcement.ts

@@ -37,14 +37,14 @@ import { getMagicContextStorageDir } from "./data-path";
  * Bump only when there are user-visible changes worth a startup dialog.
  * Does NOT need to match the published package version.
  */
-export const ANNOUNCEMENT_VERSION = "0.30.1";
+export const ANNOUNCEMENT_VERSION = "0.30.2";
 
 /**
  * Short, user-facing bullet strings. Keep each line ~80 chars or shorter so the
  * TUI dialog renders cleanly without horizontal scroll on a typical terminal.
  */
 export const ANNOUNCEMENT_FEATURES: ReadonlyArray<string> = [
-    "Local embeddings work on OpenCode Desktop again (#195): /ctx-embed no longer fails with 'Unsupported device: cpu' on the Desktop app.",
+    "Fixed high idle CPU from the TUI sidebar (#200): it now uses a single persistent connection to the plugin instead of polling, so an idle session no longer burns CPU.",
 ];
 
 /**

package/src/shared/data-path.test.ts

@@ -7,6 +7,7 @@ import {
     getCacheDir,
     getDataDir,
     getLegacyOpenCodeMagicContextStorageDir,
+    getMagicContextLogPath,
     getMagicContextStorageDir,
     getOpenCodeCacheDir,
     getOpenCodeStorageDir,
@@ -18,6 +19,7 @@ const savedEnv = {
     XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
     XDG_DATA_HOME: process.env.XDG_DATA_HOME,
     LOCALAPPDATA: process.env.LOCALAPPDATA,
+    MAGIC_CONTEXT_LOG_PATH: process.env.MAGIC_CONTEXT_LOG_PATH,
 };
 
 describe("data-path", () => {
@@ -25,10 +27,12 @@ describe("data-path", () => {
         process.env.XDG_CACHE_HOME = undefined;
         process.env.XDG_DATA_HOME = undefined;
         process.env.LOCALAPPDATA = undefined;
+        process.env.MAGIC_CONTEXT_LOG_PATH = undefined;
         // Bun's env handling: explicit delete for unset
         delete process.env.XDG_CACHE_HOME;
         delete process.env.XDG_DATA_HOME;
         delete process.env.LOCALAPPDATA;
+        delete process.env.MAGIC_CONTEXT_LOG_PATH;
     });
 
     afterEach(() => {
@@ -37,6 +41,9 @@ describe("data-path", () => {
         if (savedEnv.XDG_DATA_HOME !== undefined)
             process.env.XDG_DATA_HOME = savedEnv.XDG_DATA_HOME;
         if (savedEnv.LOCALAPPDATA !== undefined) process.env.LOCALAPPDATA = savedEnv.LOCALAPPDATA;
+        if (savedEnv.MAGIC_CONTEXT_LOG_PATH !== undefined)
+            process.env.MAGIC_CONTEXT_LOG_PATH = savedEnv.MAGIC_CONTEXT_LOG_PATH;
+        else delete process.env.MAGIC_CONTEXT_LOG_PATH;
     });
 
     test("getCacheDir falls back to <homedir>/.cache when XDG_CACHE_HOME is unset (all platforms)", () => {
@@ -158,6 +165,27 @@ describe("data-path", () => {
             path.join("/some/project/", ".cortexkit", "magic-context"),
         );
     });
+
+    test("getMagicContextLogPath falls back to the harness temp dir when the env override is unset", () => {
+        expect(getMagicContextLogPath("opencode")).toBe(
+            path.join(os.tmpdir(), "opencode", "magic-context", "magic-context.log"),
+        );
+        expect(getMagicContextLogPath("pi")).toBe(
+            path.join(os.tmpdir(), "pi", "magic-context", "magic-context.log"),
+        );
+    });
+
+    test("getMagicContextLogPath honors MAGIC_CONTEXT_LOG_PATH", () => {
+        process.env.MAGIC_CONTEXT_LOG_PATH = "/tmp/custom/magic-context.log";
+        expect(getMagicContextLogPath("pi")).toBe("/tmp/custom/magic-context.log");
+    });
+
+    test("getMagicContextLogPath ignores a blank MAGIC_CONTEXT_LOG_PATH", () => {
+        process.env.MAGIC_CONTEXT_LOG_PATH = "   ";
+        expect(getMagicContextLogPath("pi")).toBe(
+            path.join(os.tmpdir(), "pi", "magic-context", "magic-context.log"),
+        );
+    });
 });
 
 describe("ensureCortexKitArtifactGitignore", () => {

package/src/shared/data-path.ts

@@ -46,6 +46,11 @@ export function getMagicContextTempDir(harness: HarnessId = getHarness()): strin
  * reflected in the next flush.
  */
 export function getMagicContextLogPath(harness: HarnessId = getHarness()): string {
+    // An explicit override wins over the harness temp-dir default, so users on
+    // sandboxed/ephemeral setups (Docker, CI) can point the diagnostic log at a
+    // persistent or shared path. Blank/whitespace is treated as unset.
+    const envPath = process.env.MAGIC_CONTEXT_LOG_PATH?.trim();
+    if (envPath) return envPath;
     return path.join(getMagicContextTempDir(harness), "magic-context.log");
 }
 

package/src/shared/rpc-client.ts

@@ -97,6 +97,20 @@ export class MagicContextRpcClient {
         }
     }
 
+    /** Resolve the live server's port + bearer token (for opening the WS push
+     *  channel). Reuses the same health-checked port-file discovery as `call`,
+     *  so the WS client and the HTTP client always agree on which server instance
+     *  (and token) to use. Returns null when no live server is found. */
+    async resolveEndpoint(): Promise<{ port: number; token: string | null } | null> {
+        try {
+            const port = await this.resolvePort();
+            if (port === null) return null;
+            return { port, token: this.token };
+        } catch {
+            return null;
+        }
+    }
+
     private async resolvePort(): Promise<number | null> {
         if (this.port && this.healthChecked) {
             return this.port;

package/src/shared/rpc-notifications.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { drainNotifications, isTuiConnected, pushNotification } from "./rpc-notifications";
+import {
+    drainNotifications,
+    isTuiConnected,
+    type NotificationSink,
+    pushNotification,
+    registerNotificationSink,
+} from "./rpc-notifications";
 
 describe("rpc notifications", () => {
     test("keeps messages queued until the client acks their id", () => {
@@ -45,17 +51,68 @@ describe("rpc notifications", () => {
         expect(poll.map((m) => m.type).sort()).toEqual(["x", "y"]);
     });
 
-    test("isTuiConnected is per-session: a TUI on session A does not mark session B connected", () => {
-        // A TUI draining for tuiA must not make tuiB's producers think a TUI is
-        // polling for tuiB (which would route tuiB's /ctx-status, upgrade
-        // reminder, etc. to the dialog path and lose them in the unrelated TUI).
-        // Use ids no other test drains so the per-session window is unambiguous.
-        drainNotifications(0, "ses_tuiA_only");
-        expect(isTuiConnected("ses_tuiA_only")).toBe(true);
-        expect(isTuiConnected("ses_tuiB_never_drained")).toBe(false);
-        // The session-less (global) query still reports recent activity for the
-        // legacy callers that have no session context.
+    test("isTuiConnected reflects live WS sinks per-session", () => {
+        // No sinks → nothing connected.
+        expect(isTuiConnected("ses_anything")).toBe(false);
+        expect(isTuiConnected()).toBe(false);
+
+        // A live sink scoped to session A marks ONLY A connected (so B's producers
+        // don't misroute B's /ctx-status / upgrade reminder to the dialog path and
+        // lose it in an unrelated TUI), and the global query is also "connected".
+        const unregister = registerNotificationSink({ sessionId: "ses_A", send: () => {} });
+        expect(isTuiConnected("ses_A")).toBe(true);
+        expect(isTuiConnected("ses_B")).toBe(false);
         expect(isTuiConnected()).toBe(true);
+
+        // Closing the socket removes the sink → disconnected again.
+        unregister();
+        expect(isTuiConnected("ses_A")).toBe(false);
+        expect(isTuiConnected()).toBe(false);
+    });
+
+    test("a session-less sink counts as connected for any session query", () => {
+        const unregister = registerNotificationSink({ sessionId: undefined, send: () => {} });
+        expect(isTuiConnected("ses_whatever")).toBe(true);
+        expect(isTuiConnected()).toBe(true);
+        unregister();
+    });
+
+    test("pushNotification fans out live to a matching sink and skips a foreign session", () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const received: string[] = [];
+        const sink: NotificationSink = {
+            sessionId: "ses_live",
+            send: (n) => received.push(n.type),
+        };
+        const unregister = registerNotificationSink(sink);
+
+        pushNotification("for-live", { action: "show-status-dialog" }, "ses_live");
+        pushNotification("for-other", { action: "show-status-dialog" }, "ses_other");
+        pushNotification("global", { action: "show-status-dialog" });
+
+        // The sink sees its own session + global, never the foreign session.
+        expect(received.sort()).toEqual(["for-live", "global"]);
+        unregister();
+    });
+
+    test("a dead sink (throwing send) does not block delivery to other sinks", () => {
+        drainNotifications(Number.MAX_SAFE_INTEGER);
+        const live: string[] = [];
+        const unregDead = registerNotificationSink({
+            sessionId: undefined,
+            send: () => {
+                throw new Error("socket dead");
+            },
+        });
+        const unregLive = registerNotificationSink({
+            sessionId: undefined,
+            send: (n) => live.push(n.type),
+        });
+        // Must not throw, and the live sink still receives it.
+        expect(() => pushNotification("resilient", { ok: true })).not.toThrow();
+        expect(live).toEqual(["resilient"]);
+        unregDead();
+        unregLive();
     });
 
     test("queue-cap eviction is session-fair: a noisy session cannot evict another session's newest unseen item", () => {

package/src/shared/rpc-notifications.ts

@@ -16,31 +16,73 @@ export interface RpcNotification {
 
 let queue: RpcNotification[] = [];
 let nextNotificationId = 1;
-// Timestamp of last drain — used to detect if a TUI is actively polling.
-// The TUI polls every 500ms; we consider it connected if it polled within
-// the last 3 seconds (6× the poll interval, tolerates transient delays).
-//
-// PER-SESSION: a single server process can serve MANY sessions (e.g. a TUI on
-// session A plus an OpenCode Desktop opened on session B for the same project,
-// whose newer RPC server this TUI's port discovery then selects). The TUI
-// poller drains with ITS active session id, so a session is "TUI-connected"
-// only if a TUI recently drained FOR THAT session. A process-global timestamp
-// would make session B's producers (`/ctx-status`, upgrade reminder) take the
-// TUI-dialog path because session A's TUI is polling — queuing a B-scoped
-// dialog action that A's poller correctly refuses to show, so B's notice is
-// lost (it also suppressed B's non-TUI fallback). Tracking drains per session
-// routes each producer to the right delivery path.
-const lastDrainAtBySession = new Map<string, number>();
-let lastDrainAtAny = 0;
-const TUI_CONNECTED_WINDOW_MS = 3_000;
 
-/** Push a notification for TUI to pick up via polling. */
+/**
+ * A connected TUI notification sink — one per authenticated WebSocket. The RPC
+ * server registers a sink when a TUI socket authenticates (hello) and removes
+ * it on close. `send` is sink-agnostic (the server owns the actual WS socket)
+ * so this module stays free of Bun/WS types.
+ */
+export interface NotificationSink {
+    /** The TUI's active session at connect time (its hello scope). */
+    sessionId?: string;
+    /** Deliver one notification over this sink's live socket. */
+    send: (notification: RpcNotification) => void;
+}
+
+// Live sinks replace the old poll-drain-timestamp inference. "TUI connected for
+// a session" is now exact socket liveness — accurate and immediate — instead of
+// "did a 500ms poll drain within the last 3s". Per-session scoping still matters:
+// one process can serve MANY sessions (a TUI on session A plus an OpenCode
+// Desktop opened on session B for the same project, whose newer RPC server this
+// TUI's port discovery then selects). Each sink carries ITS session, so a
+// B-scoped producer (`/ctx-status`, upgrade reminder) only sees B's TUI as
+// connected and routes its dialog there, never to A.
+const sinks = new Set<NotificationSink>();
+
+/** Register a live TUI sink. Returns an unregister fn (call on socket close). */
+export function registerNotificationSink(sink: NotificationSink): () => void {
+    sinks.add(sink);
+    return () => {
+        sinks.delete(sink);
+    };
+}
+
+/** Whether a given notification may be delivered to a given sink. A global
+ *  notification (no sessionId) reaches every sink; a session-scoped one reaches
+ *  only sinks for that session (or session-less sinks). Mirrors the drain filter
+ *  from the sink's perspective. */
+function notificationMatchesSink(notification: RpcNotification, sink: NotificationSink): boolean {
+    return (
+        notification.sessionId === undefined ||
+        sink.sessionId === undefined ||
+        notification.sessionId === sink.sessionId
+    );
+}
+
+/** Push a notification to the TUI. Fans out to any live WS sink immediately and
+ *  also enqueues it so a TUI that is momentarily disconnected (reconnecting, or
+ *  not yet connected) still receives it on its next hello via the backlog drain.
+ *  At-least-once: a live push that the socket drops is re-delivered from the
+ *  queue on reconnect (pruned only when the client acks via `lastReceivedId`). */
 export function pushNotification(
     type: string,
     payload: Record<string, unknown>,
     sessionId?: string,
 ): void {
-    queue.push({ id: nextNotificationId++, type, payload, sessionId });
+    const notification: RpcNotification = { id: nextNotificationId++, type, payload, sessionId };
+    queue.push(notification);
+    // Fan out to every live sink this notification is scoped to. A delivery throw
+    // (dead socket mid-send) must not block other sinks or the caller.
+    for (const sink of sinks) {
+        if (!notificationMatchesSink(notification, sink)) continue;
+        try {
+            sink.send(notification);
+        } catch {
+            // Socket died between liveness check and send; the close handler will
+            // unregister it, and the queue backlog re-delivers on reconnect.
+        }
+    }
     // Cap queue size to prevent unbounded growth if a TUI is not draining.
     // Session-FAIR eviction: a naive `slice(-50)` drops the globally-oldest
     // items, so a noisy session could evict ANOTHER session's single unseen
@@ -66,13 +108,12 @@ export function pushNotification(
 }
 
 /** Return pending notifications after acking the client's last received id.
- *  Updates lastDrainAt so isTuiConnected() reflects recent activity.
  *
  *  Session scoping: when `sessionId` is provided, only notifications tagged for
  *  that session (or session-less/global ones) are returned and pruned — a
  *  notification tagged for a DIFFERENT session is never handed to this client
  *  and is never pruned by this client's ack. This matters because the in-memory
- *  queue is per-process but a TUI can end up draining a process that also serves
+ *  queue is per-process but a TUI can end up bound to a process that also serves
  *  OTHER sessions: e.g. opening OpenCode Desktop on the same project starts a
  *  newer RPC server that the TUI's port discovery (newest-pid-wins) then selects,
  *  so a Desktop-session upgrade-dialog action would otherwise surface in an
@@ -82,11 +123,9 @@ export function pushNotification(
  *
  *  Delivery is at-least-once (non-destructive return + prune-on-ack): a returned
  *  notification stays queued until a later call acks it via a higher
- *  `lastReceivedId`, so a lost poll response re-delivers on the next poll. */
+ *  `lastReceivedId`, so a dropped WS socket re-delivers the backlog on reconnect
+ *  (the client sends its `lastReceivedId` in the hello). */
 export function drainNotifications(lastReceivedId = 0, sessionId?: string): RpcNotification[] {
-    const now = Date.now();
-    lastDrainAtAny = now;
-    if (sessionId !== undefined) lastDrainAtBySession.set(sessionId, now);
     const matchesClient = (notification: RpcNotification): boolean =>
         sessionId === undefined ||
         notification.sessionId === undefined ||
@@ -103,20 +142,20 @@ export function drainNotifications(lastReceivedId = 0, sessionId?: string): RpcN
     );
 }
 
-/** Whether a TUI client is actively polling for notifications.
- *  Returns true only if a TUI has drained within the last 3 seconds.
+/** Whether a TUI client is connected via a live notification socket.
+ *  Now exact socket liveness (a registered WS sink), not a poll-drain timestamp.
  *
- *  Pass `sessionId` (preferred) to ask whether a TUI is polling FOR THAT
+ *  Pass `sessionId` (preferred) to ask whether a TUI is connected FOR THAT
  *  SESSION — this is what producers (`/ctx-status`, `/ctx-recomp`, the upgrade
  *  reminder) must use to decide dialog-vs-message, so a TUI on a different
- *  session in the same process does not misroute their delivery. Omit it only
- *  for legacy/global callers that genuinely have no session context; they fall
- *  back to "any session recently drained" (the pre-per-session behavior). */
+ *  session in the same process does not misroute their delivery. A session-less
+ *  sink (legacy/global) counts for any session query. Omit `sessionId` only for
+ *  callers with no session context; they get "any sink connected". */
 export function isTuiConnected(sessionId?: string): boolean {
-    const now = Date.now();
-    if (sessionId !== undefined) {
-        const at = lastDrainAtBySession.get(sessionId) ?? 0;
-        return at > 0 && now - at < TUI_CONNECTED_WINDOW_MS;
+    if (sinks.size === 0) return false;
+    if (sessionId === undefined) return true;
+    for (const sink of sinks) {
+        if (sink.sessionId === undefined || sink.sessionId === sessionId) return true;
     }
-    return lastDrainAtAny > 0 && now - lastDrainAtAny < TUI_CONNECTED_WINDOW_MS;
+    return false;
 }