tmux-ide 2.9.14 → 2.9.16

package/packages/daemon/dist/lib/tmux-native-browser.js

@@ -0,0 +1,80 @@
+import { PaneEditorContextTargetSchemaZ, NativeBrowserCommandSchemaZ } from "@tmux-ide/contracts";
+import { z } from "zod";
+import { decodeTmuxArgument } from "../terminal/protocol/session-descriptor-discovery.js";
+import { NativeBrowserEndpointSchema, NativeBrowserUnavailable, nativeBrowserRpc, } from "./native-browser-rpc.js";
+export const NativeBrowserRequestSchema = z
+    .object({
+    target: PaneEditorContextTargetSchemaZ,
+    command: NativeBrowserCommandSchemaZ.nullable(),
+})
+    .strict();
+export function createNativeBrowserResolver(options) {
+    let readers = 0;
+    return async (input, cancellation) => {
+        const { target, command } = NativeBrowserRequestSchema.parse(input);
+        const signal = AbortSignal.any([cancellation, AbortSignal.timeout(2500)]);
+        const workspace = options.registry.get(target.workspaceName);
+        const assertCurrent = () => {
+            options.assertOpen();
+            signal.throwIfAborted();
+            if (target.generation !== options.generation ||
+                !workspace ||
+                options.registry.get(target.workspaceName) !== workspace)
+                throw new NativeBrowserUnavailable();
+        };
+        assertCurrent();
+        if (readers >= 8)
+            throw new NativeBrowserUnavailable();
+        readers++;
+        try {
+            const sessions = await options.catalog();
+            assertCurrent();
+            const matching = sessions.filter((s) => s.liveSessionId === target.liveSessionId);
+            if (matching.length !== 1 || matching[0].sessionName !== workspace.sessionName)
+                throw new NativeBrowserUnavailable();
+            const snapshot = await options.inventory.discoverTerminalInventory(signal);
+            assertCurrent();
+            if (snapshot.catalog.invalidRuntimeProof ||
+                snapshot.catalog.duplicateSemanticStamp ||
+                snapshot.catalog.duplicateRuntimePaneBinding)
+                throw new NativeBrowserUnavailable();
+            const matches = snapshot.panes.filter((p) => p.workspaceName === target.workspaceName &&
+                p.semanticPaneId === target.semanticPaneId &&
+                p.sessionName === workspace.sessionName);
+            if (matches.length !== 1)
+                throw new NativeBrowserUnavailable();
+            const pane = { ...matches[0] };
+            if (!pane.nativePaneBirthId || !/^%[0-9]+$/u.test(pane.runtimePaneId))
+                throw new NativeBrowserUnavailable();
+            const observe = async () => {
+                const raw = await options.run([
+                    "display-message",
+                    "-p",
+                    "-t",
+                    pane.runtimePaneId,
+                    "#{qa:@tmux_ide_pane_id}\t#{qa:pane_birth_id}\t#{qa:@tmux_ide_browser_control}",
+                ], signal);
+                assertCurrent();
+                if (raw.length > 8192)
+                    throw new NativeBrowserUnavailable();
+                const [semantic, birth, endpoint] = raw.trimEnd().split("\t").map(decodeTmuxArgument);
+                if (semantic !== target.semanticPaneId || birth !== pane.nativePaneBirthId)
+                    throw new NativeBrowserUnavailable();
+                const parsed = NativeBrowserEndpointSchema.parse(JSON.parse(endpoint ?? "null"));
+                if (parsed.pane !== pane.runtimePaneId)
+                    throw new NativeBrowserUnavailable();
+                return parsed;
+            };
+            const endpoint = await observe();
+            const result = await nativeBrowserRpc(endpoint, command, signal);
+            assertCurrent();
+            const current = await observe();
+            if (JSON.stringify(current) !== JSON.stringify(endpoint))
+                throw new NativeBrowserUnavailable();
+            return result;
+        }
+        finally {
+            readers--;
+        }
+    };
+}

package/packages/daemon/dist/lib/tmux-server-owner.js

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.js";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.js";
 import { shellEscape } from "./shell.js";
 import { createNativeSplitCapabilityProbe, createNativeSplitReadiness, } from "./native-split-capability.js";
@@ -68,7 +69,8 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
                 "list-panes",
                 "-a",
                 "-F",
-                "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{session_path}",
+                // session_path stays last: tmux rejects tabs in session names but not in paths.
+                "#{pid}\t#{session_id}\t#{session_created}\t#{session_name}\t#{pane_id}\t#{window_id}\t#{session_activity}\t#{session_path}",
             ]
                 .map(shellEscape)
                 .join(" "),
@@ -79,7 +81,8 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
         // Command errors, unsupported formats and unwitnessed blank output stay failures.
         const lines = raw.trim() === "tmux-ide-empty-catalog-v1" ? [] : raw.trim().split("\n");
         for (const line of lines) {
-            const [pid, id, created, name, pane, dir] = line.split("\t");
+            const [pid, id, created, name, pane, window, activity, ...pathParts] = line.split("\t");
+            const dir = pathParts.join("\t");
             if (!pid ||
                 !/^\d+$/.test(pid) ||
                 !id ||
@@ -89,6 +92,8 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
                 !name ||
                 !pane ||
                 !/^%\d+$/.test(pane) ||
+                !window ||
+                !/^@\d+$/.test(window) ||
                 !dir)
                 throw new Error("Invalid native server catalog");
             if (!isVisibleFleetSession(name))
@@ -97,9 +102,12 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
             const row = rows.get(liveSessionId) ?? {
                 summary: { liveSessionId, sessionName: name, paneCount: 0 },
                 panes: new Set(),
+                windows: new Set(),
                 dir,
+                activity: activity && /^\d+$/.test(activity) ? Number(activity) : null,
             };
             row.panes.add(pane);
+            row.windows.add(window);
             rows.set(liveSessionId, row);
         }
         const names = new Set([...rows.values()].map(({ summary }) => summary.sessionName));
@@ -114,7 +122,13 @@ export function createNativeTmuxServerCatalog(workspaceRegistry, run, assertOpen
                     projectDir: dir,
                     persistence: "volatile",
                 });
-        return [...rows.values()].map(({ summary, panes }) => ({ ...summary, paneCount: panes.size }));
+        return [...rows.values()].map(({ summary, panes, windows, dir, activity }) => ({
+            ...summary,
+            paneCount: panes.size,
+            windowCount: windows.size,
+            lastActivity: activity,
+            sessionPath: dir,
+        }));
     };
 }
 /** One proven server incarnation. Never elects an endpoint or changes ambient tmux authority. */
@@ -505,6 +519,14 @@ export async function createNativeTmuxServerOwner(options) {
             run: (args, signal) => generationRunAsync(args, signal),
         }),
         resolvePaneEditorContext,
+        nativeBrowser: createNativeBrowserResolver({
+            generation,
+            assertOpen,
+            registry: workspaceRegistry,
+            catalog,
+            inventory: terminalInventoryRuntime,
+            run: generationRunAsync,
+        }),
         catalog,
         readWindowSplitLayout: async (workspaceName, input) => {
             assertOpen();

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/Info.plist

@@ -21,9 +21,9 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>2.9.14</string>
+  <string>2.9.16</string>
   <key>CFBundleVersion</key>
-  <string>2.9.14</string>
+  <string>2.9.16</string>
   <key>LSMinimumSystemVersion</key>
   <string>11.0</string>
   <key>LSUIElement</key>

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/_CodeSignature/CodeResources

@@ -10,7 +10,7 @@
 		</data>
 		<key>Resources/Assets.car</key>
 		<data>
-		vWBHvsqTbQOxNEIBI9tGJCW1B9s=
+		80sBn8yzZzR4ZHE3L4qFvRPqA+A=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -26,7 +26,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			9TKARXnkH7u4v7AEsGxJfv64Q3jE3NOm+N2tQHYvvIE=
+			PKQV15gCKuH8bIwdxGZgHEhWb0Rwq62t/R9Ozfnv/BA=
 			</data>
 		</dict>
 	</dict>

package/packages/daemon/dist/open-browser.js

@@ -1,17 +1,29 @@
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { homedir } from "node:os";
 import { IdeError } from "./lib/errors.js";
 import { resolveRuntimeNamespace, runtimeNamespaceEnvironment } from "./lib/runtime-namespace.js";
 import { createPinnedWorkspaceTmuxRunner, resolveWorkspacePaneTmuxAuthority, } from "./lib/workspace-pane-creation.js";
 /** Resolve once before creating a pane; ignore relative PATH entries. */
-export function resolveTerminalBrowser(environment = process.env) {
+export function resolveTerminalBrowser(environment = process.env, platform = process.platform) {
     const configured = environment.TMUX_IDE_TERMINAL_BROWSER_BIN;
+    const home = environment.HOME ?? homedir();
+    // Resolve the managed alias on every invocation so an app update selects its
+    // matching browser. Native assets remain outside the universal npm package.
+    const bundled = platform === "darwin" && isAbsolute(home)
+        ? [
+            join(home, "Library", "Application Support", "tmux-ide", "native-alpha", "TmuxIDE.app", "Contents", "Resources", "browser", "terminal-browser"),
+        ]
+        : [];
     const candidates = configured
         ? [configured]
-        : (environment.PATH ?? "")
-            .split(delimiter)
-            .filter(isAbsolute)
-            .map((dir) => join(dir, "terminal-browser"));
+        : [
+            ...bundled,
+            ...(environment.PATH ?? "")
+                .split(delimiter)
+                .filter(isAbsolute)
+                .map((dir) => join(dir, "terminal-browser")),
+        ];
     for (const candidate of candidates) {
         try {
             if (!isAbsolute(candidate))
@@ -64,6 +76,42 @@ export function validateBrowserOpen(url, options) {
             exitCode: 2,
         });
 }
+/** Printed when the opened browser never publishes tmux-ide's native controls. */
+export const NO_NATIVE_CONTROLS_NOTICE = "This browser has no tmux-ide controls; install the native app for back/forward/reload.";
+/** A browser bundled in a native app publishes its controls; a standalone one may not. */
+function isBundledBrowser(executable) {
+    return /\/[^/]+\.app\/Contents\/Resources\/browser\//u.test(executable);
+}
+/** How long a standalone browser has to publish its controls. */
+const STANDALONE_WAIT_MS = 2000;
+/**
+ * Watches the new pane for @tmux_ide_browser_control, which only a browser with
+ * native controls sets. A browser bundled in an app is never reported: if it is
+ * slow, its controls appear when it is ready. A standalone browser gets 2 s of
+ * wall-clock time, however slow tmux answers, and then the notice. Returns
+ * null once the option appears or when the pane is already gone.
+ */
+export async function nativeControlsNotice(run, pane, executable, wait = {}) {
+    if (isBundledBrowser(executable))
+        return null;
+    const sleep = wait.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const now = wait.now ?? Date.now;
+    const deadline = now() + STANDALONE_WAIT_MS;
+    for (;;) {
+        let control;
+        try {
+            control = run(["display-message", "-p", "-t", pane, "#{@tmux_ide_browser_control}"]).trim();
+        }
+        catch {
+            return null;
+        }
+        if (control)
+            return null;
+        if (now() >= deadline)
+            return NO_NATIVE_CONTROLS_NOTICE;
+        await sleep(250);
+    }
+}
 export function createBrowserPane(run, executable, url, options, environment, cwd, namespace) {
     validateBrowserOpen(url, options);
     const inheritedPane = /^%\d+$/u.test(environment.TMUX_PANE ?? "")
@@ -151,9 +199,16 @@ export function createBrowserPane(run, executable, url, options, environment, cw
         });
     return { pane: pane, session: createdSession, window: createdWindow, status: "created" };
 }
-export function openBrowser(url, options = {}) {
+export async function openBrowser(url, options = {}, dependencies = {}) {
     validateBrowserOpen(url, options);
-    const executable = resolveTerminalBrowser();
+    const executable = (dependencies.executable ?? resolveTerminalBrowser)();
+    const { result, run } = (dependencies.create ?? createPinnedBrowserPane)(executable, url, options);
+    const message = await nativeControlsNotice(run, result.pane, executable, dependencies.wait);
+    if (message)
+        (dependencies.notice ?? ((line) => process.stderr.write(`${line}\n`)))(message);
+    return result;
+}
+function createPinnedBrowserPane(executable, url, options) {
     try {
         const namespace = { ...runtimeNamespaceEnvironment(resolveRuntimeNamespace()) };
         const authority = resolveWorkspacePaneTmuxAuthority();
@@ -161,7 +216,8 @@ export function openBrowser(url, options = {}) {
         const run = createPinnedWorkspaceTmuxRunner(authority, {
             timeoutMs: 10_000,
         });
-        return createBrowserPane(run, executable, url, options, process.env, process.cwd(), namespace);
+        const result = createBrowserPane(run, executable, url, options, process.env, process.cwd(), namespace);
+        return { result, run };
     }
     catch (error) {
         if (error instanceof IdeError)

package/packages/daemon/dist/terminal/pane-stream/pane-stream-websocket.js

@@ -6,6 +6,7 @@ import { PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION, PANE_STREAM_INPUT_BYTES_
 import { inflateSync } from "node:zlib";
 import { PaneStreamLayoutSnapshotFrameSchemaZ } from "@tmux-ide/contracts";
 import { z } from "zod";
+import { logger } from "../../lib/log.js";
 import { PANE_STREAM_MAX_HELD_DELTAS, PANE_STREAM_MAX_OUTPUT_BYTES, PANE_STREAM_MAX_PANES, PANE_STREAM_MAX_SEED_BYTES, PANE_STREAM_PROTOCOL_VERSION, PANE_STREAM_REDEEM_PATH, PANE_STREAM_WEBSOCKET_SUBPROTOCOL, TERMINAL_GRAPHICS_BLOB_CHUNK_BYTES, TERMINAL_DELIVERY_BINARY_CAPABILITY_VERSION, TERMINAL_DELIVERY_BINARY_LOCAL_CAPABILITY_VERSION, TERMINAL_GRAPHICS_BINARY_CAPABILITY_VERSION, TERMINAL_GRAPHICS_LOCAL_CAPABILITY_VERSION, encodeTerminalGraphicsBinary, encodeTerminalDeliveryBinaryChunk, TERMINAL_GRAPHICS_CELL_PIXELS_CAPABILITY_VERSION, TERMINAL_GRAPHICS_PRECISE_PIXELS_CAPABILITY_VERSION, TERMINAL_GRAPHICS_LEGACY_MAX_IMAGE_BYTES, TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION, PaneStreamClientFrameSchemaZ, PaneStreamLoopbackWebSocketUrlSchemaZ, PaneStreamRedeemFrameSchemaZ, PaneStreamServerFrameSchemaZ, sharedMonotonicMicros, } from "@tmux-ide/contracts";
 import { canonicalOriginOrNull, digestSecret, digestsEqual, rawDataByteLength, rawDataToBuffer, safeCloseSocket, strictJsonParse, } from "../attachments/admission-util.js";
 import { SessionRuntimeControllerLeaseError } from "../session-runtime/registry.js";
@@ -547,6 +548,11 @@ class PreAuthAdmission {
         this.#open = false;
         this.#cancelDeadline();
         const socket = this.#socket;
+        logger.info("pane-stream", "admission closed", {
+            code,
+            reason,
+            hostClientId: this.hostClientId,
+        });
         this.#detach();
         this.#onRelease(this);
         if (socket)
@@ -825,6 +831,12 @@ export class PaneStreamLiveConnection {
         if (this.#closed)
             return;
         this.#recordDiagnosticLifecycle("pane-stream-terminal", code, reason);
+        logger.info("pane-stream", "stream closed", {
+            code,
+            reason,
+            session: this.#descriptor.sessionName,
+            clientId: this.#clientId,
+        });
         this.#closed = true;
         for (const demand of this.#surfaceDemands.values())
             demand.close();

package/packages/daemon/dist/terminal/session-runtime/terminal-delivery-hub.js

@@ -2,6 +2,7 @@ import { prepareProjection } from "./terminal-projection-delivery.js";
 import { TerminalProjectionEnvelopeSchemaZ, TerminalProjectionReceiptSchemaZ, TerminalProjectionMaterializeSchemaZ, } from "@tmux-ide/contracts";
 import { encodeTerminalProjectionCooperatively } from "@tmux-ide/core";
 import { StockCaptureTabUnavailableError } from "./stock-capture-fidelity.js";
+import { logger } from "../../lib/log.js";
 import { MAX_RETAINED_NATIVE_BACKING_BYTES, takeNativeSeedBacking, } from "./native-seed-backing.js";
 import { WorkspaceIdSchemaZ, TERMINAL_GRAPHICS_CAPABILITY_VERSION, TERMINAL_DELIVERY_PATCH_TO_SEED_BYTES, TERMINAL_DELIVERY_MAX_REPRESENTATION_BYTES, TerminalDeliveryEnvelopeSchemaZ, TerminalDeliveryAckSchemaZ, TerminalDeliveryNackSchemaZ, TerminalDeliveryOfferSchemaZ, TerminalDeliveryVisibilitySchemaZ, } from "@tmux-ide/contracts";
 import { TerminalDeliveryStateTooLargeError, terminalReplicaRowsEqual, TERMINAL_COMPACT_COOPERATIVE_SEED_CELLS, applyTerminalReplicaUpdate, applyTerminalReplicaUpdateCooperatively, terminalReplicaUpdateNeedsCooperativeReduction, encodeBinarySemanticTerminalUpdate, encodeBinarySemanticTerminalUpdateCooperatively, encodeCompactSemanticTerminalUpdate, encodeCompactSemanticTerminalUpdateCooperatively, terminalSemanticUpdateNeedsCooperativeEncoding, encodeAnsiTerminalRepresentation, encodeSemanticTerminalUpdate, hashTerminalDeliveryRepresentation, negotiateTerminalDelivery, preaccountSemanticTerminalUpdateBytes, } from "@tmux-ide/core";
@@ -196,6 +197,7 @@ export class SessionRuntimeTerminalDeliveryHub {
             if (!(error instanceof StockCaptureTabUnavailableError))
                 throw error;
             // Negotiation still settles this pane; no invented canonical seed is published.
+            logDeliveryFault({ paneId: semanticPaneId, deliveryWorkspaceName: address }, "source-closed", "capture-unavailable");
             await accept({
                 type: "terminal.delivery.fault",
                 reason: "source-closed",
@@ -350,6 +352,7 @@ export class SessionRuntimeTerminalDeliveryHub {
             this.#cancelEncoding(client);
             client.outgoing.length = 0;
             client.inFlight = null;
+            logDeliveryFault(client, "source-closed", "source-restarted");
             this.#enqueue(client, {
                 type: "terminal.delivery.fault",
                 reason: "source-closed",
@@ -1442,6 +1445,7 @@ export class SessionRuntimeTerminalDeliveryHub {
         this.#recordDeliveryStatus(client, this.#panes.get(client.paneId));
     }
     #fault(client, reason, message, selectionObservation = null) {
+        logDeliveryFault(client, reason);
         if (this.#observability.enabled)
             try {
                 const atMicros = this.#observability.nowMicros();
@@ -2038,3 +2042,15 @@ function joinBytes(chunks) {
     }
     return joined;
 }
+/**
+ * One info line per fault a client is sent, so a client's drop has a daemon-side
+ * record. Ids and fixed reasons only: the fault message can carry source text.
+ */
+function logDeliveryFault(client, reason, cause) {
+    logger.info("terminal-delivery", "fault sent to client", {
+        reason,
+        ...(cause ? { cause } : {}),
+        pane: client.paneId,
+        workspace: client.deliveryWorkspaceName,
+    });
+}

package/packages/daemon/src/command-center/daemon-fleet-facts-observer.ts

@@ -90,7 +90,7 @@ export class DaemonFleetFactsObserver {
 
   constructor(options: DaemonFleetFactsObserverOptions) {
     this.#options = options;
-    this.#intervalMs = options.intervalMs ?? 2_000;
+    this.#intervalMs = options.intervalMs ?? FLEET_FACTS_POLL_MS;
     this.#setTimer =
       options.setTimer ??
       ((callback, delayMs) => {
@@ -549,6 +549,14 @@ export function createDefaultFleetFactsReaders(): Pick<
   return createSharedFleetFactsReaders(execute);
 }
 
+/**
+ * How often subscribed clients' tmux facts (sessions, panes, agent stamps) are
+ * read. Hook-stamped agent changes reach clients within one tick, so 500 ms
+ * keeps a state flip visible within 1 s (#716). One `list-panes -a` per tick,
+ * only while a client is subscribed.
+ */
+export const FLEET_FACTS_POLL_MS = 500;
+
 export const SESSION_COMPOSITION_TMUX_ARGS = [
   "list-panes",
   "-a",

package/packages/daemon/src/command-center/tmux-servers.ts

@@ -22,6 +22,7 @@ import {
   TmuxServerScopeSchemaZ,
   TmuxServersResourceSchemaZ,
   TmuxServerSessionsResourceSchemaZ,
+  TmuxServerSessionsResourceV2SchemaZ,
   WorkspaceMultiplexerMutationRequestSchemaZ,
   WorkspacePaneCreateMutationRequestSchemaZ,
   WorkspaceSessionCreateArgumentsSchemaZ,
@@ -32,6 +33,7 @@ import {
   TmuxServerScopeError,
 } from "../lib/tmux-server-owners.ts";
 import type { NativeTmuxServerOwner } from "../lib/tmux-server-owner.ts";
+import { createSessionFaviconResolver, type SessionFavicon } from "../lib/session-favicon.ts";
 import { WorkspaceMultiplexerError } from "../lib/workspace-multiplexer-verbs.ts";
 import { WorkspacePaneCreationError } from "../lib/workspace-pane-creation.ts";
 import { ownerBearerMatches } from "./owner-authority.ts";
@@ -41,7 +43,11 @@ import { projectTerminalRuntimeInventory } from "./resources/terminal-runtime-in
 export interface TmuxServerRoutesOptions {
   readonly ownerToken: string | null;
   readonly owners: TmuxServerOwners<NativeTmuxServerOwner>;
+  /** Project favicon lookup for the version 2 sessions resource. */
+  readonly resolveSessionFavicon?: (sessionPath: string) => Promise<SessionFavicon | null>;
 }
+/** Total raw favicon bytes one version 2 sessions response may carry. */
+export const SESSIONS_RESOURCE_FAVICON_BUDGET_BYTES = 512 * 1024;
 const registrationSchema = TmuxServerRegistrationSchemaZ.omit({ serverId: true }).strict();
 const workspaceSchema = z
   .string()
@@ -94,6 +100,7 @@ function failure(c: Context, error: unknown): Response {
 /** Owner capability is mandatory even when the ordinary local HTTP surface is open. */
 export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOptions): void {
   const base = TMUX_SERVERS_API_PATH;
+  const resolveSessionFavicon = options.resolveSessionFavicon ?? createSessionFaviconResolver();
   const authorize = async (c: Context, next: () => Promise<void>) => {
     c.header("Cache-Control", "no-store");
     if (!ownerBearerMatches(c.req.header("Authorization"), options.ownerToken))
@@ -150,6 +157,17 @@ export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOption
     owners: options.owners,
     readBody: (request) => boundedJson(request, 8 * 1024),
   });
+  app.post(
+    `${scoped}/native-browser`,
+    route(async (c) => {
+      const server = scope(c);
+      const input = await boundedJson(c.req.raw, 24 * 1024);
+      const state = await options.owners.withOwner(server, (owner) =>
+        owner.nativeBrowser(input, c.req.raw.signal),
+      );
+      return c.json({ version: 1, state });
+    }),
+  );
   // Structured read only: this never acquires a channel or changes tmux geometry.
   app.post(
     `${scoped}/split-layout/:workspaceName`,
@@ -260,19 +278,56 @@ export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOption
     `${scoped}/sessions`,
     route(async (c) => {
       const server = scope(c);
+      const v2 = c.req.query("version") === "2";
+      const { rows, favicons } = await options.owners.withOwner(server, async (owner) => {
+        const sessions = await owner.catalog();
+        const workspaces = owner.workspaceRegistry.list();
+        const rows = sessions.map((session) => {
+          const aliases = workspaces.filter(
+            (workspace) => workspace.sessionName === session.sessionName,
+          );
+          return { session, workspaceName: aliases.length === 1 ? aliases[0]!.name : null };
+        });
+        const favicons = v2
+          ? await Promise.all(
+              sessions.map((session) =>
+                resolveSessionFavicon(session.sessionPath).catch(() => null),
+              ),
+            )
+          : [];
+        return { rows, favicons };
+      });
+      if (!v2)
+        return c.json(
+          TmuxServerSessionsResourceSchemaZ.parse({
+            version: 1,
+            server,
+            sessions: rows.map(({ session, workspaceName }) => ({
+              liveSessionId: session.liveSessionId,
+              sessionName: session.sessionName,
+              paneCount: session.paneCount,
+              workspaceName,
+            })),
+          }),
+        );
+      let budget = SESSIONS_RESOURCE_FAVICON_BUDGET_BYTES;
       return c.json(
-        TmuxServerSessionsResourceSchemaZ.parse({
-          version: 1,
+        TmuxServerSessionsResourceV2SchemaZ.parse({
+          version: 2,
           server,
-          sessions: await options.owners.withOwner(server, async (owner) => {
-            const sessions = await owner.catalog();
-            const workspaces = owner.workspaceRegistry.list();
-            return sessions.map((session) => {
-              const aliases = workspaces.filter(
-                (workspace) => workspace.sessionName === session.sessionName,
-              );
-              return { ...session, workspaceName: aliases.length === 1 ? aliases[0]!.name : null };
-            });
+          sessions: rows.map(({ session, workspaceName }, index) => {
+            const found = favicons[index] ?? null;
+            const favicon = found && found.size <= budget ? found : null;
+            if (favicon) budget -= favicon.size;
+            return {
+              liveSessionId: session.liveSessionId,
+              sessionName: session.sessionName,
+              workspaceName,
+              paneCount: session.paneCount,
+              windowCount: session.windowCount,
+              lastActivity: session.lastActivity,
+              favicon: favicon ? { mime: favicon.mime, data: favicon.data } : null,
+            };
           }),
         }),
       );

package/packages/daemon/src/lib/daemon-embed.ts

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.ts";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
 import { NativeSurfaceProviderRegistry } from "../terminal/graphics/native-surface-provider.ts";
 import { TmuxServerVersionSchemaZ } from "@tmux-ide/contracts";
@@ -1937,6 +1938,22 @@ async function startEmbeddedDaemonGeneration(
                 throw new Error("Default tmux editor context owner is unavailable");
             },
           }),
+          nativeBrowser: createNativeBrowserResolver({
+            generation: instanceId,
+            run: fleetFactsTmuxRunner,
+            registry: workspaceRegistry,
+            catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
+            inventory: terminalInventoryRuntime,
+            assertOpen: () => {
+              if (
+                defaultEditorContextRetired ||
+                serverOwners?.defaultRetired ||
+                !initialNativeServerIdentity ||
+                terminalInventoryRuntime?.lifecycleState() !== "ready"
+              )
+                throw new Error("Default native browser owner is unavailable");
+            },
+          }),
           catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
           readWindowSplitLayout: async (workspaceName, input) => {
             const target = WindowLinkTargetSchemaZ.parse(input);