tmux-ide 2.9.15 → 2.9.17

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/discovery.ts

@@ -208,10 +208,16 @@ export function isVisibleFleetSession(name: string): boolean {
 export function readAdoptedSessionNames(runTmux: TmuxRunner = _tmuxRunner): string[] | null {
   let raw: string;
   try {
-    raw = runTmux(["list-sessions", "-F", `#{session_name}\t#{${ADOPTED_OPTION}}`]);
+    raw = runTmux(ADOPTED_SESSIONS_ARGS);
   } catch {
     return null;
   }
+  return parseAdoptedSessionNames(raw);
+}
+
+const ADOPTED_SESSIONS_ARGS = ["list-sessions", "-F", `#{session_name}\t#{${ADOPTED_OPTION}}`];
+
+function parseAdoptedSessionNames(raw: string): string[] {
   const names: string[] = [];
   for (const line of raw.split("\n")) {
     if (!line) continue;
@@ -312,18 +318,77 @@ export function readAdoptedFleet(
   const nativeEpoch = nativeServerEpoch?.() ?? null;
   const adopted = readAdoptedSessionNames(runTmux);
   if (adopted === null) return null;
-  const adoptedSet = new Set(adopted);
-  if (adoptedSet.size === 0) return [];
-
-  const appCreatedSessions = new Set(registry.list().map((workspace) => workspace.sessionName));
+  if (adopted.length === 0) return [];
+  let panesRaw: string;
+  try {
+    panesRaw = runTmux(FLEET_PANES_ARGS);
+  } catch {
+    panesRaw = "";
+  }
+  return assembleAdoptedFleet(
+    adopted,
+    panesRaw,
+    registry,
+    nativeEpoch,
+    resolveInteractionEndpoint,
+    nativeServerEpoch,
+  );
+}
 
-  const panesBySession = new Map<string, FleetPaneFacts[]>();
+/**
+ * {@link readAdoptedFleet} over an asynchronous tmux runner: the same two reads
+ * in the same order, without blocking the event loop while tmux answers (#709).
+ */
+export async function readAdoptedFleetAsync(
+  registry: { list(): { sessionName: string }[] },
+  runTmux: (args: string[]) => Promise<string>,
+  resolveInteractionEndpoint?: (
+    sessionName: string,
+    pane: FleetPaneFacts,
+  ) => Extract<InteractionPaneEndpoint, { kind: "pane" }> | null,
+  nativeServerEpoch?: () => string | null,
+): Promise<FleetSessionFacts[] | null> {
+  const nativeEpoch = nativeServerEpoch?.() ?? null;
+  let sessionsRaw: string;
+  try {
+    sessionsRaw = await runTmux(ADOPTED_SESSIONS_ARGS);
+  } catch {
+    return null;
+  }
+  const adopted = parseAdoptedSessionNames(sessionsRaw);
+  if (adopted.length === 0) return [];
   let panesRaw: string;
   try {
-    panesRaw = runTmux(["list-panes", "-a", "-F", FLEET_PANE_FORMAT]);
+    panesRaw = await runTmux(FLEET_PANES_ARGS);
   } catch {
     panesRaw = "";
   }
+  return assembleAdoptedFleet(
+    adopted,
+    panesRaw,
+    registry,
+    nativeEpoch,
+    resolveInteractionEndpoint,
+    nativeServerEpoch,
+  );
+}
+
+const FLEET_PANES_ARGS = ["list-panes", "-a", "-F", FLEET_PANE_FORMAT];
+
+function assembleAdoptedFleet(
+  adopted: string[],
+  panesRaw: string,
+  registry: { list(): { sessionName: string }[] },
+  nativeEpoch: string | null,
+  resolveInteractionEndpoint?: (
+    sessionName: string,
+    pane: FleetPaneFacts,
+  ) => Extract<InteractionPaneEndpoint, { kind: "pane" }> | null,
+  nativeServerEpoch?: () => string | null,
+): FleetSessionFacts[] {
+  const adoptedSet = new Set(adopted);
+  const appCreatedSessions = new Set(registry.list().map((workspace) => workspace.sessionName));
+  const panesBySession = new Map<string, FleetPaneFacts[]>();
   for (const line of panesRaw.split("\n")) {
     if (!line) continue;
     const fields = line.split(FLEET_FIELD_SEPARATOR);

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))
@@ -271,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/catalog-fleet-read.ts

@@ -0,0 +1,40 @@
+import type { InteractionPaneEndpoint } from "@tmux-ide/contracts";
+import {
+  readAdoptedFleet,
+  readAdoptedFleetAsync,
+  type FleetPaneFacts,
+  type FleetSessionFacts,
+} from "../command-center/discovery.ts";
+
+/** The two runners a catalog fleet read may use; both are fenced to one tmux server generation. */
+export interface CatalogFleetRunners {
+  /** The session-mutation fence; only its `active` state is read here. */
+  readonly fence: { readonly active: boolean };
+  /** Synchronous runner wrapped by that fence: inside a mutation it adds the session check. */
+  readonly fencedSync: (args: string[]) => string;
+  /** Asynchronous runner fenced to the same server generation. */
+  readonly generationFencedAsync: (args: string[]) => Promise<string>;
+}
+
+/**
+ * Read the catalog fleet without blocking the event loop (#709), except inside
+ * a session mutation, where the read keeps the fence's synchronous runner.
+ */
+export async function readCatalogFleet(
+  registry: { list(): { sessionName: string }[] },
+  runners: CatalogFleetRunners,
+  resolveInteractionEndpoint?: (
+    sessionName: string,
+    pane: FleetPaneFacts,
+  ) => Extract<InteractionPaneEndpoint, { kind: "pane" }> | null,
+  nativeServerEpoch?: () => string | null,
+): Promise<FleetSessionFacts[] | null> {
+  return runners.fence.active
+    ? readAdoptedFleet(registry, runners.fencedSync, resolveInteractionEndpoint, nativeServerEpoch)
+    : readAdoptedFleetAsync(
+        registry,
+        runners.generationFencedAsync,
+        resolveInteractionEndpoint,
+        nativeServerEpoch,
+      );
+}

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

@@ -117,7 +117,12 @@ import {
   resolveWorkspacePaneTmuxAuthority,
   WorkspacePaneCreationAuthority,
 } from "./workspace-pane-creation.ts";
-import { discoverLiveSessionSummaries, readAdoptedFleet } from "../command-center/discovery.ts";
+import {
+  discoverLiveSessionSummaries,
+  readAdoptedFleet,
+  type FleetSessionFacts,
+} from "../command-center/discovery.ts";
+import { readCatalogFleet } from "./catalog-fleet-read.ts";
 import { WorkspaceOpenAuthority } from "./workspace-open.ts";
 import { WorkspacePromotionAuthority } from "./workspace-promotion.ts";
 import { WorkspaceOpenHandoffCoordinator } from "./workspace-open-handoff.ts";
@@ -2103,18 +2108,28 @@ async function startEmbeddedDaemonGeneration(
         paneStreamRuntime,
         catalogLiveSessions: () => discoverLiveSessionSummaries(catalogTmuxRunner),
         catalogFleet: async () => {
-          const fleet = readAdoptedFleet(
+          const endpoint = (sessionName: string, pane: FleetSessionFacts["panes"][number]) =>
+            pane.semanticPaneId
+              ? (interactionEvidence?.captureInventoryEndpoint(
+                  sessionName,
+                  pane.runtimePaneId,
+                  pane.semanticPaneId,
+                ) ?? null)
+              : null;
+          const epoch = () => observationSelector?.nativeServerEpoch ?? null;
+          // Same pinned server generation either way. Outside a session
+          // mutation the read must not block the event loop: every concurrent
+          // catalog request queued behind its spawnSync (#709). Inside one,
+          // keep the fenced synchronous runner the mutation relies on.
+          const fleet = await readCatalogFleet(
             workspaceRegistry,
-            nativeGenerationTmuxRunner,
-            (sessionName, pane) =>
-              pane.semanticPaneId
-                ? (interactionEvidence?.captureInventoryEndpoint(
-                    sessionName,
-                    pane.runtimePaneId,
-                    pane.semanticPaneId,
-                  ) ?? null)
-                : null,
-            () => observationSelector?.nativeServerEpoch ?? null,
+            {
+              fence: sessionMutationFence,
+              fencedSync: nativeGenerationTmuxRunner,
+              generationFencedAsync: (args) => fleetFactsTmuxRunner(args),
+            },
+            endpoint,
+            epoch,
           );
           if (!fleet) return null;
           const names = await readTeamMemberships(

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

@@ -149,13 +149,20 @@ export async function manageDaemonService(
       refused("The service manager loaded a different definition; refusing to control it");
     return state;
   };
-  const ready = async (previousInstance?: string) => {
+  // `retiredPid` is the process this restart terminated. It can publish a record
+  // while it shuts down (a KeepAlive relaunch just before the restart), so it is
+  // never the replacement, whatever its instance id.
+  const ready = async (previousInstance?: string, retiredPid?: number | null) => {
     const deadline = Date.now() + deps.waitMs;
     do {
       const state = deps.inspect();
       if (!boundTo(state, plan.supervisionId))
         refused("Service reservation changed during startup");
-      if (state.status === "valid" && state.info.instanceId !== previousInstance) {
+      if (
+        state.status === "valid" &&
+        state.info.instanceId !== previousInstance &&
+        state.info.pid !== retiredPid
+      ) {
         const identity = await deps.probe(state.info);
         const service = await inspectManager();
         if (
@@ -283,9 +290,15 @@ export async function manageDaemonService(
     }
     const before = deps.inspect();
     if (action === "install" && service.active) return await ready();
-    if (service.loaded) await manager.restart(service.pid !== null);
+    // Read the manager again: a relaunch may have replaced the process while this
+    // waited for the lock, and the restart terminates whichever one runs now.
+    const current = service.loaded ? await inspectManager() : service;
+    if (current.loaded) await manager.restart(current.pid !== null);
     else await manager.install();
-    return await ready(before.status === "valid" ? before.info.instanceId : undefined);
+    return await ready(
+      before.status === "valid" ? before.info.instanceId : undefined,
+      current.loaded ? current.pid : null,
+    );
   } catch (error) {
     // Never discard ownership after an uncertain OS activation. The retained
     // record/reservation gives the explicit remove/restart commands a recovery path.

package/packages/daemon/src/lib/session-favicon.ts

@@ -0,0 +1,185 @@
+import { constants, type Stats } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { extname, isAbsolute, join } from "node:path";
+import {
+  TMUX_SERVER_SESSION_FAVICON_MAX_BYTES,
+  type TmuxServerSessionFaviconMime,
+} from "@tmux-ide/contracts";
+
+/** Project-relative favicon locations, first match wins. */
+export const SESSION_FAVICON_CANDIDATES = [
+  "favicon.svg",
+  "favicon.png",
+  "favicon.ico",
+  "public/favicon.svg",
+  "public/favicon.png",
+  "public/favicon.ico",
+  "app/icon.svg",
+  "app/icon.png",
+  "app/favicon.ico",
+  "src/app/icon.svg",
+  "src/app/icon.png",
+  "src/app/favicon.ico",
+  "static/favicon.svg",
+  "static/favicon.png",
+  "static/favicon.ico",
+  "assets/favicon.svg",
+  "assets/favicon.png",
+  "assets/favicon.ico",
+  "apple-touch-icon.png",
+  "public/apple-touch-icon.png",
+  "icon.svg",
+  "icon.png",
+] as const;
+
+const MIME_BY_EXTENSION: Readonly<Record<string, TmuxServerSessionFaviconMime>> = {
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+
+export interface SessionFavicon {
+  readonly mime: TmuxServerSessionFaviconMime;
+  /** Base64 of the raw file bytes. */
+  readonly data: string;
+  /** Raw byte count. */
+  readonly size: number;
+}
+
+export interface SessionFaviconIo {
+  lstat(path: string): Promise<Stats>;
+  /** Reads a regular file without following a final symlink; null when refused or too large. */
+  readNoFollow(path: string, maxBytes: number): Promise<Buffer | null>;
+}
+
+export const defaultSessionFaviconIo: SessionFaviconIo = {
+  lstat: (path) => lstat(path),
+  readNoFollow: async (path, maxBytes) => {
+    let handle;
+    try {
+      handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch {
+      return null;
+    }
+    try {
+      const stats = await handle.stat();
+      if (!stats.isFile() || stats.size > maxBytes) return null;
+      const bytes = await handle.readFile();
+      return bytes.byteLength > maxBytes ? null : bytes;
+    } catch {
+      return null;
+    } finally {
+      await handle.close().catch(() => undefined);
+    }
+  },
+};
+
+type CacheEntry =
+  | {
+      readonly kind: "hit";
+      readonly file: string;
+      readonly mtimeMs: number;
+      readonly size: number;
+      readonly favicon: SessionFavicon;
+    }
+  | { readonly kind: "miss"; readonly at: number };
+
+export interface SessionFaviconResolverOptions {
+  readonly io?: SessionFaviconIo;
+  readonly now?: () => number;
+  readonly missTtlMs?: number;
+  readonly maxEntries?: number;
+}
+
+async function lstatOrNull(io: SessionFaviconIo, path: string): Promise<Stats | null> {
+  try {
+    return await io.lstat(path);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Finds a session's project favicon from its working directory. Only regular
+ * files and real directories inside the session path are considered; symlinks
+ * are never followed. Hits are revalidated by mtime and size, misses are
+ * remembered briefly, and the cache is bounded (least recently used first).
+ */
+export function createSessionFaviconResolver(options: SessionFaviconResolverOptions = {}) {
+  const io = options.io ?? defaultSessionFaviconIo;
+  const now = options.now ?? Date.now;
+  const missTtlMs = options.missTtlMs ?? 30_000;
+  const maxEntries = options.maxEntries ?? 256;
+  const cache = new Map<string, CacheEntry>();
+
+  const remember = (sessionPath: string, entry: CacheEntry) => {
+    cache.delete(sessionPath);
+    cache.set(sessionPath, entry);
+    while (cache.size > maxEntries) cache.delete(cache.keys().next().value!);
+  };
+
+  const scan = async (sessionPath: string): Promise<CacheEntry> => {
+    const directories = new Map<string, boolean>();
+    for (const candidate of SESSION_FAVICON_CANDIDATES) {
+      const mime = MIME_BY_EXTENSION[extname(candidate)];
+      if (!mime) continue;
+      const slash = candidate.lastIndexOf("/");
+      if (slash >= 0) {
+        const parts = candidate.slice(0, slash).split("/");
+        let real = true;
+        for (let index = 1; index <= parts.length && real; index += 1) {
+          const directory = parts.slice(0, index).join("/");
+          let known = directories.get(directory);
+          if (known === undefined) {
+            const stats = await lstatOrNull(io, join(sessionPath, directory));
+            known = stats !== null && stats.isDirectory() && !stats.isSymbolicLink();
+            directories.set(directory, known);
+          }
+          real = known;
+        }
+        if (!real) continue;
+      }
+      const file = join(sessionPath, candidate);
+      const stats = await lstatOrNull(io, file);
+      if (!stats || !stats.isFile() || stats.size > TMUX_SERVER_SESSION_FAVICON_MAX_BYTES) continue;
+      const bytes = await io.readNoFollow(file, TMUX_SERVER_SESSION_FAVICON_MAX_BYTES);
+      if (!bytes) continue;
+      return {
+        kind: "hit",
+        file,
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+        favicon: { mime, data: bytes.toString("base64"), size: bytes.byteLength },
+      };
+    }
+    return { kind: "miss", at: now() };
+  };
+
+  return async (sessionPath: string): Promise<SessionFavicon | null> => {
+    if (!sessionPath || !isAbsolute(sessionPath) || sessionPath.includes("\0")) return null;
+    const cached = cache.get(sessionPath);
+    if (cached?.kind === "miss" && now() - cached.at < missTtlMs) {
+      remember(sessionPath, cached);
+      return null;
+    }
+    if (cached?.kind === "hit") {
+      const stats = await lstatOrNull(io, cached.file);
+      if (
+        stats &&
+        stats.isFile() &&
+        stats.mtimeMs === cached.mtimeMs &&
+        stats.size === cached.size
+      ) {
+        remember(sessionPath, cached);
+        return cached.favicon;
+      }
+    }
+    const entry = await scan(sessionPath);
+    remember(sessionPath, entry);
+    return entry.kind === "hit" ? entry.favicon : null;
+  };
+}

package/packages/daemon/src/lib/skill-sync.ts

@@ -13,8 +13,8 @@ import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
  *
  * The dir is FULLY MANAGED: overwriting our own `~/.claude/skills/tmux-ide` is
  * correct, and this NEVER touches anything outside it (user-authored skills in
- * sibling dirs are safe). The version marker is line 2 of SKILL.md, an HTML
- * comment ({@link VERSION_MARKER_RE}); {@link parseSkillVersion} reads it and
+ * sibling dirs are safe). The version marker is an HTML comment under
+ * SKILL.md's frontmatter ({@link VERSION_MARKER_RE}); {@link parseSkillVersion} reads it and
  * {@link rewriteVersionMarker} substitutes it at copy time.
  *
  * The parse/render helpers are PURE and tested against fixtures; {@link syncSkill}
@@ -73,7 +73,7 @@ export function defaultSkillSource(): string {
 // ---------------------------------------------------------------------------
 
 /**
- * The version marker line (an HTML comment on line 2 of SKILL.md). The sync
+ * The version marker line (an HTML comment under SKILL.md's frontmatter). The sync
  * machinery reads it to know which version an installed copy is, and rewrites it
  * to the installed package version at copy time.
  */

package/packages/daemon/src/lib/tmux-server-owner.ts

@@ -97,13 +97,23 @@ function discoveredWorkspaceName(registry: WorkspaceRegistry, sessionName: strin
   throw new Error("Unable to allocate discovered workspace identity");
 }
 
+/** A live session row with the facts the native app's Home shows beside it. */
+export interface NativeLiveSessionSummary extends LiveSessionSummary {
+  /** Distinct tmux windows of the session (at least one). */
+  readonly windowCount: number;
+  /** tmux `#{session_activity}` in epoch seconds, or null when tmux reports none. */
+  readonly lastActivity: number | null;
+  /** tmux `#{session_path}`, the session's working directory. */
+  readonly sessionPath: string;
+}
+
 /** Refresh discovered live membership without changing durable workspace intent or aliases. */
 export function createNativeTmuxServerCatalog(
   workspaceRegistry: WorkspaceRegistry,
   run: (args: readonly string[], signal?: AbortSignal) => Promise<string>,
   assertOpen: () => void = () => undefined,
-): () => Promise<LiveSessionSummary[]> {
-  return async (): Promise<LiveSessionSummary[]> => {
+): () => Promise<NativeLiveSessionSummary[]> {
+  return async (): Promise<NativeLiveSessionSummary[]> => {
     assertOpen();
     const raw = await run(
       [
@@ -116,7 +126,8 @@ export function createNativeTmuxServerCatalog(
           "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(" "),
@@ -126,13 +137,20 @@ export function createNativeTmuxServerCatalog(
     assertOpen();
     const rows = new Map<
       string,
-      { summary: LiveSessionSummary; panes: Set<string>; dir: string }
+      {
+        summary: LiveSessionSummary;
+        panes: Set<string>;
+        windows: Set<string>;
+        dir: string;
+        activity: number | null;
+      }
     >();
     // Only the successful server-side zero-session branch proves emptiness.
     // 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) ||
@@ -143,6 +161,8 @@ export function createNativeTmuxServerCatalog(
         !name ||
         !pane ||
         !/^%\d+$/.test(pane) ||
+        !window ||
+        !/^@\d+$/.test(window) ||
         !dir
       )
         throw new Error("Invalid native server catalog");
@@ -151,9 +171,12 @@ export function createNativeTmuxServerCatalog(
       const row = rows.get(liveSessionId) ?? {
         summary: { liveSessionId, sessionName: name, paneCount: 0 },
         panes: new Set<string>(),
+        windows: new Set<string>(),
         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));
@@ -170,7 +193,13 @@ export function createNativeTmuxServerCatalog(
           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,
+    }));
   };
 }