From 7cc78dd5d8f306f9c7c18031372b01508de2343e Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 01:21:56 +0200
Subject: [PATCH 1/6] feat(dev-dashboard): one tmux/ttyd identity: Claude
 /rename pane-title sync, hub ttyd tabs, dd-* naming

---
 src/dev-dashboard/config.ts                   |   2 +
 src/dev-dashboard/contract/dto.ts             |   7 +
 .../lib/tmux/claude-pane-title.test.ts        |  35 ++++
 .../lib/tmux/claude-pane-title.ts             |  46 +++++
 src/dev-dashboard/lib/tmux/hub.test.ts        |  38 +++-
 src/dev-dashboard/lib/tmux/hub.ts             |  33 +++-
 src/dev-dashboard/lib/tmux/naming.test.ts     |  12 ++
 src/dev-dashboard/lib/tmux/naming.ts          |   5 +-
 src/dev-dashboard/lib/ttyd/label.ts           |  14 +-
 src/dev-dashboard/lib/ttyd/naming.test.ts     |  19 +-
 src/dev-dashboard/lib/ttyd/naming.ts          |  36 +++-
 src/dev-dashboard/lib/ttyd/types.ts           |   9 +-
 src/dev-dashboard/server/routes/cmux.ts       |   6 +-
 .../ui/src/components/TmuxSessionName.tsx     |   3 +-
 .../ui/src/components/TmuxSessionsPanel.tsx   |  40 +++-
 .../terminal-shell/MobileTerminalShell.tsx    |  28 ++-
 src/dev-dashboard/ui/src/lib/api.ts           |   7 +
 .../ui/src/lib/terminal-tabs.test.ts          |  19 +-
 src/dev-dashboard/ui/src/routes/ttyd.tsx      |   3 +-
 src/tmux/commands/sessions-format.ts          |  34 ++++
 src/tmux/commands/sessions.test.ts            |  24 +++
 src/tmux/commands/sessions.ts                 | 181 ++++++++++++++----
 22 files changed, 518 insertions(+), 83 deletions(-)
 create mode 100644 src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
 create mode 100644 src/dev-dashboard/lib/tmux/claude-pane-title.ts
 create mode 100644 src/dev-dashboard/lib/tmux/naming.test.ts
 create mode 100644 src/tmux/commands/sessions-format.ts
 create mode 100644 src/tmux/commands/sessions.test.ts

diff --git a/src/dev-dashboard/config.ts b/src/dev-dashboard/config.ts
index 4d9e405b3..3105af06c 100644
--- a/src/dev-dashboard/config.ts
+++ b/src/dev-dashboard/config.ts
@@ -41,6 +41,8 @@ const TtydSessionSchema = z.object({
     pid: z.number().int(),
     startedAt: z.string(),
     tmuxSessionName: z.string().optional(),
+    /** User-set display name; also mirrors the tmux session name after a unified rename. */
+    name: z.string().optional(),
 });
 
 const WeatherCoordsSchema = z.object({
diff --git a/src/dev-dashboard/contract/dto.ts b/src/dev-dashboard/contract/dto.ts
index 62b7a9e47..4545ae78e 100644
--- a/src/dev-dashboard/contract/dto.ts
+++ b/src/dev-dashboard/contract/dto.ts
@@ -114,6 +114,13 @@ export interface TmuxHubSession {
     attached: number;
     windows: number;
     ttydTabIds: string[];
+    ttydTabs: Array<{
+        id: string;
+        port: number;
+        label: string;
+        cwd?: string;
+        lastCommand?: string;
+    }>;
     canAttachInTtyd: boolean;
     cmuxSurfaces: Array<{ workspaceId: string; surfaceId: string; title: string }>;
     inCmux: boolean;
diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
new file mode 100644
index 000000000..24f3401e2
--- /dev/null
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import { isClaudeForegroundCommand, parseClaudePaneTitle } from "@app/dev-dashboard/lib/tmux/claude-pane-title";
+
+describe("parseClaudePaneTitle", () => {
+    test("strips working and idle markers", () => {
+        expect(parseClaudePaneTitle("✳ testt")).toBe("testt");
+        expect(parseClaudePaneTitle("⠐ templates-todo")).toBe("templates-todo");
+        expect(parseClaudePaneTitle("* testt")).toBe("testt");
+    });
+
+    test("keeps multi-word titles and sanitizes colons", () => {
+        expect(parseClaudePaneTitle("✳ Debug formatting: spacing")).toBe("Debug formatting- spacing");
+    });
+
+    test("rejects non-Claude titles and the stock default", () => {
+        expect(parseClaudePaneTitle("zsh")).toBeNull();
+        expect(parseClaudePaneTitle("/Users/me/proj")).toBeNull();
+        expect(parseClaudePaneTitle("…/Projects/Foo")).toBeNull();
+        expect(parseClaudePaneTitle("")).toBeNull();
+        expect(parseClaudePaneTitle(undefined)).toBeNull();
+        expect(parseClaudePaneTitle("✳ Claude Code")).toBeNull();
+        expect(parseClaudePaneTitle("⠐ Claude Code")).toBeNull();
+    });
+});
+
+describe("isClaudeForegroundCommand", () => {
+    test("matches claude binaries only", () => {
+        expect(isClaudeForegroundCommand("claude")).toBe(true);
+        expect(isClaudeForegroundCommand("/opt/homebrew/bin/claude")).toBe(true);
+        expect(isClaudeForegroundCommand("claude-code")).toBe(true);
+        expect(isClaudeForegroundCommand("bash")).toBe(false);
+        expect(isClaudeForegroundCommand("cursor")).toBe(false);
+        expect(isClaudeForegroundCommand(undefined)).toBe(false);
+    });
+});
diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
new file mode 100644
index 000000000..4796e09de
--- /dev/null
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
@@ -0,0 +1,46 @@
+/**
+ * Claude Code sets the tmux pane title via OSC to `✳ <name>` (working) or `⠐ <name>` (idle)
+ * after `/rename`. Strip that marker so we can mirror the name onto the tmux session + ttyd tab.
+ *
+ * @see src/cmux/docs/Cmux.md — same title convention on cmux surfaces.
+ */
+const CLAUDE_PANE_TITLE_RE = /^[✳⠐*]\s*(.+)$/u;
+
+/** Stock title before the user runs `/rename` — never promote this to a session name. */
+const CLAUDE_DEFAULT_TITLES = new Set(["claude code", "claude"]);
+
+export function parseClaudePaneTitle(title: string | undefined | null): string | null {
+    if (!title) {
+        return null;
+    }
+
+    const trimmed = title.trim();
+
+    if (!trimmed) {
+        return null;
+    }
+
+    const match = trimmed.match(CLAUDE_PANE_TITLE_RE);
+
+    if (!match?.[1]) {
+        return null;
+    }
+
+    // tmux session names cannot contain `:`. Collapse whitespace; keep the rest.
+    const name = match[1].replace(/:/g, "-").replace(/\s+/g, " ").trim();
+
+    if (!name || CLAUDE_DEFAULT_TITLES.has(name.toLowerCase())) {
+        return null;
+    }
+
+    return name;
+}
+
+export function isClaudeForegroundCommand(command: string | undefined): boolean {
+    if (!command) {
+        return false;
+    }
+
+    const base = command.trim().split("/").pop()?.toLowerCase() ?? "";
+    return base === "claude" || base === "claude-code";
+}
diff --git a/src/dev-dashboard/lib/tmux/hub.test.ts b/src/dev-dashboard/lib/tmux/hub.test.ts
index d3c4b3307..c128d2483 100644
--- a/src/dev-dashboard/lib/tmux/hub.test.ts
+++ b/src/dev-dashboard/lib/tmux/hub.test.ts
@@ -8,13 +8,48 @@ describe("tmux hub enrichment", () => {
                 { name: "free-session", attached: 0, windows: 1 },
                 { name: "busy-session", attached: 1, windows: 1 },
             ],
-            [{ id: "tab-1", tmuxSessionName: "busy-session" }]
+            [{ id: "tab-1", port: 60586, command: "/bin/zsh", cwd: "/work", tmuxSessionName: "busy-session" }]
         );
 
         expect(enriched[0]?.canAttachInTtyd).toBe(true);
         expect(enriched[0]?.ttydTabIds).toEqual([]);
+        expect(enriched[0]?.ttydTabs).toEqual([]);
         expect(enriched[1]?.canAttachInTtyd).toBe(false);
         expect(enriched[1]?.ttydTabIds).toEqual(["tab-1"]);
+        expect(enriched[1]?.ttydTabs).toEqual([
+            {
+                id: "tab-1",
+                port: 60586,
+                label: "busy-session",
+                cwd: "/work",
+                lastCommand: undefined,
+            },
+        ]);
+    });
+
+    test("surfaces ttyd display name / lastCommand on hub tabs", () => {
+        const enriched = enrichSessionsForHub(
+            [{ name: "bridge", attached: 1, windows: 1 }],
+            [
+                {
+                    id: "t1",
+                    port: 50100,
+                    command: "/bin/zsh",
+                    cwd: "/Users/me/proj",
+                    tmuxSessionName: "bridge",
+                    name: "My Bridge",
+                    lastCommand: "claude",
+                },
+            ]
+        );
+
+        expect(enriched[0]?.ttydTabs[0]).toEqual({
+            id: "t1",
+            port: 50100,
+            label: "My Bridge",
+            cwd: "/Users/me/proj",
+            lastCommand: "claude",
+        });
     });
 
     test("marks sessions attached in cmux", () => {
@@ -25,5 +60,6 @@ describe("tmux hub enrichment", () => {
 
         expect(enriched[0]?.inCmux).toBe(true);
         expect(enriched[0]?.cmuxSurfaces).toHaveLength(1);
+        expect(enriched[0]?.ttydTabs).toEqual([]);
     });
 });
diff --git a/src/dev-dashboard/lib/tmux/hub.ts b/src/dev-dashboard/lib/tmux/hub.ts
index ada473c46..bdd7ff6cc 100644
--- a/src/dev-dashboard/lib/tmux/hub.ts
+++ b/src/dev-dashboard/lib/tmux/hub.ts
@@ -1,8 +1,18 @@
+import { ttydLabel } from "@app/dev-dashboard/lib/ttyd/label";
 import type { CmuxTmuxSurfaceRef } from "@genesiscz/utils/cmux/tmux-bindings";
 import type { TmuxSessionInfo } from "@genesiscz/utils/tmux/types";
 
+export interface TtydHubTab {
+    id: string;
+    port: number;
+    label: string;
+    cwd?: string;
+    lastCommand?: string;
+}
+
 export interface TmuxHubSession extends TmuxSessionInfo {
     ttydTabIds: string[];
+    ttydTabs: TtydHubTab[];
     canAttachInTtyd: boolean;
     cmuxSurfaces: CmuxTmuxSurfaceRef[];
     inCmux: boolean;
@@ -10,7 +20,12 @@ export interface TmuxHubSession extends TmuxSessionInfo {
 
 interface TtydBinding {
     id: string;
+    port: number;
+    command: string;
+    cwd: string;
     tmuxSessionName?: string;
+    name?: string;
+    lastCommand?: string;
 }
 
 export function enrichSessionsForHub(
@@ -18,26 +33,34 @@ export function enrichSessionsForHub(
     ttydSessions: TtydBinding[],
     cmuxBySession: Map<string, CmuxTmuxSurfaceRef[]> = new Map()
 ): TmuxHubSession[] {
-    const ttydByTmux = new Map<string, string[]>();
+    const ttydByTmux = new Map<string, TtydHubTab[]>();
 
     for (const ttyd of ttydSessions) {
         if (!ttyd.tmuxSessionName) {
             continue;
         }
 
+        const tab: TtydHubTab = {
+            id: ttyd.id,
+            port: ttyd.port,
+            label: ttydLabel(ttyd),
+            cwd: ttyd.cwd,
+            lastCommand: ttyd.lastCommand,
+        };
         const existing = ttydByTmux.get(ttyd.tmuxSessionName) ?? [];
-        existing.push(ttyd.id);
+        existing.push(tab);
         ttydByTmux.set(ttyd.tmuxSessionName, existing);
     }
 
     return sessions.map((session) => {
-        const ttydTabIds = ttydByTmux.get(session.name) ?? [];
+        const ttydTabs = ttydByTmux.get(session.name) ?? [];
         const cmuxSurfaces = cmuxBySession.get(session.name) ?? [];
 
         return {
             ...session,
-            ttydTabIds,
-            canAttachInTtyd: ttydTabIds.length === 0,
+            ttydTabIds: ttydTabs.map((tab) => tab.id),
+            ttydTabs,
+            canAttachInTtyd: ttydTabs.length === 0,
             cmuxSurfaces,
             inCmux: cmuxSurfaces.length > 0,
         };
diff --git a/src/dev-dashboard/lib/tmux/naming.test.ts b/src/dev-dashboard/lib/tmux/naming.test.ts
new file mode 100644
index 000000000..1b8a8581c
--- /dev/null
+++ b/src/dev-dashboard/lib/tmux/naming.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, test } from "bun:test";
+import { makeCmuxTmuxSessionName, makeTtydTmuxSessionName } from "@app/dev-dashboard/lib/tmux/naming";
+
+describe("tmux session naming", () => {
+    test("ttyd defaults to dd-<8hex>", () => {
+        expect(makeTtydTmuxSessionName("58bcf039-aaaa-bbbb-cccc-dddddddddddd")).toBe("dd-58bcf039");
+    });
+
+    test("cmux defaults to dd-cmux-<8hex>", () => {
+        expect(makeCmuxTmuxSessionName()).toMatch(/^dd-cmux-[0-9a-f]{8}$/);
+    });
+});
diff --git a/src/dev-dashboard/lib/tmux/naming.ts b/src/dev-dashboard/lib/tmux/naming.ts
index 7c861858b..47d7846ad 100644
--- a/src/dev-dashboard/lib/tmux/naming.ts
+++ b/src/dev-dashboard/lib/tmux/naming.ts
@@ -2,10 +2,11 @@ import { makeStandaloneTmuxSessionName } from "@genesiscz/utils/tmux/naming";
 
 export { DEV_DASHBOARD_WORKSPACE } from "@app/dev-dashboard/lib/tmux/constants";
 
+/** Short default for ttyd-spawned sessions — was `dev-dashboard-<8hex>`, now `dd-<8hex>`. */
 export function makeTtydTmuxSessionName(id: string): string {
-    return `dev-dashboard-${id.slice(0, 8)}`;
+    return `dd-${id.slice(0, 8)}`;
 }
 
 export function makeCmuxTmuxSessionName(): string {
-    return makeStandaloneTmuxSessionName("dev-dashboard-cmux");
+    return makeStandaloneTmuxSessionName("dd-cmux");
 }
diff --git a/src/dev-dashboard/lib/ttyd/label.ts b/src/dev-dashboard/lib/ttyd/label.ts
index 962acd488..a11c84056 100644
--- a/src/dev-dashboard/lib/ttyd/label.ts
+++ b/src/dev-dashboard/lib/ttyd/label.ts
@@ -1,16 +1,14 @@
-import type { TtydSession } from "./types";
+import { deriveTtydDisplayName, type TtydNameSource } from "@app/dev-dashboard/lib/ttyd/naming";
 
 /**
  * Display label for a ttyd session. Pure — lives in its own module (not
  * `manager.ts`) so the browser can import it without dragging the server-only
  * manager (node:child_process, config → auth → node:crypto) into the client
  * bundle.
+ *
+ * Delegates to {@link deriveTtydDisplayName} so tab chrome and Session Hub share
+ * the same identity (tmux session name), not `zsh :port`.
  */
-export function ttydLabel(session: TtydSession): string {
-    const name = session.name?.trim();
-    if (name) {
-        return name;
-    }
-
-    return `${session.command.split("/").pop()} :${session.port}`;
+export function ttydLabel(session: TtydNameSource): string {
+    return deriveTtydDisplayName(session);
 }
diff --git a/src/dev-dashboard/lib/ttyd/naming.test.ts b/src/dev-dashboard/lib/ttyd/naming.test.ts
index eeb929fc7..a53c28b88 100644
--- a/src/dev-dashboard/lib/ttyd/naming.test.ts
+++ b/src/dev-dashboard/lib/ttyd/naming.test.ts
@@ -28,15 +28,15 @@ describe("isMeaningfulCommand", () => {
     });
 });
 
-describe("deriveTtydDisplayName precedence (manual wins — auto never overwrites)", () => {
-    it("a manual name beats a meaningful lastCommand", () => {
+describe("deriveTtydDisplayName precedence (tmux identity over live command)", () => {
+    it("a manual name beats tmux session name and lastCommand", () => {
         const s = session({ name: "My Server", lastCommand: "vim", tmuxSessionName: "dev-dashboard-abc12345" });
         expect(deriveTtydDisplayName(s)).toBe("My Server");
     });
 
-    it("auto-names from lastCommand when no manual name", () => {
+    it("prefers tmux session name over a meaningful lastCommand (shared hub identity)", () => {
         const s = session({ lastCommand: "claude", tmuxSessionName: "dev-dashboard-abc12345" });
-        expect(deriveTtydDisplayName(s)).toBe("claude");
+        expect(deriveTtydDisplayName(s)).toBe("dev-dashboard-abc12345");
     });
 
     it("falls back to tmux session name when lastCommand is just a shell", () => {
@@ -44,13 +44,18 @@ describe("deriveTtydDisplayName precedence (manual wins — auto never overwrite
         expect(deriveTtydDisplayName(s)).toBe("dev-dashboard-abc12345");
     });
 
-    it("falls back to command when there is no tmux binding and no meaningful command", () => {
+    it("uses meaningful lastCommand when unbound", () => {
+        const s = session({ lastCommand: "node", command: "/bin/zsh" });
+        expect(deriveTtydDisplayName(s)).toBe("node");
+    });
+
+    it("falls back to command:port when unbound and no meaningful command", () => {
         const s = session({ command: "/bin/zsh", lastCommand: "zsh" });
-        expect(deriveTtydDisplayName(s)).toBe("/bin/zsh");
+        expect(deriveTtydDisplayName(s)).toBe("zsh :4001");
     });
 
     it("a whitespace-only manual name is treated as unset", () => {
         const s = session({ name: "   ", lastCommand: "node", tmuxSessionName: "t" });
-        expect(deriveTtydDisplayName(s)).toBe("node");
+        expect(deriveTtydDisplayName(s)).toBe("t");
     });
 });
diff --git a/src/dev-dashboard/lib/ttyd/naming.ts b/src/dev-dashboard/lib/ttyd/naming.ts
index c412bf013..71783e638 100644
--- a/src/dev-dashboard/lib/ttyd/naming.ts
+++ b/src/dev-dashboard/lib/ttyd/naming.ts
@@ -1,9 +1,16 @@
 import type { TtydSession } from "@app/dev-dashboard/lib/ttyd/types";
 
+/**
+ * The subset of {@link TtydSession} the display-name derivation actually reads. Structural on
+ * purpose: hub enrichment passes contract-shaped bindings that lack `pid`/`startedAt`.
+ */
+export type TtydNameSource = Pick<TtydSession, "name" | "tmuxSessionName" | "lastCommand" | "command" | "port">;
+
 /**
  * Commands that are not meaningful as an auto-name — a session sitting at a shell prompt should fall
  * back to its tmux name / spawn command, not be labeled "zsh". Long-running foreground processes
- * (claude, vim, node, …) ARE meaningful, so anything not in this set becomes the auto-name.
+ * (claude, vim, node, …) ARE meaningful, so anything not in this set becomes the auto-name when
+ * there is no tmux binding.
  */
 const UNINTERESTING_COMMANDS = new Set(["zsh", "bash", "sh", "fish", "-zsh", "-bash", "login", "tmux"]);
 
@@ -17,25 +24,36 @@ export function isMeaningfulCommand(command: string | undefined): command is str
     return trimmed.length > 0 && !UNINTERESTING_COMMANDS.has(trimmed);
 }
 
+function portFallback(session: TtydNameSource): string {
+    return `${session.command.split("/").pop()} :${session.port}`;
+}
+
 /**
- * The display name for a ttyd session, honoring the precedence the user asked for — a MANUAL name
- * always wins, so the automatic command-derived name never overwrites a hand-set one:
+ * The display name for a ttyd session. Manual rename always wins; otherwise the **tmux session
+ * name** is the shared identity with Session Hub (so tabs like `zsh :60586` never diverge from the
+ * hub row). Meaningful foreground commands only auto-name when there is no tmux binding.
  *
- *   1. `name`          — explicit rename (the in-terminal pencil or a cmux rename). Sticky.
- *   2. `lastCommand`   — the live foreground command, when it is meaningful (auto-name).
- *   3. `tmuxSessionName` — the bound tmux session.
- *   4. `command`       — the spawn command (always present).
+ *   1. `name`            — explicit rename (tab pencil or hub rename). Sticky.
+ *   2. `tmuxSessionName` — the bound tmux session (shared with Session Hub).
+ *   3. `lastCommand`     — live foreground command, when meaningful and unbound.
+ *   4. `command`:`port`  — spawn fallback.
  */
-export function deriveTtydDisplayName(session: TtydSession): string {
+export function deriveTtydDisplayName(session: TtydNameSource): string {
     const manual = session.name?.trim();
 
     if (manual) {
         return manual;
     }
 
+    const tmux = session.tmuxSessionName?.trim();
+
+    if (tmux) {
+        return tmux;
+    }
+
     if (isMeaningfulCommand(session.lastCommand)) {
         return session.lastCommand.trim();
     }
 
-    return session.tmuxSessionName ?? session.command;
+    return portFallback(session);
 }
diff --git a/src/dev-dashboard/lib/ttyd/types.ts b/src/dev-dashboard/lib/ttyd/types.ts
index 3ce953c49..56f9ff902 100644
--- a/src/dev-dashboard/lib/ttyd/types.ts
+++ b/src/dev-dashboard/lib/ttyd/types.ts
@@ -6,12 +6,15 @@ export interface TtydSession {
     pid: number;
     startedAt: string;
     tmuxSessionName?: string;
-    /** User-set display name; falls back to "<command> :<port>" when unset. */
+    /**
+     * User-set display name. When set (including after a unified rename), tabs and Session Hub share
+     * this identity with `tmuxSessionName`. Falls back via {@link deriveTtydDisplayName}.
+     */
     name?: string;
     /**
      * Live command in the bound tmux session's active pane (`#{pane_current_command}`), refreshed on
-     * every `listTtyd()`. Drives an auto-name when the user has not set `name`. NOT persisted — it is
-     * a derived live fact, recomputed each read. Absent when the session has no tmux binding.
+     * every `listTtyd()`. Surfaced as secondary meta in the hub / CLI — not the primary tab label when
+     * a tmux binding exists. NOT persisted — derived live fact, recomputed each read.
      */
     lastCommand?: string;
 }
diff --git a/src/dev-dashboard/server/routes/cmux.ts b/src/dev-dashboard/server/routes/cmux.ts
index 53b151696..69902edbf 100644
--- a/src/dev-dashboard/server/routes/cmux.ts
+++ b/src/dev-dashboard/server/routes/cmux.ts
@@ -131,13 +131,13 @@ export function cmuxRoutes(): RouteDef[] {
                             title: body.title,
                         });
 
-                        // A cmux rename is an explicit user action, so it sets the ttyd MANUAL name
-                        // (same tier as the in-terminal pencil) — best-effort, never fails the rename.
+                        // One identity: cmux rename → ttyd display name + bound tmux session.
+                        // Best-effort — never fails the cmux rename itself.
                         if (ttydId) {
                             try {
                                 await renameTtyd(ttydId, body.title);
                             } catch (err) {
-                                logger.debug({ err, ttydId }, "cmux rename: ttyd display-name propagation failed");
+                                logger.debug({ err, ttydId }, "cmux rename: ttyd/tmux sync failed");
                             }
                         }
                     } else {
diff --git a/src/dev-dashboard/ui/src/components/TmuxSessionName.tsx b/src/dev-dashboard/ui/src/components/TmuxSessionName.tsx
index 24f9317da..d39b5457e 100644
--- a/src/dev-dashboard/ui/src/components/TmuxSessionName.tsx
+++ b/src/dev-dashboard/ui/src/components/TmuxSessionName.tsx
@@ -131,7 +131,8 @@ export function TmuxSessionName({ name, editable = true, size = "sm", className
                     setEditing(true);
                 }}
                 className="shrink-0 rounded-md p-1 text-[var(--dd-text-muted)] transition-colors hover:bg-white/5 hover:text-[var(--dd-accent-from)]"
-                aria-label="Rename tmux session"
+                aria-label="Rename session (tmux + ttyd)"
+                title="Renames the tmux session and the ttyd tab together"
             >
                 <Pencil size={12} />
             </button>
diff --git a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
index 39e93fa2d..77f9a14de 100644
--- a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
+++ b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
@@ -89,7 +89,8 @@ export function TmuxSessionsPanel({ open, onOpenChange, onFocusTtydTab }: Props)
                             <GlassDialogEyebrow>Session hub</GlassDialogEyebrow>
                             <GlassDialogTitle className="font-mono text-lg">Tmux sessions</GlassDialogTitle>
                             <GlassDialogDescription className="font-mono text-xs text-zinc-400">
-                                Attach in ttyd or send to cmux — shared tmux I/O across surfaces.
+                                Same names as the terminal tabs — rename once, tmux + ttyd both update. Attach in ttyd
+                                or send to cmux.
                             </GlassDialogDescription>
                         </GlassDialogHeader>
 
@@ -181,7 +182,11 @@ function SessionRow({
     onRemove?: () => void;
     onRenamed: (nextName: string) => void;
 }) {
-    const alreadyInTtyd = session.ttydTabIds.length > 0;
+    const alreadyInTtyd = (session.ttydTabs?.length ?? session.ttydTabIds.length) > 0;
+    const primaryTab = session.ttydTabs?.[0];
+    const cwd = primaryTab?.cwd;
+    const lastCommand = primaryTab?.lastCommand;
+    const shortCwd = cwd ? shortenPath(cwd) : null;
 
     return (
         <BezelCard
@@ -197,11 +202,23 @@ function SessionRow({
                     </div>
                     <p className="font-mono text-[10px] text-zinc-500">
                         {session.windows} window(s) · {session.attached} attached
-                        {alreadyInTtyd ? ` · ttyd ×${session.ttydTabIds.length}` : ""}
+                        {alreadyInTtyd
+                            ? ` · ttyd ${
+                                  (session.ttydTabs ?? []).map((t) => `:${t.port}`).join(" ") ||
+                                  `×${session.ttydTabIds.length}`
+                              }`
+                            : ""}
                         {session.inCmux && session.cmuxSurfaces.length > 0
                             ? ` · cmux ×${session.cmuxSurfaces.length}`
                             : ""}
                     </p>
+                    {shortCwd || lastCommand ? (
+                        <p className="truncate font-mono text-[10px] text-zinc-400">
+                            {lastCommand ? <span className="text-amber-400/90">{lastCommand}</span> : null}
+                            {lastCommand && shortCwd ? <span className="text-zinc-600"> · </span> : null}
+                            {shortCwd ? <span>{shortCwd}</span> : null}
+                        </p>
+                    ) : null}
                 </div>
                 <div className="flex shrink-0 flex-col gap-1.5">
                     <Button
@@ -248,3 +265,20 @@ function SessionRow({
         </BezelCard>
     );
 }
+
+function shortenPath(path: string): string {
+    const home = "/Users/";
+    if (path.startsWith(home)) {
+        const rest = path.slice(home.length);
+        const slash = rest.indexOf("/");
+        if (slash >= 0) {
+            return `~/${rest.slice(slash + 1)}`;
+        }
+    }
+
+    if (path.startsWith("/private/tmp")) {
+        return path.replace("/private/tmp", "/tmp");
+    }
+
+    return path;
+}
diff --git a/src/dev-dashboard/ui/src/components/terminal-shell/MobileTerminalShell.tsx b/src/dev-dashboard/ui/src/components/terminal-shell/MobileTerminalShell.tsx
index 00fac88bb..7d898e583 100644
--- a/src/dev-dashboard/ui/src/components/terminal-shell/MobileTerminalShell.tsx
+++ b/src/dev-dashboard/ui/src/components/terminal-shell/MobileTerminalShell.tsx
@@ -1,6 +1,6 @@
 import { Link } from "@tanstack/react-router";
 import type { ReactNode } from "react";
-import { useState } from "react";
+import { useRef, useState } from "react";
 import { NAV_ROUTES } from "@/lib/nav-routes";
 
 export interface ShellTab {
@@ -34,6 +34,7 @@ export function MobileTerminalShell(props: MobileTerminalShellProps) {
     const [overviewOpen, setOverviewOpen] = useState(false);
     const [editingId, setEditingId] = useState<string | null>(null);
     const [expandedId, setExpandedId] = useState<string | null>(null);
+    const skipBlurCommitRef = useRef(false);
 
     const renderTab = (
         tab: ShellTab,
@@ -49,13 +50,36 @@ export function MobileTerminalShell(props: MobileTerminalShellProps) {
                     onFocus={(e) => e.currentTarget.select()}
                     onKeyDown={(e) => {
                         if (e.key === "Enter") {
+                            skipBlurCommitRef.current = true;
                             onRename?.(tab.id, e.currentTarget.value);
                             setEditingId(null);
                         }
+
+                        if (e.key === "Escape") {
+                            skipBlurCommitRef.current = true;
+                            setEditingId(null);
+                        }
+                    }}
+                    onBlur={(e) => {
+                        if (skipBlurCommitRef.current) {
+                            skipBlurCommitRef.current = false;
+                            setEditingId(null);
+                            return;
+                        }
+
+                        const next = e.currentTarget.value.trim();
+
+                        // Commit on blur when the value changed — blur-cancel was dropping renames
+                        // when the user clicked away after editing.
+                        if (next.length > 0 && next !== tab.label) {
+                            onRename?.(tab.id, next);
+                        }
+
+                        setEditingId(null);
                     }}
-                    onBlur={() => setEditingId(null)}
                     className="dd-tab-edit"
                     aria-label={`rename ${tab.label}`}
+                    title="Renames the tmux session too"
                 />
             );
         }
diff --git a/src/dev-dashboard/ui/src/lib/api.ts b/src/dev-dashboard/ui/src/lib/api.ts
index 9360485f7..9a323f97c 100644
--- a/src/dev-dashboard/ui/src/lib/api.ts
+++ b/src/dev-dashboard/ui/src/lib/api.ts
@@ -26,6 +26,13 @@ export interface TmuxHubSession {
     attached: number;
     windows: number;
     ttydTabIds: string[];
+    ttydTabs: Array<{
+        id: string;
+        port: number;
+        label: string;
+        cwd?: string;
+        lastCommand?: string;
+    }>;
     canAttachInTtyd: boolean;
     cmuxSurfaces: Array<{ workspaceId: string; surfaceId: string; title: string }>;
     inCmux: boolean;
diff --git a/src/dev-dashboard/ui/src/lib/terminal-tabs.test.ts b/src/dev-dashboard/ui/src/lib/terminal-tabs.test.ts
index d00ad036e..162b66df8 100644
--- a/src/dev-dashboard/ui/src/lib/terminal-tabs.test.ts
+++ b/src/dev-dashboard/ui/src/lib/terminal-tabs.test.ts
@@ -2,26 +2,33 @@ import { describe, expect, test } from "bun:test";
 import type { TtydSession } from "@app/dev-dashboard/lib/ttyd/types";
 import { buildTtydTabs } from "./terminal-tabs";
 
-const s = (id: string, port: number, name?: string): TtydSession => ({
+const s = (id: string, port: number, overrides: Partial<TtydSession> = {}): TtydSession => ({
     id,
     port,
     command: "/bin/zsh",
     cwd: "/x",
     pid: 1,
     startedAt: "now",
-    name,
+    ...overrides,
 });
 
 describe("buildTtydTabs", () => {
-    test("maps sessions to tabs with label fallback + active flag", () => {
-        const tabs = buildTtydTabs([s("a", 50245), s("b", 50261, "deploy")], "b");
+    test("maps sessions to tabs with tmux identity + active flag", () => {
+        const tabs = buildTtydTabs(
+            [s("a", 50245, { tmuxSessionName: "dev-dashboard-aaaa1111" }), s("b", 50261, { name: "deploy" })],
+            "b"
+        );
         expect(tabs).toEqual([
-            { id: "a", label: "zsh :50245", active: false },
+            { id: "a", label: "dev-dashboard-aaaa1111", active: false },
             { id: "b", label: "deploy", active: true },
         ]);
     });
 
+    test("unbound sessions fall back to command:port", () => {
+        expect(buildTtydTabs([s("a", 50245)], null)).toEqual([{ id: "a", label: "zsh :50245", active: false }]);
+    });
+
     test("no active id → none active", () => {
-        expect(buildTtydTabs([s("a", 1)], null)[0].active).toBe(false);
+        expect(buildTtydTabs([s("a", 1, { tmuxSessionName: "x" })], null)[0].active).toBe(false);
     });
 });
diff --git a/src/dev-dashboard/ui/src/routes/ttyd.tsx b/src/dev-dashboard/ui/src/routes/ttyd.tsx
index 457860447..e625f1b51 100644
--- a/src/dev-dashboard/ui/src/routes/ttyd.tsx
+++ b/src/dev-dashboard/ui/src/routes/ttyd.tsx
@@ -37,6 +37,7 @@ import {
     scrollIframeTerminalByPage,
     sendKeyToIframe,
 } from "@/lib/iframe-keys";
+import { invalidateTmuxAndTtyd } from "@/lib/query-keys";
 import { buildTtydTabs } from "@/lib/terminal-tabs";
 import { pickTtydActiveId, TTYD_TAB_SEARCH_KEY, writeTtydActiveId } from "@/lib/view-state";
 
@@ -198,7 +199,7 @@ export function TtydRoute() {
     const renameMut = useMutation({
         mutationFn: ({ id, name }: { id: string; name: string }) => ttydApi.rename(id, name),
         onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ["ttyd", "list"] });
+            invalidateTmuxAndTtyd(queryClient);
         },
     });
 
diff --git a/src/tmux/commands/sessions-format.ts b/src/tmux/commands/sessions-format.ts
new file mode 100644
index 000000000..fcb6fb2c9
--- /dev/null
+++ b/src/tmux/commands/sessions-format.ts
@@ -0,0 +1,34 @@
+export interface TtydSessionBinding {
+    id: string;
+    port: number;
+    label: string;
+    cwd?: string;
+    lastCommand?: string;
+}
+
+/** Pure pieces of the session header line — kept separate so tests don't need picocolors. */
+export function printSessionHeaderParts(
+    _name: string,
+    _attached: boolean,
+    windowCount: number,
+    ttydTabs: TtydSessionBinding[] | undefined
+): { windows: string; ttyd: string } {
+    return {
+        windows: `${windowCount} window${windowCount === 1 ? "" : "s"}`,
+        ttyd: ttydTabs && ttydTabs.length > 0 ? ` · ttyd ${ttydTabs.map((t) => `:${t.port}`).join(" ")}` : "",
+    };
+}
+
+export function formatTtydBranchForTest(tabs: TtydSessionBinding[]): string {
+    const parts = tabs.map((t) => {
+        const bits = [`:${t.port}`, t.label];
+
+        if (t.lastCommand) {
+            bits.push(t.lastCommand);
+        }
+
+        return bits.join(" ");
+    });
+
+    return `ttyd ${parts.join(" · ")}`;
+}
diff --git a/src/tmux/commands/sessions.test.ts b/src/tmux/commands/sessions.test.ts
new file mode 100644
index 000000000..e3fed9fd6
--- /dev/null
+++ b/src/tmux/commands/sessions.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { formatTtydBranchForTest, printSessionHeaderParts } from "./sessions-format";
+
+describe("tmux sessions ttyd formatting", () => {
+    test("header parts include ttyd ports when bound", () => {
+        const parts = printSessionHeaderParts("bridge", true, 1, [
+            { id: "a", port: 60586, label: "bridge" },
+            { id: "b", port: 60587, label: "bridge-2" },
+        ]);
+        expect(parts.ttyd).toBe(" · ttyd :60586 :60587");
+        expect(parts.windows).toBe("1 window");
+    });
+
+    test("header parts omit ttyd when unbound", () => {
+        expect(printSessionHeaderParts("solo", false, 2, undefined).ttyd).toBe("");
+        expect(printSessionHeaderParts("solo", false, 2, []).ttyd).toBe("");
+    });
+
+    test("ttyd branch lists port + label", () => {
+        expect(formatTtydBranchForTest([{ id: "a", port: 1, label: "bridge", lastCommand: "claude" }])).toBe(
+            "ttyd :1 bridge claude"
+        );
+    });
+});
diff --git a/src/tmux/commands/sessions.ts b/src/tmux/commands/sessions.ts
index 8a067f6d4..5c37066cf 100644
--- a/src/tmux/commands/sessions.ts
+++ b/src/tmux/commands/sessions.ts
@@ -1,9 +1,15 @@
+import { getConfig } from "@app/dev-dashboard/config";
+import { ttydLabel } from "@app/dev-dashboard/lib/ttyd/label";
+import { isMeaningfulCommand } from "@app/dev-dashboard/lib/ttyd/naming";
 import { out } from "@genesiscz/utils/logger";
 import { renderTree, type TreeNode } from "@genesiscz/utils/prompts/p/tree";
 import { listTmuxSessions } from "@genesiscz/utils/tmux/sessions";
-import { captureTmuxSnapshot, type TmuxSessionSnapshot } from "@genesiscz/utils/tmux/snapshot";
+import { captureTmuxSnapshot, type TmuxPaneSnapshot, type TmuxSessionSnapshot } from "@genesiscz/utils/tmux/snapshot";
 import type { Command } from "commander";
 import pc from "picocolors";
+import { printSessionHeaderParts, type TtydSessionBinding } from "./sessions-format";
+
+export type { TtydSessionBinding } from "./sessions-format";
 
 interface ListFlags {
     json?: boolean;
@@ -11,6 +17,47 @@ interface ListFlags {
     prefix?: string;
 }
 
+/** Persisted ttyd registry bindings keyed by tmux session name (no process heal). */
+export async function loadTtydBindingsByTmux(): Promise<Map<string, TtydSessionBinding[]>> {
+    const map = new Map<string, TtydSessionBinding[]>();
+
+    try {
+        const config = await getConfig();
+
+        for (const session of config.ttydSessions) {
+            if (!session.tmuxSessionName) {
+                continue;
+            }
+
+            // Skip stale registry rows whose ttyd process is gone (config lags until the
+            // dashboard heals). `kill -0` is a pure existence probe.
+            if (typeof session.pid === "number" && session.pid > 0) {
+                const alive = Bun.spawnSync(["kill", "-0", String(session.pid)], {
+                    stdio: ["ignore", "ignore", "ignore"],
+                });
+
+                if (alive.exitCode !== 0) {
+                    continue;
+                }
+            }
+
+            const binding: TtydSessionBinding = {
+                id: session.id,
+                port: session.port,
+                label: ttydLabel(session),
+                cwd: session.cwd,
+            };
+            const existing = map.get(session.tmuxSessionName) ?? [];
+            existing.push(binding);
+            map.set(session.tmuxSessionName, existing);
+        }
+    } catch {
+        // Dashboard config missing or unreadable — CLI still lists bare tmux sessions.
+    }
+
+    return map;
+}
+
 export function registerSessionsCommand(program: Command): void {
     program
         .command("sessions")
@@ -19,12 +66,14 @@ export function registerSessionsCommand(program: Command): void {
         .option("--detailed", "Include per-pane cwd / current command (default: true)", true)
         .option("--no-detailed", "Skip per-pane detail (faster)")
         .option("--prefix <str>", "Only sessions whose name starts with this prefix")
-        .action((flags: ListFlags) => {
-            runList(flags);
+        .action(async (flags: ListFlags) => {
+            await runList(flags);
         });
 }
 
-export function runList(flags: ListFlags): void {
+export async function runList(flags: ListFlags): Promise<void> {
+    const ttydByTmux = await loadTtydBindingsByTmux();
+
     if (flags.detailed) {
         const snapshot = captureTmuxSnapshot({ prefix: flags.prefix });
 
@@ -33,6 +82,7 @@ export function runList(flags: ListFlags): void {
         if (flags.json) {
             const enriched = snapshot.map((s) => ({
                 ...s,
+                ttyd: ttydByTmux.get(s.name) ?? [],
                 windows: s.windows.map((w) => ({
                     ...w,
                     panes: w.panes.map((p) => ({
@@ -51,36 +101,31 @@ export function runList(flags: ListFlags): void {
         }
 
         for (const session of snapshot) {
-            const attach = session.attached ? pc.green("attached") : pc.dim("detached");
-            out.println(`${pc.cyan(session.name)} ${pc.dim(`(${attach}, ${session.windows.length} window(s))`)}`);
+            printSessionHeader(session.name, session.attached, session.windows.length, ttydByTmux.get(session.name));
+
+            const windowNodes: TreeNode[] = [];
+            const ttydTabs = ttydByTmux.get(session.name);
+
+            if (ttydTabs && ttydTabs.length > 0) {
+                windowNodes.push({
+                    text: formatTtydBranch(ttydTabs),
+                });
+            }
 
-            const windowNodes: TreeNode[] = session.windows.map((window) => {
+            for (const window of session.windows) {
                 const wname = window.name ? ` ${pc.dim(window.name)}` : "";
 
                 const paneNodes: TreeNode[] = window.panes.map((pane) => {
                     const cmd = pane.currentCommand ?? "?";
-                    const details: TreeNode[] = [];
 
-                    if (pane.cwd) {
-                        const branch = branches.get(pane.cwd);
-                        const branchStr = branch ? ` ${pc.magenta(branch)}` : "";
-                        details.push({ text: `${pc.dim("cwd:")} ${pane.cwd}${branchStr}` });
-                    }
-
-                    if (pane.launchCommand) {
-                        details.push({ text: `${pc.dim("cmd:")} ${pc.green(pane.launchCommand)}` });
-                    }
-
-                    if (pane.lastShellCommand) {
-                        const lines = pane.lastShellCommand.split("\n");
-                        details.push({ text: pc.dim(`› ${lines.join(" ")}`) });
-                    }
-
-                    return { text: `pane ${pane.index} ${pc.yellow(cmd)}`, children: details };
+                    return {
+                        text: `pane ${pane.index} ${pc.yellow(cmd)}`,
+                        children: buildPaneDetailNodes(pane, branches),
+                    };
                 });
 
-                return { text: `window ${window.index}${wname}`, children: paneNodes };
-            });
+                windowNodes.push({ text: `window ${window.index}${wname}`, children: paneNodes });
+            }
 
             for (const line of renderTree(windowNodes)) {
                 out.println(line);
@@ -90,10 +135,15 @@ export function runList(flags: ListFlags): void {
         return;
     }
 
-    const sessions = listTmuxSessions().filter((s) => (flags.prefix ? s.name.startsWith(flags.prefix) : true));
+    const sessions = (await listTmuxSessions()).filter((s) => (flags.prefix ? s.name.startsWith(flags.prefix) : true));
 
     if (flags.json) {
-        out.result(sessions);
+        out.result(
+            sessions.map((s) => ({
+                ...s,
+                ttyd: ttydByTmux.get(s.name) ?? [],
+            }))
+        );
         return;
     }
 
@@ -103,11 +153,78 @@ export function runList(flags: ListFlags): void {
     }
 
     for (const session of sessions) {
-        const attach = session.attached > 0 ? pc.green("attached") : pc.dim("detached");
-        out.println(
-            `${pc.cyan(session.name)} ${pc.dim(`(${attach}, ${session.windows} window${session.windows === 1 ? "" : "s"})`)}`
-        );
+        printSessionHeader(session.name, session.attached > 0, session.windows, ttydByTmux.get(session.name));
+    }
+}
+
+function printSessionHeader(
+    name: string,
+    attached: boolean,
+    windowCount: number,
+    ttydTabs: TtydSessionBinding[] | undefined
+): void {
+    const attach = attached ? pc.green("attached") : pc.dim("detached");
+    const { windows, ttyd } = printSessionHeaderParts(name, attached, windowCount, ttydTabs);
+    out.println(
+        `${pc.cyan(name)} ${pc.dim("(")}${attach}${pc.dim(`, ${windows}`)}${ttyd ? pc.cyan(ttyd) : ""}${pc.dim(")")}`
+    );
+}
+
+function formatTtydBranch(tabs: TtydSessionBinding[]): string {
+    const parts = tabs.map((t) => {
+        const bits = [`:${t.port}`, pc.white(t.label)];
+
+        if (t.lastCommand) {
+            bits.push(pc.yellow(t.lastCommand));
+        }
+
+        return bits.join(" ");
+    });
+
+    return `${pc.cyan("ttyd")} ${parts.join(pc.dim(" · "))}`;
+}
+
+function buildPaneDetailNodes(
+    pane: TmuxPaneSnapshot | undefined,
+    branches: Map<string, string>
+): TreeNode[] | undefined {
+    if (!pane) {
+        return undefined;
     }
+
+    const details: TreeNode[] = [];
+
+    if (pane.cwd) {
+        const branch = branches.get(pane.cwd);
+        const branchStr = branch ? ` ${pc.magenta(branch)}` : "";
+        details.push({ text: `${pc.dim("cwd:")} ${pane.cwd}${branchStr}` });
+    }
+
+    if (pane.launchCommand && isMeaningfulCommand(commandBasename(pane.launchCommand))) {
+        details.push({ text: `${pc.dim("cmd:")} ${pc.green(pane.launchCommand)}` });
+    } else if (isMeaningfulCommand(pane.currentCommand)) {
+        details.push({ text: `${pc.dim("cmd:")} ${pc.yellow(pane.currentCommand)}` });
+    }
+
+    if (pane.lastShellCommand) {
+        const line = pane.lastShellCommand.split("\n").join(" ").trim();
+        const foreground = (pane.currentCommand ?? "").trim().toLowerCase();
+        const launch = pane.launchCommand ?? "";
+        const tuiForeground = new Set(["claude", "claude-code", "vim", "nvim", "less", "htop", "nano"]);
+        const agentLaunch = /\b(claude|claude-code|tools\s+cc)\b/i.test(launch);
+
+        // TUIs / agent launchers own the screen — scrollback "prompt" hits are chrome.
+        if (line.length > 0 && !tuiForeground.has(foreground) && !agentLaunch) {
+            details.push({ text: `${pc.dim("last:")} ${line}` });
+        }
+    }
+
+    return details.length > 0 ? details : undefined;
+}
+
+function commandBasename(command: string): string {
+    const first = command.trim().split(/\s+/)[0] ?? "";
+    return first.split("/").pop() ?? first;
 }
 
 function resolveGitBranches(sessions: TmuxSessionSnapshot[]): Map<string, string> {

From b81c056a021ec98ed64dc15007f1cdf241acb405 Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 01:21:59 +0200
Subject: [PATCH 2/6] fix(update): keep the directory marketplace (add only
 when missing), refresh catalog before install, always run plugin update

---
 src/update/index.ts | 155 ++++++++++++++++++++++++++++++--------------
 1 file changed, 106 insertions(+), 49 deletions(-)

diff --git a/src/update/index.ts b/src/update/index.ts
index 791d83c7b..33d808da2 100644
--- a/src/update/index.ts
+++ b/src/update/index.ts
@@ -5,10 +5,61 @@ import * as p from "@clack/prompts";
 import { getAgentRuntimeContext } from "@genesiscz/utils/agent-runtime";
 import { runTool } from "@genesiscz/utils/cli";
 import { env } from "@genesiscz/utils/env";
-import { out } from "@genesiscz/utils/logger";
+import { SafeJSON } from "@genesiscz/utils/json";
+import { logger, out } from "@genesiscz/utils/logger";
 import { Command } from "commander";
 import pc from "picocolors";
 
+const MARKETPLACE_NAME = "genesis-tools";
+/** Only used when this process cannot find a real checkout to point the marketplace at. */
+const MARKETPLACE_FALLBACK_SOURCE = "https://github.com/genesiscz/GenesisTools";
+const PLUGIN_REF = "genesis-tools@genesis-tools";
+
+interface MarketplaceEntry {
+    name?: string;
+    /** "directory" | "git" | "github" */
+    source?: string;
+    /** Present for directory sources. */
+    path?: string;
+}
+
+async function runClaude(args: string[]): Promise<number> {
+    return Bun.spawn(["claude", ...args], { stdio: ["inherit", "inherit", "inherit"] }).exited;
+}
+
+/** Run a `claude … --json` query and parse it; null on non-zero exit or unparseable output. */
+async function claudeJson<T>(args: string[]): Promise<T | null> {
+    const proc = Bun.spawn(["claude", ...args], { stdio: ["ignore", "pipe", "ignore"] });
+    const stdout = await new Response(proc.stdout).text();
+
+    if ((await proc.exited) !== 0) {
+        return null;
+    }
+
+    try {
+        return SafeJSON.parse(stdout) as T;
+    } catch (err) {
+        logger.debug({ err, args }, "update: could not parse claude CLI --json output");
+        return null;
+    }
+}
+
+async function findMarketplace(name: string): Promise<MarketplaceEntry | null> {
+    const entries = await claudeJson<MarketplaceEntry[]>(["plugin", "marketplace", "list", "--json"]);
+
+    if (!Array.isArray(entries)) {
+        return null;
+    }
+
+    return entries.find((entry) => entry.name === name) ?? null;
+}
+
+async function pluginIsInstalled(id: string): Promise<boolean> {
+    const entries = await claudeJson<Array<{ id?: string }>>(["plugin", "list", "--json"]);
+
+    return Array.isArray(entries) && entries.some((entry) => entry.id === id);
+}
+
 const program = new Command()
     .name("update")
     .description("Update GenesisTools to the latest version")
@@ -67,60 +118,66 @@ const program = new Command()
             process.exit(0);
         }
         if (runClaudeUpdates) {
-            if (inClaudeCode) {
-                out.println(pc.dim("\n  Adding marketplace (if needed)..."));
-                await Bun.spawn(
-                    ["claude", "plugin", "marketplace", "add", "https://github.com/genesiscz/GenesisTools"],
-                    {
-                        stdio: ["inherit", "inherit", "inherit"],
-                    }
-                ).exited;
-
-                out.println(pc.dim("\n  Installing plugin (if needed)..."));
-                const pluginInstallCode = await Bun.spawn(
-                    ["claude", "plugin", "install", "genesis-tools@genesis-tools"],
-                    {
-                        stdio: ["inherit", "inherit", "inherit"],
-                    }
-                ).exited;
-                if (pluginInstallCode !== 0) {
-                    out.println(pc.yellow("  Plugin install had issues (may already be installed)"));
-                }
+            // This checkout IS the marketplace — step 1 just pulled it. Registering the GitHub
+            // URL instead makes Claude Code clone a SECOND copy into
+            // ~/.claude/plugins/marketplaces/genesis-tools and read the plugin from there, so
+            // edits in this repo stop taking effect until they are committed AND pushed.
+            const checkout = resolve(genesisPath);
+            const isCheckout = existsSync(join(checkout, ".claude-plugin", "marketplace.json"));
+            const existing = await findMarketplace(MARKETPLACE_NAME);
+            const pointsAtCheckout =
+                existing?.source === "directory" && existing.path !== undefined && resolve(existing.path) === checkout;
 
-                out.println(pc.dim("\n  Updating Claude Code plugin..."));
-                const pluginUpdateCode = await Bun.spawn(
-                    ["claude", "plugin", "update", "genesis-tools@genesis-tools"],
-                    {
-                        stdio: ["inherit", "inherit", "inherit"],
-                    }
-                ).exited;
-                if (pluginUpdateCode !== 0) {
-                    out.println(pc.yellow("  Plugin update had issues"));
-                }
+            // True when we re-source an ALREADY-registered marketplace (the git-clone → this-repo
+            // flip), as opposed to registering it for the first time.
+            let repointed = false;
+
+            if (isCheckout && !pointsAtCheckout) {
+                // `marketplace add` OVERWRITES an existing registration's source rather than
+                // refusing, so this one command covers both first registration and the flip.
+                out.println(
+                    pc.dim(existing ? `\n  Re-pointing marketplace at ${checkout}...` : "\n  Adding marketplace...")
+                );
+                await runClaude(["plugin", "marketplace", "add", checkout]);
+                repointed = existing !== null;
+            } else if (!isCheckout && !existing) {
+                out.println(pc.yellow(`\n  ${checkout} is not a GenesisTools checkout; using the GitHub marketplace.`));
+                await runClaude(["plugin", "marketplace", "add", MARKETPLACE_FALLBACK_SOURCE]);
             } else {
-                out.println(pc.dim("\n  Updating Claude Code marketplace..."));
-                await Bun.spawn(["claude", "plugin", "marketplace", "update"], {
-                    stdio: ["inherit", "inherit", "inherit"],
-                }).exited;
-
-                out.println(pc.dim("\n  Adding marketplace..."));
-                await Bun.spawn(
-                    ["claude", "plugin", "marketplace", "add", "https://github.com/genesiscz/GenesisTools"],
-                    {
-                        stdio: ["inherit", "inherit", "inherit"],
-                    }
-                ).exited;
+                out.println(pc.dim("\n  Refreshing marketplace..."));
+            }
 
+            // Claude Code caches each marketplace's PARSED plugin catalog; even a directory
+            // source is not re-read on its own. Skipping this is what makes the next step fail
+            // with `Plugin "genesis-tools" not found in marketplace "genesis-tools"`.
+            await runClaude(["plugin", "marketplace", "update", MARKETPLACE_NAME]);
+
+            if (!(await pluginIsInstalled(PLUGIN_REF))) {
                 out.println(pc.dim("\n  Installing plugin..."));
-                const pluginInstallCode = await Bun.spawn(
-                    ["claude", "plugin", "install", "genesis-tools@genesis-tools"],
-                    {
-                        stdio: ["inherit", "inherit", "inherit"],
-                    }
-                ).exited;
-                if (pluginInstallCode !== 0) {
+
+                if ((await runClaude(["plugin", "install", PLUGIN_REF])) !== 0) {
                     out.println(pc.yellow("  Plugin install had issues"));
                 }
+            } else if (repointed) {
+                // The installed copy was taken from the OLD source, and the plugin cache is keyed
+                // by version — so `plugin update` is a no-op whenever the version is unchanged and
+                // the stale copy would survive the flip. Reinstall to re-copy from this checkout.
+                out.println(pc.dim("\n  Reinstalling plugin from this checkout..."));
+                await runClaude(["plugin", "uninstall", PLUGIN_REF, "--keep-data", "-y"]);
+
+                if ((await runClaude(["plugin", "install", PLUGIN_REF])) !== 0) {
+                    out.println(pc.yellow("  Plugin reinstall had issues"));
+                }
+            } else {
+                out.println(pc.dim("\n  Updating Claude Code plugin..."));
+
+                if ((await runClaude(["plugin", "update", PLUGIN_REF])) !== 0) {
+                    out.println(pc.yellow("  Plugin update had issues"));
+                }
+            }
+
+            if (inClaudeCode) {
+                out.println(pc.dim("\n  Restart Claude Code to apply the new plugin version."));
             }
         }
 

From e6445dc1fc0c1afc94e47b5c2721a931580ad851 Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 01:22:07 +0200
Subject: [PATCH 3/6] perf(tmux,dev-dashboard): async tmux core with batched
 round-trips, unblock the server event loop, seed profiling

---
 src/dev-dashboard/lib/tmux/create-session.ts  |  10 +-
 src/dev-dashboard/lib/tmux/presets.ts         |   4 +-
 src/dev-dashboard/lib/tmux/rename.ts          |  10 +-
 src/dev-dashboard/lib/ttyd/manager.test.ts    |  37 ++-
 src/dev-dashboard/lib/ttyd/manager.ts         | 296 ++++++++++++-----
 .../server/adapters/bun-serve.ts              |   9 +-
 .../server/adapters/node-connect.ts           |   8 +-
 .../server/routes/tmux-presets.ts             |   2 +-
 src/dev-dashboard/server/routes/tmux.ts       |  17 +-
 src/tmux/commands/create.ts                   |   6 +-
 src/tmux/commands/presets/restore.ts          |   4 +-
 src/tmux/commands/session.ts                  |   4 +-
 src/utils/cmux/send-tmux.ts                   |   2 +-
 src/utils/tmux/reset.ts                       |  12 +-
 src/utils/tmux/sessions.test.ts               |  74 +++--
 src/utils/tmux/sessions.ts                    | 310 ++++++++++++------
 src/utils/tmux/snapshot-last-cmd.test.ts      |  28 ++
 src/utils/tmux/snapshot.ts                    | 112 ++++++-
 18 files changed, 695 insertions(+), 250 deletions(-)
 create mode 100644 src/utils/tmux/snapshot-last-cmd.test.ts

diff --git a/src/dev-dashboard/lib/tmux/create-session.ts b/src/dev-dashboard/lib/tmux/create-session.ts
index 55a33b232..39e1fd3c3 100644
--- a/src/dev-dashboard/lib/tmux/create-session.ts
+++ b/src/dev-dashboard/lib/tmux/create-session.ts
@@ -2,20 +2,22 @@ import { env } from "@genesiscz/utils/env";
 import { makeStandaloneTmuxSessionName } from "@genesiscz/utils/tmux/naming";
 import { createTmuxSession, sessionExists } from "@genesiscz/utils/tmux/sessions";
 
-export function createStandaloneTmuxSession(opts: { name?: string; cwd?: string; command?: string } = {}): {
+export async function createStandaloneTmuxSession(
+    opts: { name?: string; cwd?: string; command?: string } = {}
+): Promise<{
     sessionName: string;
     cwd: string;
     command: string;
-} {
+}> {
     const sessionName = opts.name?.trim() || makeStandaloneTmuxSessionName();
     const cwd = opts.cwd ?? process.cwd();
     const command = opts.command ?? env.paths.getShell("/bin/zsh");
 
-    if (sessionExists(sessionName)) {
+    if (await sessionExists(sessionName)) {
         throw new Error(`tmux session ${sessionName} already exists`);
     }
 
-    createTmuxSession(sessionName, cwd, command);
+    await createTmuxSession(sessionName, cwd, command);
 
     return { sessionName, cwd, command };
 }
diff --git a/src/dev-dashboard/lib/tmux/presets.ts b/src/dev-dashboard/lib/tmux/presets.ts
index 6fe0f1455..01679e5e8 100644
--- a/src/dev-dashboard/lib/tmux/presets.ts
+++ b/src/dev-dashboard/lib/tmux/presets.ts
@@ -71,7 +71,7 @@ export function savePreset(input: SavePresetInput, store?: TmuxPresetStore): Tmu
     return s.summarize(preset);
 }
 
-export function restorePreset(name: string, store?: TmuxPresetStore): RestorePresetResult {
+export async function restorePreset(name: string, store?: TmuxPresetStore): Promise<RestorePresetResult> {
     const s = resolveStore(store);
     const preset = s.read(name);
 
@@ -82,7 +82,7 @@ export function restorePreset(name: string, store?: TmuxPresetStore): RestorePre
 
     for (const session of preset.sessions) {
         try {
-            const outcome = restoreTmuxSession(session);
+            const outcome = await restoreTmuxSession(session);
             outcomes.push(outcome);
 
             if (outcome.created) {
diff --git a/src/dev-dashboard/lib/tmux/rename.ts b/src/dev-dashboard/lib/tmux/rename.ts
index e9f1132ae..964b47bf0 100644
--- a/src/dev-dashboard/lib/tmux/rename.ts
+++ b/src/dev-dashboard/lib/tmux/rename.ts
@@ -1,6 +1,11 @@
-import { retargetTtydTmuxBindings } from "@app/dev-dashboard/lib/ttyd/manager";
+import { retargetTtydTmuxBindings, syncTtydDisplayNamesForTmux } from "@app/dev-dashboard/lib/ttyd/manager";
 import { renameTmuxSession } from "@genesiscz/utils/tmux/sessions";
 
+/**
+ * Rename a live tmux session and keep every dashboard surface in sync:
+ * relaunch bound ttyd processes so `attach-session -t` tracks the new name, and
+ * mirror the name onto ttyd display labels so tabs match Session Hub.
+ */
 export async function renameTmuxSessionInHub(fromName: string, toName: string): Promise<string> {
     const trimmed = toName.trim();
 
@@ -8,8 +13,9 @@ export async function renameTmuxSessionInHub(fromName: string, toName: string):
         throw new Error("Destination tmux session name cannot be empty.");
     }
 
-    renameTmuxSession(fromName, trimmed);
+    await renameTmuxSession(fromName, trimmed);
     await retargetTtydTmuxBindings(fromName, trimmed);
+    await syncTtydDisplayNamesForTmux(trimmed, trimmed);
 
     return trimmed;
 }
diff --git a/src/dev-dashboard/lib/ttyd/manager.test.ts b/src/dev-dashboard/lib/ttyd/manager.test.ts
index a522e8ed3..267dabdc2 100644
--- a/src/dev-dashboard/lib/ttyd/manager.test.ts
+++ b/src/dev-dashboard/lib/ttyd/manager.test.ts
@@ -90,7 +90,7 @@ describe.skipIf(!hasTtydDeps)("ttyd manager", () => {
         expect(fromName).toBeTruthy();
 
         const toName = `retarget-test-${session.id.slice(0, 8)}`;
-        renameTmuxSession(fromName!, toName);
+        await renameTmuxSession(fromName!, toName);
 
         await retargetTtydTmuxBindings(fromName!, toName);
 
@@ -98,8 +98,8 @@ describe.skipIf(!hasTtydDeps)("ttyd manager", () => {
         expect(listed?.tmuxSessionName).toBe(toName);
         expect(listed?.port).toBe(session.port);
         expect(listed?.id).toBe(session.id);
-        expect(sessionExists(toName)).toBe(true);
-        expect(sessionExists(fromName!)).toBe(false);
+        expect(await sessionExists(toName)).toBe(true);
+        expect(await sessionExists(fromName!)).toBe(false);
 
         // Live process must attach to the NEW name (this is the bug: config-only retarget).
         const ps = Bun.spawnSync(["/bin/ps", "-p", String(listed!.pid), "-o", "command="], {
@@ -110,6 +110,23 @@ describe.skipIf(!hasTtydDeps)("ttyd manager", () => {
         expect(cmd).toContain(`-t ${toName}`);
         expect(cmd).not.toContain(`-t ${fromName}`);
     });
+
+    test("renameTtyd renames the bound tmux session and mirrors the display name", async () => {
+        const { renameTtyd } = await import("./manager");
+        const session = await spawnTtyd({ command: "/bin/sh", cwd: process.cwd() });
+        const fromName = session.tmuxSessionName;
+        expect(fromName).toBeTruthy();
+
+        const toName = `tab-rename-${session.id.slice(0, 8)}`;
+        const ok = await renameTtyd(session.id, toName);
+        expect(ok).toBe(true);
+
+        const listed = (await listTtyd()).find((s) => s.id === session.id);
+        expect(listed?.name).toBe(toName);
+        expect(listed?.tmuxSessionName).toBe(toName);
+        expect(await sessionExists(toName)).toBe(true);
+        expect(await sessionExists(fromName!)).toBe(false);
+    });
 });
 
 describe.skipIf(!hasTtydDeps)("spawnTtyd persist-failure cleanup", () => {
@@ -162,16 +179,22 @@ const labelBase: TtydSession = {
 };
 
 describe("ttydLabel", () => {
-    test("falls back to '<cmd-basename> :<port>' when no name", () => {
+    test("falls back to tmux session name when bound", () => {
+        expect(ttydLabel({ ...labelBase, tmuxSessionName: "dev-dashboard-abc12345" })).toBe("dev-dashboard-abc12345");
+    });
+
+    test("falls back to '<cmd-basename> :<port>' when unbound", () => {
         expect(ttydLabel(labelBase)).toBe("zsh :50245");
     });
 
     test("uses the custom name when set", () => {
-        expect(ttydLabel({ ...labelBase, name: "deploy-watch" })).toBe("deploy-watch");
+        expect(ttydLabel({ ...labelBase, name: "deploy-watch", tmuxSessionName: "dev-dashboard-x" })).toBe(
+            "deploy-watch"
+        );
     });
 
-    test("blank name falls back", () => {
-        expect(ttydLabel({ ...labelBase, name: "  " })).toBe("zsh :50245");
+    test("blank name falls back to tmux when bound", () => {
+        expect(ttydLabel({ ...labelBase, name: "  ", tmuxSessionName: "bridge" })).toBe("bridge");
     });
 });
 
diff --git a/src/dev-dashboard/lib/ttyd/manager.ts b/src/dev-dashboard/lib/ttyd/manager.ts
index 4cd27db7d..a37c877e4 100644
--- a/src/dev-dashboard/lib/ttyd/manager.ts
+++ b/src/dev-dashboard/lib/ttyd/manager.ts
@@ -1,12 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { getConfig, saveTtydSessions } from "@app/dev-dashboard/config";
+import { isClaudeForegroundCommand, parseClaudePaneTitle } from "@app/dev-dashboard/lib/tmux/claude-pane-title";
 import { makeTtydTmuxSessionName } from "@app/dev-dashboard/lib/tmux/naming";
 import type { TtydSession } from "@app/dev-dashboard/lib/ttyd/types";
 import { env } from "@genesiscz/utils/env";
 import { logger } from "@genesiscz/utils/logger";
 import { findFreePort } from "@genesiscz/utils/net/free-port";
 import { killWithEscalation } from "@genesiscz/utils/process/killWithEscalation";
+import { profiler } from "@genesiscz/utils/profile";
 import { buildTerminalSpawnEnv } from "@genesiscz/utils/terminal/locale";
 import { resolveTmuxBin } from "@genesiscz/utils/tmux/bin";
 import {
@@ -14,7 +16,8 @@ import {
     ensureTmuxServerPersists,
     ensureTmuxSessionEnvironment,
     killTmuxSession,
-    listTmuxSessionCommands,
+    listTmuxSessionActivePanes,
+    renameTmuxSession,
     sessionExists,
 } from "@genesiscz/utils/tmux/sessions";
 import type { Subprocess } from "bun";
@@ -42,6 +45,12 @@ const registry = new Map<string, Tracked>();
 const TTYD_BIN = "/opt/homebrew/bin/ttyd";
 let hydrated = false;
 
+// `listTtyd` is polled by several routes every few seconds and `spawnTtyd` sits on the
+// interactive "new terminal" path, so both are worth breaking into phases: a slow request
+// here is always one phase, never the whole function.
+//   PROFILE=ttyd,tmux tools dev-dashboard …
+const prof = profiler.scope("ttyd");
+
 function tmuxAlreadyOpenInTtyd(tmuxSessionName: string): boolean {
     for (const tracked of registry.values()) {
         if (tracked.session.tmuxSessionName === tmuxSessionName) {
@@ -57,20 +66,6 @@ function tmuxAlreadyOpenInTtyd(tmuxSessionName: string): boolean {
  * unrelated process that reused the PID. ttyd is spawned with a unique
  * `-b /ttyd/<id>` base path, so its argv carries the session id as a marker.
  */
-function processMatchesSession(session: TtydSession): boolean {
-    const result = Bun.spawnSync(["/bin/ps", "-p", String(session.pid), "-o", "command="], {
-        stdio: ["ignore", "pipe", "ignore"],
-    });
-
-    if (result.exitCode !== 0) {
-        return false;
-    }
-
-    const cmd = result.stdout.toString().trim();
-
-    return cmd.includes("ttyd") && cmd.includes(`/ttyd/${session.id}`);
-}
-
 async function processMatchesSessionAsync(session: TtydSession): Promise<boolean> {
     const proc = Bun.spawn(["/bin/ps", "-p", String(session.pid), "-o", "command="], {
         stdio: ["ignore", "pipe", "ignore"],
@@ -126,9 +121,11 @@ async function persistRegistry(): Promise<void> {
     }
 
     const all = Array.from(registry.values()).map((tracked) => tracked.session);
-    const alive = await isSessionAliveBatch(all);
+    const alive = await prof.measureAsync("persist.aliveBatch", () => isSessionAliveBatch(all));
     const sessions = all.filter((session) => alive.get(session.id) === true);
-    await saveTtydSessions(sessions);
+    // Re-reads the whole config off disk before writing it back; called once per spawn/kill
+    // AND once per renamed session inside the list hot path.
+    await prof.measureAsync("persist.saveConfig", () => saveTtydSessions(sessions));
 }
 
 async function hydrateRegistry(): Promise<void> {
@@ -195,7 +192,7 @@ async function stopTtydProcess(tracked: Tracked, id: string): Promise<void> {
         return;
     }
 
-    if (!processMatchesSession(tracked.session)) {
+    if (!(await processMatchesSessionAsync(tracked.session))) {
         logger.debug({ id, pid: tracked.session.pid }, "ttyd pid no longer ours; skipping kill");
         return;
     }
@@ -212,31 +209,31 @@ async function stopTtydProcess(tracked: Tracked, id: string): Promise<void> {
                     return;
                 }
 
-                const poll = (): void => {
+                const poll = async (): Promise<void> => {
                     try {
                         process.kill(pid, 0);
 
                         // A live PID isn't necessarily still ttyd — the OS can reuse a PID
                         // within the escalation grace window. Confirm ownership before
                         // continuing to treat it as the process we're waiting to exit.
-                        if (!processMatchesSession(tracked.session)) {
+                        if (!(await processMatchesSessionAsync(tracked.session))) {
                             listener();
                             return;
                         }
 
-                        setTimeout(poll, 200);
+                        setTimeout(() => void poll(), 200);
                     } catch (err) {
                         // ESRCH means the process is actually gone; anything else (e.g. EPERM,
                         // pid reused by a process we can't signal) means it's still alive.
                         if (err && typeof err === "object" && "code" in err && err.code === "ESRCH") {
                             listener();
                         } else {
-                            setTimeout(poll, 200);
+                            setTimeout(() => void poll(), 200);
                         }
                     }
                 };
 
-                poll();
+                void poll();
             },
         });
     } catch (err) {
@@ -244,28 +241,6 @@ async function stopTtydProcess(tracked: Tracked, id: string): Promise<void> {
     }
 }
 
-/**
- * ttyd's attach target is baked into argv at spawn (`tmux attach-session -t NAME`).
- * Renaming the tmux session (or only updating config.tmuxSessionName) leaves a live
- * ttyd forever trying the old name → "can't find session" + "Reconnecting…".
- * True when the live process cmdline still contains the expected session name.
- */
-function ttydProcessTargetsTmux(session: TtydSession, tmuxSessionName: string): boolean {
-    if (session.pid <= 0) {
-        return false;
-    }
-
-    const result = Bun.spawnSync(["/bin/ps", "-p", String(session.pid), "-o", "command="], {
-        stdio: ["ignore", "pipe", "ignore"],
-    });
-
-    if (result.exitCode !== 0) {
-        return false;
-    }
-
-    return argvTargetsTmux(result.stdout.toString(), tmuxSessionName);
-}
-
 /**
  * Match the attach target specifically — the base path also contains the ttyd
  * uuid which can look like a session fragment.
@@ -294,10 +269,10 @@ export function argvTargetsTmux(cmd: string, tmuxSessionName: string): boolean {
 }
 
 /**
- * Async sibling of ttydProcessTargetsTmux — the heal sweep runs one of these per
- * live session on `listTtyd()`, and listTtyd is polled by several routes. Serial
- * `Bun.spawnSync("/bin/ps")` there re-introduced exactly the blocking hot path
- * `isSessionAliveBatch` was written to remove (10.4ms serial vs 2.6ms parallel, n=11).
+ * ttyd's attach target is baked into argv at spawn (`tmux attach-session -t NAME`).
+ * Renaming the tmux session (or only updating config.tmuxSessionName) leaves a live
+ * ttyd forever trying the old name → "can't find session" + "Reconnecting…".
+ * True when the live process cmdline still contains the expected session name.
  */
 async function ttydProcessTargetsTmuxAsync(session: TtydSession, tmuxSessionName: string): Promise<boolean> {
     if (session.pid <= 0) {
@@ -455,27 +430,31 @@ async function waitForTtydListening(child: TtydChild, port: number): Promise<voi
  * across renames.
  */
 async function relaunchTtydAtTmux(tracked: Tracked, tmuxSessionName: string): Promise<void> {
+    // Split lock-wait from the work: queueing behind another caller's kill+relaunch is
+    // indistinguishable from a slow relaunch when only the route is timed.
+    const endLockWait = prof.start("relaunch.lockWait");
+
     return withTtydLifecycleLock(async () => {
+        endLockWait();
         const prev = tracked.session;
 
-        if (!sessionExists(tmuxSessionName)) {
+        if (!(await sessionExists(tmuxSessionName))) {
             throw new Error(`tmux session ${tmuxSessionName} does not exist`);
         }
 
         // A concurrent caller (heal + retarget, or two polling routes) may have
         // relaunched this session at the same target while we waited for the lock.
         // Replacing a healthy child would drop live websockets for nothing.
-        if (ttydProcessTargetsTmux(prev, tmuxSessionName)) {
+        if (await ttydProcessTargetsTmuxAsync(prev, tmuxSessionName)) {
             tracked.session = { ...prev, tmuxSessionName };
             registry.set(prev.id, tracked);
             logger.debug({ id: prev.id, tmuxSessionName }, "ttyd already targets this tmux session; skipping relaunch");
             return;
         }
 
-        ensureTmuxSessionEnvironment(tmuxSessionName);
-        ensureTmuxServerPersists();
+        await Promise.all([ensureTmuxSessionEnvironment(tmuxSessionName), ensureTmuxServerPersists()]);
 
-        await stopTtydProcess(tracked, prev.id);
+        await prof.measureAsync("relaunch.stopProcess", () => stopTtydProcess(tracked, prev.id));
 
         // Port may still be draining for a tick after kill; retry bind briefly.
         let lastErr: unknown;
@@ -497,7 +476,11 @@ async function relaunchTtydAtTmux(tracked: Tracked, tmuxSessionName: string): Pr
                 // that failure surfaces asynchronously, so without this probe the
                 // retry loop never retries and callers see a "successful" retarget
                 // pointing at a dead endpoint.
-                await waitForTtydListening(launched.child, prev.port);
+                //
+                // Worst case here is 8 attempts × TTYD_LISTEN_TIMEOUT_MS plus backoff, so a
+                // per-attempt timer is the difference between "ttyd is slow" and "attempt 6".
+                const spawnedChild = launched.child;
+                await prof.measureAsync("relaunch.waitListening", () => waitForTtydListening(spawnedChild, prev.port));
 
                 tracked.session = launched.session;
                 tracked.child = launched.child;
@@ -521,7 +504,7 @@ async function relaunchTtydAtTmux(tracked: Tracked, tmuxSessionName: string): Pr
 }
 
 export async function spawnTtyd(opts: SpawnOptions = {}): Promise<TtydSession> {
-    await hydrateRegistry();
+    await prof.measureAsync("spawn.hydrate", () => hydrateRegistry());
 
     if (!existsSync(TTYD_BIN)) {
         throw new Error(`ttyd not found at ${TTYD_BIN}`);
@@ -530,13 +513,13 @@ export async function spawnTtyd(opts: SpawnOptions = {}): Promise<TtydSession> {
     const rawCommand = opts.command ?? env.paths.getShell("/bin/zsh");
     const command = rawCommand.trim().length > 0 && !rawCommand.includes("=") ? rawCommand.trim() : "/bin/zsh";
     const cwd = opts.cwd ?? process.cwd();
-    const port = await findFreePort();
+    const port = await prof.measureAsync("spawn.freePort", () => findFreePort());
     const id = randomUUID();
 
     let tmuxSessionName: string;
 
     if (opts.attachTmuxSession) {
-        if (!sessionExists(opts.attachTmuxSession)) {
+        if (!(await sessionExists(opts.attachTmuxSession))) {
             throw new Error(`tmux session ${opts.attachTmuxSession} does not exist`);
         }
 
@@ -546,21 +529,27 @@ export async function spawnTtyd(opts: SpawnOptions = {}): Promise<TtydSession> {
             throw err;
         }
 
-        tmuxSessionName = opts.attachTmuxSession;
-        ensureTmuxSessionEnvironment(tmuxSessionName);
-        // Re-pin the server even when attaching to a pre-existing session — it may
-        // have been bootstrapped (by an older dashboard) with exit-empty on.
-        ensureTmuxServerPersists();
+        const attachTo = opts.attachTmuxSession;
+        tmuxSessionName = attachTo;
+        await prof.measureAsync("spawn.tmuxAttachSetup", () =>
+            Promise.all([
+                ensureTmuxSessionEnvironment(attachTo),
+                // Re-pin the server even when attaching to a pre-existing session — it may
+                // have been bootstrapped (by an older dashboard) with exit-empty on.
+                ensureTmuxServerPersists(),
+            ])
+        );
     } else {
-        tmuxSessionName = makeTtydTmuxSessionName(id);
-        createTmuxSession(tmuxSessionName, cwd, command);
+        const created = makeTtydTmuxSessionName(id);
+        tmuxSessionName = created;
+        await prof.measureAsync("spawn.tmuxCreateSession", () => createTmuxSession(created, cwd, command));
     }
 
     const { session, child } = launchTtydChild({ id, port, cwd, command, tmuxSessionName });
 
     try {
         registry.set(id, { session, child });
-        await persistRegistry();
+        await prof.measureAsync("spawn.persist", () => persistRegistry());
     } catch (err) {
         registry.delete(id);
         await killWithEscalation(child);
@@ -575,14 +564,14 @@ export async function spawnTtyd(opts: SpawnOptions = {}): Promise<TtydSession> {
 
 /**
  * Config/registry can say `tmuxSessionName: "bridge"` while the live ttyd still
- * has `attach-session -t dev-dashboard-OLD` in argv (rename retarget used to only
+ * has `attach-session -t dd-OLD` in argv (rename retarget used to only
  * rewrite JSON). Heal by relaunching misaligned processes so list/UI recover without
  * a manual kill.
  */
 const HEAL_TTL_MS = 3000;
 let lastHealAt = 0;
 
-async function healStaleTtydTmuxTargets(): Promise<void> {
+async function healStaleTtydTmuxTargets(liveTmuxSessions: ReadonlySet<string>): Promise<void> {
     // Same reasoning as pruneDeadSessions' TTL: listTtyd is polled from several
     // routes every few seconds, and a stale attach target only appears on rename.
     if (Date.now() - lastHealAt < HEAL_TTL_MS) {
@@ -592,11 +581,14 @@ async function healStaleTtydTmuxTargets(): Promise<void> {
     lastHealAt = Date.now();
 
     // One `ps` per session, all in flight at once — never a serial blocking sweep.
+    // Existence checks reuse the caller's single list-sessions result: a per-binding
+    // `sessionExists` here was an N+1 subprocess storm (10 bindings = 10 extra
+    // full `tmux list-sessions` calls per poll).
     const candidates = await Promise.all(
         Array.from(registry.values()).map(async (tracked): Promise<Tracked | null> => {
             const expected = tracked.session.tmuxSessionName;
 
-            if (!expected || !sessionExists(expected)) {
+            if (!expected || !liveTmuxSessions.has(expected)) {
                 return null;
             }
 
@@ -651,22 +643,110 @@ async function healStaleTtydTmuxTargets(): Promise<void> {
 }
 
 export async function listTtyd(): Promise<TtydSession[]> {
-    await hydrateRegistry();
-    await pruneDeadSessions();
-    await healStaleTtydTmuxTargets();
+    await prof.measureAsync("list.hydrate", () => hydrateRegistry());
+
+    // prune touches only ps + config; the tmux list touches only tmux — run them
+    // concurrently. (hydrate stays sequential: prune reads the hydrated registry.)
+    const [, panesByTmux] = await Promise.all([
+        prof.measureAsync("list.prune", () => pruneDeadSessions()),
+        // One list-sessions call serving THREE consumers: heal's existence set,
+        // syncNames' pane titles, and the lastCommand enrichment below.
+        prof.measureAsync("list.activePanes", () => listTmuxSessionActivePanes()),
+    ]);
 
-    // Refresh each session's live `lastCommand` from its bound tmux session (one list-sessions call,
-    // shared across all sessions). Drives the auto-name; a manual `name` still wins downstream.
-    const commandByTmux = listTmuxSessionCommands();
+    await prof.measureAsync("list.heal", () => healStaleTtydTmuxTargets(new Set(panesByTmux.keys())));
+    // Can escalate into a tmux rename + full ttyd kill/relaunch inside this GET.
+    await prof.measureAsync("list.syncClaudeNames", () => syncNamesFromClaudePaneTitles(panesByTmux));
 
     return Array.from(registry.values()).map((tracked) => {
         const { session } = tracked;
-        const lastCommand = session.tmuxSessionName ? commandByTmux.get(session.tmuxSessionName) : undefined;
+        const pane = session.tmuxSessionName ? panesByTmux.get(session.tmuxSessionName) : undefined;
 
-        return { ...session, lastCommand };
+        return { ...session, lastCommand: pane?.command || undefined };
     });
 }
 
+/**
+ * Claude `/rename` only updates `#{pane_title}` (`✳ name`). Mirror that onto the real tmux
+ * session name + ttyd display label so Session Hub / tabs stay in sync.
+ */
+async function syncNamesFromClaudePaneTitles(
+    panesByTmux: Awaited<ReturnType<typeof listTmuxSessionActivePanes>>
+): Promise<void> {
+    // Snapshot first — retarget mutates registry bindings mid-loop.
+    const candidates = Array.from(registry.values())
+        .map((tracked) => {
+            const fromName = tracked.session.tmuxSessionName;
+
+            if (!fromName) {
+                return null;
+            }
+
+            const pane = panesByTmux.get(fromName);
+
+            if (!pane || !isClaudeForegroundCommand(pane.command)) {
+                return null;
+            }
+
+            const toName = parseClaudePaneTitle(pane.title);
+
+            if (!toName || toName === fromName) {
+                // Tmux already matches; still mirror a stale ttyd display name.
+                if (toName && tracked.session.name !== toName) {
+                    return { id: tracked.session.id, fromName, toName, renameTmux: false };
+                }
+
+                return null;
+            }
+
+            return { id: tracked.session.id, fromName, toName, renameTmux: true };
+        })
+        .filter((c): c is { id: string; fromName: string; toName: string; renameTmux: boolean } => c !== null);
+
+    if (candidates.length === 0) {
+        return;
+    }
+
+    for (const { id, fromName, toName, renameTmux } of candidates) {
+        try {
+            if (renameTmux) {
+                // The pane map's keys are the full live session-name set from this
+                // poll's single list-sessions — no extra tmux call for the clash check.
+                if (panesByTmux.has(toName)) {
+                    logger.debug(
+                        { id, fromName, toName },
+                        "claude pane title sync skipped: destination tmux session already exists"
+                    );
+                    continue;
+                }
+
+                await renameTmuxSession(fromName, toName);
+                await retargetTtydTmuxBindings(fromName, toName);
+
+                // Retarget updates bindings under the new name; refresh the pane map key for later reads.
+                const pane = panesByTmux.get(fromName);
+
+                if (pane) {
+                    panesByTmux.delete(fromName);
+                    panesByTmux.set(toName, pane);
+                }
+            }
+
+            const tracked = registry.get(id);
+
+            if (!tracked) {
+                continue;
+            }
+
+            tracked.session.name = toName;
+            await persistRegistry();
+            logger.info({ id, fromName, toName, renameTmux }, "synced tmux/ttyd name from Claude pane title (/rename)");
+        } catch (err) {
+            logger.debug({ err, id, fromName, toName }, "claude pane title sync failed");
+        }
+    }
+}
+
 /**
  * Resolve a session's port. The front-proxy (a *separate* process from the
  * vite-middleware that runs `spawnTtyd`) hits this for every /ttyd/<id>/*
@@ -719,13 +799,69 @@ export async function renameTtyd(id: string, name: string): Promise<boolean> {
     }
 
     const trimmed = name.trim();
-    tracked.session.name = trimmed.length > 0 ? trimmed : undefined;
+
+    // Clearing the display name only — keep the tmux session (identity still derives from
+    // tmuxSessionName via deriveTtydDisplayName).
+    if (!trimmed) {
+        tracked.session.name = undefined;
+        await persistRegistry();
+        logger.info({ id, name: undefined }, "ttyd display name cleared");
+
+        return true;
+    }
+
+    const fromTmux = tracked.session.tmuxSessionName;
+
+    if (fromTmux && fromTmux !== trimmed) {
+        // One identity: tab rename = tmux rename. Retarget relaunches ttyd so attach argv tracks.
+        await renameTmuxSession(fromTmux, trimmed);
+        await retargetTtydTmuxBindings(fromTmux, trimmed);
+    }
+
+    const after = registry.get(id);
+
+    if (!after) {
+        return false;
+    }
+
+    after.session.name = trimmed;
     await persistRegistry();
-    logger.info({ id, name: tracked.session.name }, "ttyd renamed");
+    logger.info(
+        { id, name: trimmed, tmuxSessionName: after.session.tmuxSessionName },
+        "ttyd renamed (synced to tmux when bound)"
+    );
 
     return true;
 }
 
+/** After a hub-side tmux rename, mirror the new name onto every bound ttyd display label. */
+export async function syncTtydDisplayNamesForTmux(tmuxSessionName: string, displayName: string): Promise<void> {
+    await hydrateRegistry();
+
+    const trimmed = displayName.trim();
+    let changed = false;
+
+    for (const tracked of registry.values()) {
+        if (tracked.session.tmuxSessionName !== tmuxSessionName) {
+            continue;
+        }
+
+        const next = trimmed.length > 0 ? trimmed : undefined;
+
+        if (tracked.session.name === next) {
+            continue;
+        }
+
+        tracked.session.name = next;
+        changed = true;
+    }
+
+    if (changed) {
+        await persistRegistry();
+        logger.info({ tmuxSessionName, displayName: trimmed }, "synced ttyd display names after tmux rename");
+    }
+}
+
 export async function retargetTtydTmuxBindings(fromName: string, toName: string): Promise<void> {
     await hydrateRegistry();
 
@@ -776,7 +912,7 @@ export async function killTtyd(id: string, opts: KillTtydOptions = {}): Promise<
     await stopTtydProcess(tracked, id);
 
     if (opts.killTmux && tracked.session.tmuxSessionName) {
-        killTmuxSession(tracked.session.tmuxSessionName);
+        await killTmuxSession(tracked.session.tmuxSessionName);
     }
 
     registry.delete(id);
diff --git a/src/dev-dashboard/server/adapters/bun-serve.ts b/src/dev-dashboard/server/adapters/bun-serve.ts
index 44dd18cfc..6d9d736d4 100644
--- a/src/dev-dashboard/server/adapters/bun-serve.ts
+++ b/src/dev-dashboard/server/adapters/bun-serve.ts
@@ -2,6 +2,11 @@ import type { Router } from "@app/dev-dashboard/server/router";
 import type { RouteContext, RouteResult, RouteServices, SseEmitter } from "@app/dev-dashboard/server/types";
 import { SafeJSON } from "@genesiscz/utils/json";
 import { logger } from "@genesiscz/utils/logger";
+import { profiler } from "@genesiscz/utils/profile";
+
+// Per-endpoint handler time, keyed by route pattern so `:id` routes aggregate.
+//   PROFILE=route,ttyd,tmux tools dev-dashboard …
+const prof = profiler.scope("route");
 
 export function toResponse(result: RouteResult): Response {
     if (result.kind === "json") {
@@ -119,5 +124,7 @@ export async function routerToResponse(
         services: opts.services,
     };
 
-    return toResponse(await matched.def.handler(ctx));
+    const label = `${matched.def.method} ${matched.def.pattern}`;
+
+    return toResponse(await prof.measureAsync(label, async () => matched.def.handler(ctx)));
 }
diff --git a/src/dev-dashboard/server/adapters/node-connect.ts b/src/dev-dashboard/server/adapters/node-connect.ts
index 936a7ad57..fb5c34fb1 100644
--- a/src/dev-dashboard/server/adapters/node-connect.ts
+++ b/src/dev-dashboard/server/adapters/node-connect.ts
@@ -2,6 +2,11 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteMatch, Router } from "@app/dev-dashboard/server/router";
 import type { RouteContext, RouteResult, RouteServices, SseEmitter } from "@app/dev-dashboard/server/types";
 import { SafeJSON } from "@genesiscz/utils/json";
+import { profiler } from "@genesiscz/utils/profile";
+
+// Per-endpoint handler time, keyed by route pattern so `:id` routes aggregate.
+//   PROFILE=route,ttyd,tmux tools dev-dashboard …
+const prof = profiler.scope("route");
 
 async function readRawBytes(req: IncomingMessage): Promise<Uint8Array> {
     const chunks: Buffer[] = [];
@@ -118,7 +123,8 @@ export async function handleWithRouter(
         services: opts.services,
     };
 
-    const result = await matched.def.handler(ctx);
+    const label = `${matched.def.method} ${matched.def.pattern}`;
+    const result = await prof.measureAsync(label, async () => matched.def.handler(ctx));
     writeResult(res, result);
 
     return true;
diff --git a/src/dev-dashboard/server/routes/tmux-presets.ts b/src/dev-dashboard/server/routes/tmux-presets.ts
index 1592349cf..d4c137d70 100644
--- a/src/dev-dashboard/server/routes/tmux-presets.ts
+++ b/src/dev-dashboard/server/routes/tmux-presets.ts
@@ -48,7 +48,7 @@ export function tmuxPresetsRoutes(): RouteDef[] {
                         return { kind: "json", status: 400, body: { error: "name is required" } };
                     }
 
-                    return { kind: "json", status: 200, body: { result: restorePreset(body.name) } };
+                    return { kind: "json", status: 200, body: { result: await restorePreset(body.name) } };
                 } catch (err) {
                     logger.warn({ err, route: "POST /api/tmux/presets/restore" }, "tmux presets: restore failed");
 
diff --git a/src/dev-dashboard/server/routes/tmux.ts b/src/dev-dashboard/server/routes/tmux.ts
index f03e7b0fd..d101af226 100644
--- a/src/dev-dashboard/server/routes/tmux.ts
+++ b/src/dev-dashboard/server/routes/tmux.ts
@@ -8,8 +8,13 @@ import { fetchCmuxFullLayout } from "@genesiscz/utils/cmux/layout";
 import type { CmuxTmuxSurfaceRef } from "@genesiscz/utils/cmux/tmux-bindings";
 import { indexCmuxSurfacesByTmuxSession } from "@genesiscz/utils/cmux/tmux-bindings";
 import { logger } from "@genesiscz/utils/logger";
+import { profiler } from "@genesiscz/utils/profile";
 import { listTmuxSessions } from "@genesiscz/utils/tmux/sessions";
 
+// The route-level timer (server/adapters/*) gives the total; this splits it into the two
+// halves that actually move — the optional cmux layout RPC and the ttyd list sweep.
+const prof = profiler.scope("route");
+
 export function tmuxRoutes(): RouteDef[] {
     return [
         {
@@ -35,7 +40,9 @@ export function tmuxRoutes(): RouteDef[] {
                         // workspace/surface ids+titles, never `preview`. Capturing the visible
                         // screen of each selected surface (the default) added ~600ms to this
                         // endpoint on a 12-workspace machine.
-                        const layout = await fetchCmuxFullLayout({ includePreviews: false });
+                        const layout = await prof.measureAsync("tmux.cmuxLayout", () =>
+                            fetchCmuxFullLayout({ includePreviews: false })
+                        );
 
                         if (layout.available) {
                             cmuxBySession = indexCmuxSurfacesByTmuxSession(layout);
@@ -45,7 +52,11 @@ export function tmuxRoutes(): RouteDef[] {
                     }
                 }
 
-                const sessions = enrichSessionsForHub(listTmuxSessions(), await listTtyd(), cmuxBySession);
+                // Argument order preserved: `listTtyd()` can rename tmux sessions mid-call, and
+                // this list is deliberately the pre-rename snapshot.
+                const tmuxSessions = await prof.measureAsync("tmux.listSessions", () => listTmuxSessions());
+                const ttydSessions = await prof.measureAsync("tmux.listTtyd", () => listTtyd());
+                const sessions = enrichSessionsForHub(tmuxSessions, ttydSessions, cmuxBySession);
 
                 return { kind: "json", status: 200, body: { sessions } };
             },
@@ -57,7 +68,7 @@ export function tmuxRoutes(): RouteDef[] {
                 try {
                     const body = await ctx.readJson<{ name?: string; cwd?: string; command?: string }>();
 
-                    return { kind: "json", status: 200, body: createStandaloneTmuxSession(body) };
+                    return { kind: "json", status: 200, body: await createStandaloneTmuxSession(body) };
                 } catch (err) {
                     logger.warn({ err, route: "POST /api/tmux/create" }, "tmux hub: create session failed");
 
diff --git a/src/tmux/commands/create.ts b/src/tmux/commands/create.ts
index e29bfae37..1905c293c 100644
--- a/src/tmux/commands/create.ts
+++ b/src/tmux/commands/create.ts
@@ -19,16 +19,16 @@ export function registerCreateCommand(program: Command): void {
         .option("-c, --cwd <path>", "Working directory (default: cwd)")
         .option("--command <shell>", "Command to run in the session (default: $SHELL)")
         .option("-a, --attach", "Attach to the new session immediately (foreground; needs a TTY)")
-        .action((flags: CreateFlags) => {
+        .action(async (flags: CreateFlags) => {
             const sessionName = flags.name?.trim() || makeStandaloneTmuxSessionName();
             const cwd = flags.cwd ?? process.cwd();
             const command = flags.command ?? env.paths.getShell("/bin/zsh");
 
-            if (sessionExists(sessionName)) {
+            if (await sessionExists(sessionName)) {
                 throw new Error(`tmux session ${sessionName} already exists`);
             }
 
-            createTmuxSession(sessionName, cwd, command);
+            await createTmuxSession(sessionName, cwd, command);
 
             if (!flags.attach) {
                 out.result({ sessionName, cwd, command });
diff --git a/src/tmux/commands/presets/restore.ts b/src/tmux/commands/presets/restore.ts
index 9dd66867c..c995fa1cd 100644
--- a/src/tmux/commands/presets/restore.ts
+++ b/src/tmux/commands/presets/restore.ts
@@ -61,7 +61,7 @@ export async function runRestorePreset(name: string, flags: RestoreFlags): Promi
 
     for (const session of targets) {
         const targetName = flags.suffix ? `${session.name}${flags.suffix}` : session.name;
-        const clash = sessionExists(targetName);
+        const clash = await sessionExists(targetName);
         const note = clash ? pc.yellow("(skip — already exists)") : pc.dim(`(${countPanes(session)} pane(s))`);
         out.println(`  ${clash ? pc.dim(targetName) : pc.cyan(targetName)} ${note}`);
     }
@@ -96,7 +96,7 @@ export async function runRestorePreset(name: string, flags: RestoreFlags): Promi
 
     for (const session of targets) {
         try {
-            const outcome = restoreTmuxSession(session, {
+            const outcome = await restoreTmuxSession(session, {
                 skipReplay: flags.skipReplay,
                 nameSuffix: flags.suffix,
             });
diff --git a/src/tmux/commands/session.ts b/src/tmux/commands/session.ts
index 00b7a8a22..5d43c41c2 100644
--- a/src/tmux/commands/session.ts
+++ b/src/tmux/commands/session.ts
@@ -96,7 +96,7 @@ export async function runReset(sessionId: string | undefined, flags: ResetCliFla
         }
     }
 
-    const result = resetSessions({
+    const result = await resetSessions({
         targets,
         options: { skipReplay: flags.skipReplay, preset: flags.preset, skipBackup: flags.skipBackup },
     });
@@ -149,7 +149,7 @@ export async function runReset(sessionId: string | undefined, flags: ResetCliFla
 }
 
 export async function runAttach(query: string): Promise<void> {
-    const sessions = listTmuxSessions();
+    const sessions = await listTmuxSessions();
     const match = resolveSessionQuery(query, sessions);
     const isTty = Boolean(process.stdin.isTTY);
 
diff --git a/src/utils/cmux/send-tmux.ts b/src/utils/cmux/send-tmux.ts
index b5b1700eb..3ae1c0361 100644
--- a/src/utils/cmux/send-tmux.ts
+++ b/src/utils/cmux/send-tmux.ts
@@ -75,7 +75,7 @@ export async function attachTmuxToCmux({
     cwd,
     focus = true,
 }: AttachTmuxToCmuxOptions): Promise<AttachTmuxResult> {
-    if (!sessionExists(tmuxSessionName)) {
+    if (!(await sessionExists(tmuxSessionName))) {
         throw new Error(`tmux session ${tmuxSessionName} does not exist`);
     }
 
diff --git a/src/utils/tmux/reset.ts b/src/utils/tmux/reset.ts
index 45bc306be..37f0513b6 100644
--- a/src/utils/tmux/reset.ts
+++ b/src/utils/tmux/reset.ts
@@ -117,7 +117,11 @@ export function selectResetTargets(
  * output — returns a result the caller renders. Reusable by the dev-dashboard
  * server (its "recycle dev-dashboard-* sessions" flow) without shelling out.
  */
-export function resetSessions(opts: { targets: ResetTargets; options: ResetCoreOptions; now?: Date }): ResetResult {
+export async function resetSessions(opts: {
+    targets: ResetTargets;
+    options: ResetCoreOptions;
+    now?: Date;
+}): Promise<ResetResult> {
     const { targets, options } = opts;
     const now = opts.now ?? new Date();
     const { sessions } = targets;
@@ -146,13 +150,13 @@ export function resetSessions(opts: { targets: ResetTargets; options: ResetCoreO
 
     // Scrub the server's global env BEFORE killing so the recreated shells don't
     // re-inherit NO_COLOR / empty COLORTERM leaked by whichever process founded it.
-    ensureTmuxServerPersists();
+    await ensureTmuxServerPersists();
 
-    result.killed = killTmuxSessionsMatching(sessions.map((s) => s.name));
+    result.killed = await killTmuxSessionsMatching(sessions.map((s) => s.name));
 
     for (const session of sessions) {
         try {
-            const outcome = restoreTmuxSession(session, { skipReplay: options.skipReplay });
+            const outcome = await restoreTmuxSession(session, { skipReplay: options.skipReplay });
             result.outcomes.push(outcome);
         } catch (error) {
             result.failures.push({ name: session.name, error });
diff --git a/src/utils/tmux/sessions.test.ts b/src/utils/tmux/sessions.test.ts
index abedd3799..1e8d0a84c 100644
--- a/src/utils/tmux/sessions.test.ts
+++ b/src/utils/tmux/sessions.test.ts
@@ -5,6 +5,7 @@ import {
     buildTmuxSpawnEnv,
     createTmuxSession,
     getTmuxScrollState,
+    listTmuxSessionActivePanes,
     listTmuxSessionCommands,
     listTmuxSessions,
     renameTmuxSession,
@@ -20,7 +21,7 @@ describe("tmux sessions", () => {
         resetTmuxBinCache();
     });
 
-    test("listTmuxSessions parses tmux list-sessions output", () => {
+    test("listTmuxSessions parses tmux list-sessions output", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests((cmd) => {
             if (cmd.includes("list-sessions")) {
@@ -33,42 +34,63 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        expect(listTmuxSessions()).toEqual([
+        expect(await listTmuxSessions()).toEqual([
             { name: "dev-dashboard-abc12345", attached: 1, windows: 2 },
             { name: "cmux-test", attached: 0, windows: 1 },
         ]);
     });
 
-    test("listTmuxSessions returns empty when tmux fails", () => {
+    test("listTmuxSessions returns empty when tmux fails", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests(() => ({ exitCode: 1, stdout: "" }));
-        expect(listTmuxSessions()).toEqual([]);
+        expect(await listTmuxSessions()).toEqual([]);
     });
 
-    test("listTmuxSessionCommands maps session name to its active pane command", () => {
+    test("listTmuxSessionCommands maps session name to its active pane command", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests((cmd) => {
             if (cmd.includes("list-sessions")) {
-                return { exitCode: 0, stdout: "dev-dashboard-abc12345\tclaude\ncmux-test\tzsh\nblank-cmd\t\n" };
+                return {
+                    exitCode: 0,
+                    stdout: "dev-dashboard-abc12345\tclaude\t✳ testt\ncmux-test\tzsh\t\nblank-cmd\t\t\n",
+                };
             }
 
             return { exitCode: 0, stdout: "" };
         });
 
-        const commands = listTmuxSessionCommands();
+        const commands = await listTmuxSessionCommands();
         expect(commands.get("dev-dashboard-abc12345")).toBe("claude");
         expect(commands.get("cmux-test")).toBe("zsh");
         // A blank command is skipped (no entry), not stored as "".
         expect(commands.has("blank-cmd")).toBe(false);
     });
 
-    test("listTmuxSessionCommands returns empty when tmux fails", () => {
+    test("listTmuxSessionActivePanes includes pane titles", async () => {
+        setTmuxBinForTests("/mock/tmux");
+        setTmuxSpawnSyncForTests((cmd) => {
+            if (cmd.includes("list-sessions")) {
+                return {
+                    exitCode: 0,
+                    stdout: "dev-dashboard-abc12345\tclaude\t✳ testt\ncmux-test\tzsh\t\n",
+                };
+            }
+
+            return { exitCode: 0, stdout: "" };
+        });
+
+        const panes = await listTmuxSessionActivePanes();
+        expect(panes.get("dev-dashboard-abc12345")).toEqual({ command: "claude", title: "✳ testt" });
+        expect(panes.get("cmux-test")).toEqual({ command: "zsh", title: "" });
+    });
+
+    test("listTmuxSessionCommands returns empty when tmux fails", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests(() => ({ exitCode: 1, stdout: "" }));
-        expect(listTmuxSessionCommands().size).toBe(0);
+        expect((await listTmuxSessionCommands()).size).toBe(0);
     });
 
-    test("sessionExists checks parsed list", () => {
+    test("sessionExists checks parsed list", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests((cmd) => {
             if (cmd.includes("list-sessions")) {
@@ -78,8 +100,8 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        expect(sessionExists("foo")).toBe(true);
-        expect(sessionExists("missing")).toBe(false);
+        expect(await sessionExists("foo")).toBe(true);
+        expect(await sessionExists("missing")).toBe(false);
     });
 
     test("buildTmuxSpawnEnv sets UTF-8 locale when LANG unset", () => {
@@ -117,7 +139,7 @@ describe("tmux sessions", () => {
         }
     });
 
-    test("renameTmuxSession calls tmux rename-session", () => {
+    test("renameTmuxSession calls tmux rename-session", async () => {
         setTmuxBinForTests("/mock/tmux");
         const calls: string[][] = [];
         setTmuxSpawnSyncForTests((cmd) => {
@@ -130,12 +152,12 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        renameTmuxSession("foo", "bar");
+        await renameTmuxSession("foo", "bar");
 
         expect(calls.some((cmd) => cmd.includes("rename-session") && cmd.includes("bar"))).toBe(true);
     });
 
-    test("createTmuxSession pins exit-empty off so the server keeps sessions across teardown", () => {
+    test("createTmuxSession pins exit-empty off so the server keeps sessions across teardown", async () => {
         setTmuxBinForTests("/mock/tmux");
         const calls: string[][] = [];
         setTmuxSpawnSyncForTests((cmd) => {
@@ -143,7 +165,7 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        createTmuxSession("foo", "/tmp", "/bin/zsh");
+        await createTmuxSession("foo", "/tmp", "/bin/zsh");
 
         expect(calls.some((cmd) => cmd.includes("new-session") && cmd.includes("foo"))).toBe(true);
         expect(calls.some((cmd) => cmd.includes("new-session") && cmd.includes("--"))).toBe(true);
@@ -172,7 +194,7 @@ describe("tmux sessions", () => {
         ).toBe(true);
     });
 
-    test("getTmuxScrollState parses display-message output", () => {
+    test("getTmuxScrollState parses display-message output", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests((cmd) => {
             if (cmd.includes("display-message")) {
@@ -182,7 +204,7 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        expect(getTmuxScrollState("foo")).toEqual({
+        expect(await getTmuxScrollState("foo")).toEqual({
             historySize: 979,
             paneHeight: 24,
             scrollPosition: 100,
@@ -191,11 +213,11 @@ describe("tmux sessions", () => {
         });
     });
 
-    test("getTmuxScrollState treats empty scroll_position as live bottom", () => {
+    test("getTmuxScrollState treats empty scroll_position as live bottom", async () => {
         setTmuxBinForTests("/mock/tmux");
         setTmuxSpawnSyncForTests(() => ({ exitCode: 0, stdout: "500|40||0|0" }));
 
-        expect(getTmuxScrollState("foo")).toEqual({
+        expect(await getTmuxScrollState("foo")).toEqual({
             historySize: 500,
             paneHeight: 40,
             scrollPosition: 0,
@@ -204,7 +226,7 @@ describe("tmux sessions", () => {
         });
     });
 
-    test("scrollTmuxToFraction(1) cancels copy-mode to follow live output", () => {
+    test("scrollTmuxToFraction(1) cancels copy-mode to follow live output", async () => {
         setTmuxBinForTests("/mock/tmux");
         const calls: string[][] = [];
         setTmuxSpawnSyncForTests((cmd) => {
@@ -217,13 +239,13 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        scrollTmuxToFraction("foo", 1);
+        await scrollTmuxToFraction("foo", 1);
 
         expect(calls.some((cmd) => cmd.includes("cancel"))).toBe(true);
         expect(calls.some((cmd) => cmd.includes("scroll-up"))).toBe(false);
     });
 
-    test("scrollTmuxToFraction ignores non-finite fraction", () => {
+    test("scrollTmuxToFraction ignores non-finite fraction", async () => {
         setTmuxBinForTests("/mock/tmux");
         const calls: string[][] = [];
         setTmuxSpawnSyncForTests((cmd) => {
@@ -231,12 +253,12 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "1000|24|50|1|0" };
         });
 
-        scrollTmuxToFraction("foo", Number.NaN);
+        await scrollTmuxToFraction("foo", Number.NaN);
 
         expect(calls.length).toBe(0);
     });
 
-    test("scrollTmuxToFraction(0) parks at the top of history", () => {
+    test("scrollTmuxToFraction(0) parks at the top of history", async () => {
         setTmuxBinForTests("/mock/tmux");
         const calls: string[][] = [];
         setTmuxSpawnSyncForTests((cmd) => {
@@ -249,7 +271,7 @@ describe("tmux sessions", () => {
             return { exitCode: 0, stdout: "" };
         });
 
-        scrollTmuxToFraction("foo", 0);
+        await scrollTmuxToFraction("foo", 0);
 
         expect(calls.some((cmd) => cmd.includes("copy-mode"))).toBe(true);
         expect(calls.some((cmd) => cmd.includes("history-bottom"))).toBe(true);
diff --git a/src/utils/tmux/sessions.ts b/src/utils/tmux/sessions.ts
index 2af06b524..8a08b3d15 100644
--- a/src/utils/tmux/sessions.ts
+++ b/src/utils/tmux/sessions.ts
@@ -1,13 +1,21 @@
 import { env } from "@genesiscz/utils/env";
 import { logger } from "@genesiscz/utils/logger";
+import { profiler } from "@genesiscz/utils/profile";
 import { buildTerminalSpawnEnv } from "@genesiscz/utils/terminal/locale";
 import { resolveTmuxBin } from "@genesiscz/utils/tmux/bin";
 import type { TmuxSessionInfo } from "@genesiscz/utils/tmux/types";
 
-export type TmuxSpawnSync = (
-    cmd: string[],
-    opts?: { cwd?: string }
-) => { exitCode: number | null; stdout: string; stderr?: string };
+export interface TmuxSpawnResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr?: string;
+}
+
+/**
+ * Injection seam for tests. Sync-returning impls remain valid (the core awaits
+ * whatever comes back), so existing test doubles don't need to change.
+ */
+export type TmuxSpawnSync = (cmd: string[], opts?: { cwd?: string }) => TmuxSpawnResult | Promise<TmuxSpawnResult>;
 
 export function buildTmuxSpawnEnv(): NodeJS.ProcessEnv {
     return buildTerminalSpawnEnv();
@@ -58,52 +66,69 @@ function tmuxLoginShellArgv(shell: string): string[] {
     return argv;
 }
 
-export function ensureTmuxSessionEnvironment(sessionName: string): void {
-    const tmuxBin = resolveTmuxBin();
-    const env = buildTerminalSpawnEnv();
-
-    for (const key of TMUX_SESSION_ENV_KEYS) {
-        const value = env[key];
+/**
+ * Join several tmux commands into ONE client invocation using tmux's `;`
+ * argv separator. This is the difference between N subprocess round-trips and
+ * one: the 17 idempotent set-environment/set-option calls that used to run on
+ * every spawn each cost a full fork/exec/socket round-trip. On error tmux
+ * aborts the remainder of the chain and exits non-zero, so chains are only
+ * used for best-effort batches, never for a must-succeed command.
+ */
+function chainTmuxCommands(commands: string[][]): string[] {
+    const argv: string[] = [];
 
-        if (!value) {
-            continue;
+    for (const command of commands) {
+        if (argv.length > 0) {
+            argv.push(";");
         }
 
-        const result = spawnSyncImpl([tmuxBin, "set-environment", "-t", sessionName, key, value]);
-
-        if (result.exitCode !== 0) {
-            logger.debug(
-                { sessionName, key, exitCode: result.exitCode, detail: tmuxErrorDetail(result.stderr) },
-                "tmux set-environment failed (session env not applied)"
-            );
-        }
+        argv.push(...command);
     }
-}
 
-/** @deprecated Use {@link ensureTmuxSessionEnvironment} */
-export const ensureTmuxSessionUtf8Locale = ensureTmuxSessionEnvironment;
+    return argv;
+}
 
-const defaultSpawnSync: TmuxSpawnSync = (cmd, opts) => {
-    const result = Bun.spawnSync(cmd, {
+// Every tmux call funnels through this async spawn. The previous implementation
+// used Bun.spawnSync, which blocks the WHOLE Bun event loop for the subprocess
+// lifetime — in the dev-dashboard server that froze every other in-flight HTTP
+// request too (a 7s spawn made an unrelated 200ms poll take 6.7s). The timing
+// scope survives:
+//   PROFILE=tmux tools dev-dashboard …
+const prof = profiler.scope("tmux");
+
+const defaultSpawn: TmuxSpawnSync = async (cmd, opts) => {
+    // Bound every tmux call. A wedged tmux server makes `list-sessions` (and friends) block
+    // forever, spinning a core at ~100% CPU; if the parent process is then killed mid-call the
+    // child is orphaned and keeps spinning. 10s is far above any healthy tmux command, so this
+    // only ever fires on a genuine wedge. SIGKILL because a spinning `list-sessions` ignores TERM.
+    const proc = Bun.spawn(cmd, {
         cwd: opts?.cwd,
         env: buildTmuxSpawnEnv(),
         stdio: ["ignore", "pipe", "pipe"],
-        // Bound every tmux call. A wedged tmux server makes `list-sessions` (and friends) block
-        // forever, spinning a core at ~100% CPU; if the parent process is then killed mid-call the
-        // child is orphaned and keeps spinning. 10s is far above any healthy tmux command, so this
-        // only ever fires on a genuine wedge. SIGKILL because a spinning `list-sessions` ignores TERM.
         timeout: 10_000,
         killSignal: "SIGKILL",
     });
 
-    return {
-        exitCode: result.exitCode,
-        stdout: result.stdout.toString(),
-        stderr: result.stderr.toString(),
-    };
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ]);
+
+    return { exitCode, stdout, stderr };
 };
 
-let spawnSyncImpl: TmuxSpawnSync = defaultSpawnSync;
+let spawnImpl: TmuxSpawnSync = defaultSpawn;
+
+async function runTmux(cmd: string[], opts?: { cwd?: string }): Promise<TmuxSpawnResult> {
+    const end = prof.start(cmd[1] ?? "tmux");
+
+    try {
+        return await spawnImpl(cmd, opts);
+    } finally {
+        end();
+    }
+}
 
 function tmuxErrorDetail(stderr?: string): string {
     const trimmed = stderr?.trim();
@@ -111,10 +136,42 @@ function tmuxErrorDetail(stderr?: string): string {
 }
 
 export function setTmuxSpawnSyncForTests(impl: TmuxSpawnSync | null): void {
-    spawnSyncImpl = impl ?? defaultSpawnSync;
+    spawnImpl = impl ?? defaultSpawn;
+    // The server-persist TTL latch must not leak across tests that swap impls.
+    lastServerPersistAt = 0;
+}
+
+export async function ensureTmuxSessionEnvironment(sessionName: string): Promise<void> {
+    const tmuxBin = resolveTmuxBin();
+    const env = buildTerminalSpawnEnv();
+    const commands: string[][] = [];
+
+    for (const key of TMUX_SESSION_ENV_KEYS) {
+        const value = env[key];
+
+        if (value) {
+            commands.push(["set-environment", "-t", sessionName, key, value]);
+        }
+    }
+
+    if (commands.length === 0) {
+        return;
+    }
+
+    const result = await runTmux([tmuxBin, ...chainTmuxCommands(commands)]);
+
+    if (result.exitCode !== 0) {
+        logger.debug(
+            { sessionName, exitCode: result.exitCode, detail: tmuxErrorDetail(result.stderr) },
+            "tmux set-environment batch failed (session env not applied)"
+        );
+    }
 }
 
-export function listTmuxSessions(): TmuxSessionInfo[] {
+/** @deprecated Use {@link ensureTmuxSessionEnvironment} */
+export const ensureTmuxSessionUtf8Locale = ensureTmuxSessionEnvironment;
+
+export async function listTmuxSessions(): Promise<TmuxSessionInfo[]> {
     let tmuxBin: string;
 
     try {
@@ -123,7 +180,7 @@ export function listTmuxSessions(): TmuxSessionInfo[] {
         return [];
     }
 
-    const result = spawnSyncImpl([
+    const result = await runTmux([
         tmuxBin,
         "list-sessions",
         "-F",
@@ -162,7 +219,32 @@ export function listTmuxSessions(): TmuxSessionInfo[] {
  * (`#{pane_current_command}`). Lightweight (no scrollback parse, unlike `captureTmuxSnapshot`) so it
  * is cheap enough for the ttyd-list hit path that derives an auto-name from the live command.
  */
-export function listTmuxSessionCommands(): Map<string, string> {
+export async function listTmuxSessionCommands(): Promise<Map<string, string>> {
+    const commands = new Map<string, string>();
+
+    for (const [name, pane] of await listTmuxSessionActivePanes()) {
+        if (pane.command) {
+            commands.set(name, pane.command);
+        }
+    }
+
+    return commands;
+}
+
+export interface TmuxActivePaneInfo {
+    command: string;
+    title: string;
+}
+
+/**
+ * Active-pane command + title per session. Title is how Claude Code surfaces `/rename`
+ * (`✳ name` / `⠐ name`) into tmux without renaming the session itself.
+ *
+ * The keys are the full live session-name set, so callers that only need
+ * existence checks against many names should reuse this ONE call instead of
+ * issuing per-name `sessionExists` list-sessions storms.
+ */
+export async function listTmuxSessionActivePanes(): Promise<Map<string, TmuxActivePaneInfo>> {
     let tmuxBin: string;
 
     try {
@@ -171,43 +253,50 @@ export function listTmuxSessionCommands(): Map<string, string> {
         return new Map();
     }
 
-    const result = spawnSyncImpl([tmuxBin, "list-sessions", "-F", "#{session_name}\t#{pane_current_command}"]);
+    const result = await runTmux([
+        tmuxBin,
+        "list-sessions",
+        "-F",
+        "#{session_name}\t#{pane_current_command}\t#{pane_title}",
+    ]);
 
     if (result.exitCode !== 0) {
         return new Map();
     }
 
-    const commands = new Map<string, string>();
+    const panes = new Map<string, TmuxActivePaneInfo>();
 
     for (const line of result.stdout.split("\n")) {
-        const trimmed = line.trim();
+        const trimmed = line.trimEnd();
+
         if (!trimmed) {
             continue;
         }
 
-        const tab = trimmed.indexOf("\t");
-        if (tab === -1) {
+        const [name, commandRaw = "", ...titleParts] = trimmed.split("\t");
+
+        if (!name) {
             continue;
         }
 
-        const name = trimmed.slice(0, tab);
-        const command = trimmed.slice(tab + 1).trim();
-
-        if (name && command) {
-            commands.set(name, command);
-        }
+        panes.set(name, {
+            command: commandRaw.trim(),
+            title: titleParts.join("\t").trim(),
+        });
     }
 
-    return commands;
+    return panes;
 }
 
-export function sessionExists(sessionName: string): boolean {
-    return listTmuxSessions().some((session) => session.name === sessionName);
+export async function sessionExists(sessionName: string): Promise<boolean> {
+    // Each call is a full `list-sessions`. Callers checking MANY names should reuse
+    // one listTmuxSessions()/listTmuxSessionActivePanes() result instead of looping this.
+    return (await listTmuxSessions()).some((session) => session.name === sessionName);
 }
 
-export function createTmuxSession(sessionName: string, cwd: string, command: string): void {
+export async function createTmuxSession(sessionName: string, cwd: string, command: string): Promise<void> {
     const tmuxBin = resolveTmuxBin();
-    const result = spawnSyncImpl(
+    const result = await runTmux(
         [tmuxBin, "new-session", "-d", "-s", sessionName, "-c", cwd, "--", ...tmuxLoginShellArgv(command)],
         { cwd }
     );
@@ -216,10 +305,12 @@ export function createTmuxSession(sessionName: string, cwd: string, command: str
         throw new Error(`Failed to create tmux session ${sessionName}${tmuxErrorDetail(result.stderr)}`);
     }
 
-    ensureTmuxSessionEnvironment(sessionName);
-
-    // Pin the (possibly freshly-bootstrapped) server to keep sessions alive.
-    ensureTmuxServerPersists(tmuxBin);
+    // Both best-effort and independent — run concurrently.
+    await Promise.all([
+        ensureTmuxSessionEnvironment(sessionName),
+        // Pin the (possibly freshly-bootstrapped) server to keep sessions alive.
+        ensureTmuxServerPersists(tmuxBin),
+    ]);
 }
 
 /**
@@ -246,8 +337,19 @@ export function createTmuxSession(sessionName: string, cwd: string, command: str
  * whole server, `-g` forces the positive ones, and once a server has been
  * touched by this function its global env is colour-clean regardless of who
  * bootstrapped it. All set-options are idempotent and safe.
+ *
+ * All nine commands ride ONE tmux invocation, and the whole thing is skipped
+ * within a short TTL: the options are server-global and idempotent, so
+ * re-running them on every spawn/attach only added subprocess round-trips.
  */
-export function ensureTmuxServerPersists(tmuxBin?: string): void {
+const SERVER_PERSIST_TTL_MS = 60_000;
+let lastServerPersistAt = 0;
+
+export async function ensureTmuxServerPersists(tmuxBin?: string): Promise<void> {
+    if (Date.now() - lastServerPersistAt < SERVER_PERSIST_TTL_MS) {
+        return;
+    }
+
     let bin: string;
 
     try {
@@ -257,42 +359,48 @@ export function ensureTmuxServerPersists(tmuxBin?: string): void {
         return;
     }
 
-    // -u = unset; -g = global. Run set-environment FIRST so any session created
-    // immediately after this call (e.g. createTmuxSession → ensureTmuxServerPersists
-    // → next createTmuxSession) gets the clean env.
-    const setOptionArgs: string[][] = [
-        ["set-environment", "-gu", "NO_COLOR"],
-        ["set-environment", "-gu", "CARGO_TERM_COLOR"],
-        ["set-environment", "-gu", "PIP_NO_COLOR"],
-        ["set-environment", "-g", "COLORTERM", "truecolor"],
-        ["set-environment", "-g", "FORCE_COLOR", "1"],
-        ["set-environment", "-g", "CLICOLOR", "1"],
-        ["set-environment", "-g", "CLICOLOR_FORCE", "1"],
-        ["set-option", "-s", "exit-empty", "off"],
-        ["set-option", "-g", "destroy-unattached", "off"],
-    ];
-
-    for (const args of setOptionArgs) {
-        const result = spawnSyncImpl([bin, ...args]);
-
-        if (result.exitCode !== 0) {
-            logger.debug(
-                { args, exitCode: result.exitCode, detail: tmuxErrorDetail(result.stderr) },
-                "ensureTmuxServerPersists: tmux set-option failed"
-            );
-        }
+    // -u = unset; -g = global. set-environment runs FIRST in the chain so any
+    // session created immediately after this call gets the clean env.
+    const result = await runTmux([
+        bin,
+        ...chainTmuxCommands([
+            ["set-environment", "-gu", "NO_COLOR"],
+            ["set-environment", "-gu", "CARGO_TERM_COLOR"],
+            ["set-environment", "-gu", "PIP_NO_COLOR"],
+            ["set-environment", "-g", "COLORTERM", "truecolor"],
+            ["set-environment", "-g", "FORCE_COLOR", "1"],
+            ["set-environment", "-g", "CLICOLOR", "1"],
+            ["set-environment", "-g", "CLICOLOR_FORCE", "1"],
+            ["set-option", "-s", "exit-empty", "off"],
+            ["set-option", "-g", "destroy-unattached", "off"],
+        ]),
+    ]);
+
+    if (result.exitCode !== 0) {
+        logger.debug(
+            { exitCode: result.exitCode, detail: tmuxErrorDetail(result.stderr) },
+            "ensureTmuxServerPersists: tmux batch failed"
+        );
+        return;
     }
+
+    // Only latch on success — a failure (e.g. `set-environment -gu` on a var
+    // that a wedged server rejects) should be retried on the next touch.
+    lastServerPersistAt = Date.now();
 }
 
-export function killTmuxSession(sessionName: string): void {
+export async function killTmuxSession(sessionName: string): Promise<void> {
     const tmuxBin = resolveTmuxBin();
-    spawnSyncImpl([tmuxBin, "kill-session", "-t", sessionName]);
+    await runTmux([tmuxBin, "kill-session", "-t", sessionName]);
 }
 
 /**
  * Hand the controlling terminal to `tmux attach-session`. Replaces our stdio with
  * tmux's; control returns on detach (C-b d) or session kill. The caller MUST guard
  * for a TTY first — attaching without one fails. Throws on a non-zero exit.
+ *
+ * Deliberately sync: this is a CLI-only TTY handoff that blocks until the user
+ * detaches — there is no event loop to protect.
  */
 export function attachTmuxSession(sessionName: string): void {
     const tmuxBin = resolveTmuxBin();
@@ -305,7 +413,7 @@ export function attachTmuxSession(sessionName: string): void {
     }
 }
 
-export function renameTmuxSession(fromName: string, toName: string): void {
+export async function renameTmuxSession(fromName: string, toName: string): Promise<void> {
     const tmuxBin = resolveTmuxBin();
     const trimmed = toName.trim();
 
@@ -313,15 +421,15 @@ export function renameTmuxSession(fromName: string, toName: string): void {
         throw new Error("tmux session name cannot be empty");
     }
 
-    if (!sessionExists(fromName)) {
+    if (!(await sessionExists(fromName))) {
         throw new Error(`tmux session ${fromName} does not exist`);
     }
 
-    if (fromName !== trimmed && sessionExists(trimmed)) {
+    if (fromName !== trimmed && (await sessionExists(trimmed))) {
         throw new Error(`tmux session ${trimmed} already exists`);
     }
 
-    const result = spawnSyncImpl([tmuxBin, "rename-session", "-t", fromName, trimmed]);
+    const result = await runTmux([tmuxBin, "rename-session", "-t", fromName, trimmed]);
 
     if (result.exitCode !== 0) {
         throw new Error(`Failed to rename tmux session ${fromName}${tmuxErrorDetail(result.stderr)}`);
@@ -351,7 +459,7 @@ export interface TmuxScrollState {
  * reported by tmux in copy-mode, so it reads as 0 (live bottom) when `inMode` is
  * false. Returns null if tmux is unavailable or the session is gone.
  */
-export function getTmuxScrollState(sessionName: string): TmuxScrollState | null {
+export async function getTmuxScrollState(sessionName: string): Promise<TmuxScrollState | null> {
     let tmuxBin: string;
 
     try {
@@ -361,7 +469,7 @@ export function getTmuxScrollState(sessionName: string): TmuxScrollState | null
         return null;
     }
 
-    const result = spawnSyncImpl([
+    const result = await runTmux([
         tmuxBin,
         "display-message",
         "-p",
@@ -392,7 +500,7 @@ export function getTmuxScrollState(sessionName: string): TmuxScrollState | null
  * a fraction at/near the bottom cancels copy-mode so the pane follows live output
  * again; otherwise it parks at the exact line via history-bottom + N scroll-up.
  */
-export function scrollTmuxToFraction(sessionName: string, fraction: number): void {
+export async function scrollTmuxToFraction(sessionName: string, fraction: number): Promise<void> {
     if (!Number.isFinite(fraction)) {
         return;
     }
@@ -406,7 +514,7 @@ export function scrollTmuxToFraction(sessionName: string, fraction: number): voi
         return;
     }
 
-    const state = getTmuxScrollState(sessionName);
+    const state = await getTmuxScrollState(sessionName);
 
     if (!state) {
         return;
@@ -417,16 +525,22 @@ export function scrollTmuxToFraction(sessionName: string, fraction: number): voi
 
     if (fromBottom <= 0) {
         if (state.inMode) {
-            spawnSyncImpl([tmuxBin, "send-keys", "-t", sessionName, "-X", "cancel"]);
+            await runTmux([tmuxBin, "send-keys", "-t", sessionName, "-X", "cancel"]);
         }
 
         return;
     }
 
     if (!state.inMode) {
-        spawnSyncImpl([tmuxBin, "copy-mode", "-t", sessionName]);
+        await runTmux([tmuxBin, "copy-mode", "-t", sessionName]);
     }
 
-    spawnSyncImpl([tmuxBin, "send-keys", "-t", sessionName, "-X", "history-bottom"]);
-    spawnSyncImpl([tmuxBin, "send-keys", "-t", sessionName, "-X", "-N", String(fromBottom), "scroll-up"]);
+    // One invocation: park at the bottom of history, then step up N lines.
+    await runTmux([
+        tmuxBin,
+        ...chainTmuxCommands([
+            ["send-keys", "-t", sessionName, "-X", "history-bottom"],
+            ["send-keys", "-t", sessionName, "-X", "-N", String(fromBottom), "scroll-up"],
+        ]),
+    ]);
 }
diff --git a/src/utils/tmux/snapshot-last-cmd.test.ts b/src/utils/tmux/snapshot-last-cmd.test.ts
new file mode 100644
index 000000000..654c38b03
--- /dev/null
+++ b/src/utils/tmux/snapshot-last-cmd.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { isPlausibleLastShellCommand } from "@genesiscz/utils/tmux/snapshot";
+
+describe("isPlausibleLastShellCommand", () => {
+    test("accepts normal commands", () => {
+        expect(isPlausibleLastShellCommand("bun run test")).toBe(true);
+        expect(isPlausibleLastShellCommand("git status")).toBe(true);
+        expect(isPlausibleLastShellCommand("./scripts/foo.sh --flag")).toBe(true);
+    });
+
+    test("rejects SGR mouse / CSI junk from ttyd scrollback", () => {
+        expect(isPlausibleLastShellCommand("GenesisTools git:(master) 997;1n997;1n35;162;2M35;160;2M35;158;2M")).toBe(
+            false
+        );
+        expect(isPlausibleLastShellCommand("35;162;2M35;160;2M")).toBe(false);
+    });
+
+    test("rejects wrapped oh-my-zsh prompt chrome", () => {
+        expect(
+            isPlausibleLastShellCommand(
+                "GenesisTools\n➜  GenesisTools git:(master)\n➜  GenesisTools git:(master) 997;1n35;162;2M"
+            )
+        ).toBe(false);
+        expect(isPlausibleLastShellCommand("GenesisTools ➜  GenesisTools git:(master)")).toBe(false);
+        expect(isPlausibleLastShellCommand("GenesisTools")).toBe(false);
+        expect(isPlausibleLastShellCommand("GenesisTools git:(master)")).toBe(false);
+    });
+});
diff --git a/src/utils/tmux/snapshot.ts b/src/utils/tmux/snapshot.ts
index ce9b9a92b..144283b0d 100644
--- a/src/utils/tmux/snapshot.ts
+++ b/src/utils/tmux/snapshot.ts
@@ -1,14 +1,24 @@
 import { env } from "@genesiscz/utils/env";
 import { logger } from "@genesiscz/utils/logger";
+import { stripAnsi } from "@genesiscz/utils/string";
 import { resolveTmuxBin } from "@genesiscz/utils/tmux/bin";
 import {
     createTmuxSession,
     killTmuxSession,
     sessionExists,
     setTmuxSpawnSyncForTests,
+    type TmuxSpawnResult,
     type TmuxSpawnSync,
 } from "@genesiscz/utils/tmux/sessions";
 
+/**
+ * Snapshot capture/replay stays synchronous: it runs in CLI flows (presets
+ * save/restore, reset) with no event loop to protect, and its pane walk is a
+ * tight sequential pipeline. Only the shared create/kill/exists calls above go
+ * through the async sessions module.
+ */
+type SyncTmuxSpawn = (cmd: string[], opts?: { cwd?: string }) => TmuxSpawnResult;
+
 export const SNAPSHOT_VERSION = 1 as const;
 
 export interface TmuxPaneSnapshot {
@@ -60,7 +70,7 @@ const PANE_LIST_FORMAT = [
     "#{pane_pid}",
 ].join("\t");
 
-const defaultSpawnSync: TmuxSpawnSync = (cmd, opts) => {
+const defaultSpawnSync: SyncTmuxSpawn = (cmd, opts) => {
     const result = Bun.spawnSync(cmd, {
         cwd: opts?.cwd,
         stdio: ["ignore", "pipe", "pipe"],
@@ -72,12 +82,12 @@ const defaultSpawnSync: TmuxSpawnSync = (cmd, opts) => {
     };
 };
 
-let spawnImpl: TmuxSpawnSync = defaultSpawnSync;
+let spawnImpl: SyncTmuxSpawn = defaultSpawnSync;
 
 /** Override spawn for tests. Also forwards to sessions.ts so create/kill mock too. */
-export function setTmuxSnapshotSpawnForTests(impl: TmuxSpawnSync | null): void {
+export function setTmuxSnapshotSpawnForTests(impl: SyncTmuxSpawn | null): void {
     spawnImpl = impl ?? defaultSpawnSync;
-    setTmuxSpawnSyncForTests(impl);
+    setTmuxSpawnSyncForTests(impl satisfies TmuxSpawnSync | null);
 }
 
 export interface CaptureOptions {
@@ -266,14 +276,19 @@ function parseLastShellCommand(
             const parts = [candidate];
             for (let j = i + 1; j < lines.length && parts.length < 5; j += 1) {
                 const cont = lines[j]?.trimEnd();
-                if (!cont || extractPromptCommand(cont) || isOutputLine(cont)) {
+                if (!cont || extractPromptCommand(cont) || isOutputLine(cont) || isPromptChromeOrControlJunk(cont)) {
                     break;
                 }
 
                 parts.push(cont);
             }
 
-            return parts.join("\n");
+            const joined = parts.join("\n");
+            if (!isPlausibleLastShellCommand(joined)) {
+                continue;
+            }
+
+            return joined;
         }
     }
 
@@ -282,8 +297,17 @@ function parseLastShellCommand(
 
 const PROMPT_LINE = /^[^\s$#%❯➜]*[$#%❯➜]\s+(.+?)\s*$/;
 
+/** SGR mouse / CSI leftovers that leak into the tty when mouse mode is on (e.g. in ttyd). */
+const CONTROL_JUNK_RE = /\d+;\d+[A-Za-z]|;\d*n|\b997;\d/;
+
+/**
+ * Oh-my-zsh / similar put `dir git:(branch)` on the same line after `➜` with no command —
+ * that must not be treated as a typed command.
+ */
+const PROMPT_REMANT_RE = /^[\w./-]+\s+git:\([^)]*\)/;
+
 function extractPromptCommand(line: string): string | undefined {
-    const match = PROMPT_LINE.exec(line);
+    const match = PROMPT_LINE.exec(stripAnsi(line));
     if (!match) {
         return undefined;
     }
@@ -298,9 +322,68 @@ function extractPromptCommand(line: string): string | undefined {
         return undefined;
     }
 
+    if (!isPlausibleLastShellCommand(cmd)) {
+        return undefined;
+    }
+
     return cmd;
 }
 
+function isPromptChromeOrControlJunk(line: string): boolean {
+    const plain = stripAnsi(line).trim();
+
+    if (!plain) {
+        return true;
+    }
+
+    // Another prompt glyph mid-scrollback — not a multi-line command continuation.
+    if (/[$#%❯➜]/.test(plain)) {
+        return true;
+    }
+
+    return !isPlausibleLastShellCommand(plain);
+}
+
+/** Exported for unit tests — keep `last:` free of mouse/CSI junk and prompt chrome. */
+export function isPlausibleLastShellCommand(cmd: string): boolean {
+    const trimmed = cmd.trim();
+
+    if (!trimmed) {
+        return false;
+    }
+
+    if (CONTROL_JUNK_RE.test(trimmed)) {
+        return false;
+    }
+
+    if (PROMPT_REMANT_RE.test(trimmed)) {
+        return false;
+    }
+
+    // Prompt glyphs that leaked into the captured "command" (wrapped oh-my-zsh lines).
+    if (/[❯➜]/.test(trimmed)) {
+        return false;
+    }
+
+    // Single CapitalizedToken — almost always the directory segment of `➜  DirName`, not a command.
+    if (/^[A-Z][A-Za-z0-9_.-]*$/.test(trimmed)) {
+        return false;
+    }
+
+    // Claude / agent statusline fragments scraped out of scrollback.
+    if (/·|resets in|\d+h\s+\d+%/.test(trimmed)) {
+        return false;
+    }
+
+    // Dense digit/semicolon runs = pasted mouse reports, not a shell command.
+    const junkChars = (trimmed.match(/[0-9;]/g) ?? []).length;
+    if (trimmed.length >= 24 && junkChars / trimmed.length > 0.35) {
+        return false;
+    }
+
+    return true;
+}
+
 const OUTPUT_MARKERS = /^\s*[⎿✅❌⏵─│┌└├]+|^\s{6,}/;
 function isOutputLine(line: string): boolean {
     return OUTPUT_MARKERS.test(line);
@@ -329,11 +412,14 @@ function runTmux(tmuxBin: string, args: string[], op: string): string {
     return result.stdout;
 }
 
-export function restoreTmuxSession(snapshot: TmuxSessionSnapshot, opts: RestoreOptions = {}): RestoreOutcome {
+export async function restoreTmuxSession(
+    snapshot: TmuxSessionSnapshot,
+    opts: RestoreOptions = {}
+): Promise<RestoreOutcome> {
     const tmuxBin = resolveTmuxBin();
     const targetName = resolveTargetName(snapshot.name, opts.nameSuffix);
 
-    if (sessionExists(targetName)) {
+    if (await sessionExists(targetName)) {
         return {
             name: snapshot.name,
             sessionName: targetName,
@@ -347,7 +433,7 @@ export function restoreTmuxSession(snapshot: TmuxSessionSnapshot, opts: RestoreO
     const firstPane = firstWindow?.panes[0];
     const firstCwd = firstPane?.cwd ?? snapshot.cwd ?? process.cwd();
 
-    createTmuxSession(targetName, firstCwd, env.paths.getShell("/bin/zsh"));
+    await createTmuxSession(targetName, firstCwd, env.paths.getShell("/bin/zsh"));
 
     if (firstWindow?.name) {
         runTmux(tmuxBin, ["rename-window", "-t", `${targetName}:0`, firstWindow.name], "rename-window");
@@ -433,16 +519,16 @@ function resolveTargetName(baseName: string, suffix?: string): string {
  * Kill all sessions matching `prefix`. Returns the names of sessions actually
  * killed. Idempotent — names that no longer exist are silently skipped.
  */
-export function killTmuxSessionsMatching(names: string[]): string[] {
+export async function killTmuxSessionsMatching(names: string[]): Promise<string[]> {
     const killed: string[] = [];
 
     for (const name of names) {
-        if (!sessionExists(name)) {
+        if (!(await sessionExists(name))) {
             continue;
         }
 
         try {
-            killTmuxSession(name);
+            await killTmuxSession(name);
             killed.push(name);
         } catch (error) {
             logger.warn({ error, name }, "killTmuxSessionsMatching: failed to kill session");

From 74e7b081bf33835f555acf48a3f41be07ca1e975 Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 16:59:45 +0200
Subject: [PATCH 4/6] fix(dev-dashboard): sanitize dots in Claude pane titles
 (tmux target separators, munged to _ on rename)

---
 src/dev-dashboard/lib/tmux/claude-pane-title.test.ts | 6 ++++++
 src/dev-dashboard/lib/tmux/claude-pane-title.ts      | 6 ++++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
index 24f3401e2..446b61bfd 100644
--- a/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
@@ -12,6 +12,12 @@ describe("parseClaudePaneTitle", () => {
         expect(parseClaudePaneTitle("✳ Debug formatting: spacing")).toBe("Debug formatting- spacing");
     });
 
+    test("sanitizes dots — tmux target-syntax separators that 3.6a silently munges to _ on rename", () => {
+        expect(parseClaudePaneTitle("✳ Fix v1.2 bug")).toBe("Fix v1-2 bug");
+        // Unicode ellipsis is NOT a dot — Claude's truncated auto-topic titles keep it.
+        expect(parseClaudePaneTitle("✳ Analyze slow HAR file load…")).toBe("Analyze slow HAR file load…");
+    });
+
     test("rejects non-Claude titles and the stock default", () => {
         expect(parseClaudePaneTitle("zsh")).toBeNull();
         expect(parseClaudePaneTitle("/Users/me/proj")).toBeNull();
diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
index 4796e09de..e831b4b74 100644
--- a/src/dev-dashboard/lib/tmux/claude-pane-title.ts
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
@@ -26,8 +26,10 @@ export function parseClaudePaneTitle(title: string | undefined | null): string |
         return null;
     }
 
-    // tmux session names cannot contain `:`. Collapse whitespace; keep the rest.
-    const name = match[1].replace(/:/g, "-").replace(/\s+/g, " ").trim();
+    // tmux session names cannot contain `:` or `.` — both are target-syntax separators.
+    // tmux 3.6a even silently munges a renamed session's dots to `_`, which would desync
+    // the stored binding name from the real session. Collapse whitespace; keep the rest.
+    const name = match[1].replace(/[:.]/g, "-").replace(/\s+/g, " ").trim();
 
     if (!name || CLAUDE_DEFAULT_TITLES.has(name.toLowerCase())) {
         return null;

From c2035c822d4f5cb373e426e7342786f913c02a23 Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 18:13:19 +0200
Subject: [PATCH 5/6] feat(dev-dashboard): surface tmux active-pane
 command/cwd/title/activity for every session, accept all braille spinner
 frames

---
 src/dev-dashboard/contract/dto.ts             |  8 +++
 .../lib/tmux/claude-pane-title.test.ts        |  8 +++
 .../lib/tmux/claude-pane-title.ts             | 11 +++-
 .../ui/src/components/TmuxSessionsPanel.tsx   | 55 ++++++++++++++++++-
 src/dev-dashboard/ui/src/lib/api.ts           |  8 +++
 src/utils/tmux/sessions.ts                    | 29 ++++++++--
 src/utils/tmux/types.ts                       | 14 +++++
 7 files changed, 123 insertions(+), 10 deletions(-)

diff --git a/src/dev-dashboard/contract/dto.ts b/src/dev-dashboard/contract/dto.ts
index 4545ae78e..4c7c8a6a5 100644
--- a/src/dev-dashboard/contract/dto.ts
+++ b/src/dev-dashboard/contract/dto.ts
@@ -113,6 +113,14 @@ export interface TmuxHubSession {
     name: string;
     attached: number;
     windows: number;
+    /** Active-pane facts from tmux itself — the only meta available for a session with no ttyd. */
+    command?: string;
+    cwd?: string;
+    /** Raw `#{pane_title}`: Claude's `<spinner> <topic>`, a shell's own title, or absent. */
+    title?: string;
+    /** Unix seconds. */
+    created?: number;
+    lastActivity?: number;
     ttydTabIds: string[];
     ttydTabs: Array<{
         id: string;
diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
index 446b61bfd..b89eca0cc 100644
--- a/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.test.ts
@@ -8,6 +8,14 @@ describe("parseClaudePaneTitle", () => {
         expect(parseClaudePaneTitle("* testt")).toBe("testt");
     });
 
+    test("accepts every animated braille spinner frame, not just U+2810", () => {
+        // Observed live: a running session's title read `⠂ ttyd-naming` (U+2802) and parsed as null,
+        // so the sync silently succeeded or failed depending on poll timing.
+        for (const marker of ["⠂", "⠈", "⠠", "⣾", "⠋", "⠿", "⠀"]) {
+            expect(parseClaudePaneTitle(`${marker} ttyd-naming`)).toBe("ttyd-naming");
+        }
+    });
+
     test("keeps multi-word titles and sanitizes colons", () => {
         expect(parseClaudePaneTitle("✳ Debug formatting: spacing")).toBe("Debug formatting- spacing");
     });
diff --git a/src/dev-dashboard/lib/tmux/claude-pane-title.ts b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
index e831b4b74..e957e251a 100644
--- a/src/dev-dashboard/lib/tmux/claude-pane-title.ts
+++ b/src/dev-dashboard/lib/tmux/claude-pane-title.ts
@@ -1,10 +1,15 @@
 /**
- * Claude Code sets the tmux pane title via OSC to `✳ <name>` (working) or `⠐ <name>` (idle)
- * after `/rename`. Strip that marker so we can mirror the name onto the tmux session + ttyd tab.
+ * Claude Code sets the tmux pane title via OSC to `<marker> <name>`. Strip the marker so we can
+ * mirror the name onto the tmux session + ttyd tab.
+ *
+ * The marker is `✳` while working, and otherwise an ANIMATED BRAILLE SPINNER FRAME — not a single
+ * fixed glyph. Matching only `⠐` (U+2810) made the sync succeed or fail depending on which frame
+ * happened to be current at poll time: a live session observed here read `⠂ ttyd-naming` (U+2802)
+ * and parsed as null. Accept the whole Braille Patterns block (U+2800–U+28FF).
  *
  * @see src/cmux/docs/Cmux.md — same title convention on cmux surfaces.
  */
-const CLAUDE_PANE_TITLE_RE = /^[✳⠐*]\s*(.+)$/u;
+const CLAUDE_PANE_TITLE_RE = /^[✳*⠀-⣿]\s*(.+)$/u;
 
 /** Stock title before the user runs `/rename` — never promote this to a session name. */
 const CLAUDE_DEFAULT_TITLES = new Set(["claude code", "claude"]);
diff --git a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
index 77f9a14de..ca1c1782f 100644
--- a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
+++ b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
@@ -184,9 +184,13 @@ function SessionRow({
 }) {
     const alreadyInTtyd = (session.ttydTabs?.length ?? session.ttydTabIds.length) > 0;
     const primaryTab = session.ttydTabs?.[0];
-    const cwd = primaryTab?.cwd;
-    const lastCommand = primaryTab?.lastCommand;
+    // Fall back to tmux's own active-pane facts. Reading these only off the ttyd binding left every
+    // unbound session (a plain `tools tmux create`) rendering as a bare name with no meta at all.
+    const cwd = primaryTab?.cwd ?? session.cwd;
+    const lastCommand = primaryTab?.lastCommand ?? session.command;
     const shortCwd = cwd ? shortenPath(cwd) : null;
+    const topic = claudeTopicFromTitle(session.title);
+    const idleFor = session.lastActivity ? formatSinceSeconds(session.lastActivity) : null;
 
     return (
         <BezelCard
@@ -211,9 +215,15 @@ function SessionRow({
                         {session.inCmux && session.cmuxSurfaces.length > 0
                             ? ` · cmux ×${session.cmuxSurfaces.length}`
                             : ""}
+                        {idleFor ? ` · active ${idleFor} ago` : ""}
                     </p>
+                    {topic ? (
+                        <p className="truncate font-mono text-[10px] text-emerald-300/80" title={session.title}>
+                            {topic}
+                        </p>
+                    ) : null}
                     {shortCwd || lastCommand ? (
-                        <p className="truncate font-mono text-[10px] text-zinc-400">
+                        <p className="truncate font-mono text-[10px] text-zinc-400" title={cwd}>
                             {lastCommand ? <span className="text-amber-400/90">{lastCommand}</span> : null}
                             {lastCommand && shortCwd ? <span className="text-zinc-600"> · </span> : null}
                             {shortCwd ? <span>{shortCwd}</span> : null}
@@ -266,6 +276,45 @@ function SessionRow({
     );
 }
 
+/**
+ * The Claude topic out of a raw `#{pane_title}`, or null for a shell's own title (hostname, cwd).
+ * Client-side twin of the server's `parseClaudePaneTitle` — kept separate because that module is
+ * server-only and this is display-only (no name promotion, so a looser read is safe here).
+ */
+function claudeTopicFromTitle(title: string | undefined): string | null {
+    if (!title) {
+        return null;
+    }
+
+    // `✳` while working, otherwise an animated Braille spinner frame (U+2800–U+28FF).
+    const match = title.trim().match(/^[✳*⠀-⣿]\s*(.+)$/u);
+    const topic = match?.[1]?.trim();
+
+    return topic && topic.toLowerCase() !== "claude code" ? topic : null;
+}
+
+function formatSinceSeconds(unixSeconds: number): string | null {
+    const seconds = Math.floor(Date.now() / 1000) - unixSeconds;
+
+    if (!Number.isFinite(seconds) || seconds < 0) {
+        return null;
+    }
+
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+
+    if (seconds < 3600) {
+        return `${Math.floor(seconds / 60)}m`;
+    }
+
+    if (seconds < 86_400) {
+        return `${Math.floor(seconds / 3600)}h`;
+    }
+
+    return `${Math.floor(seconds / 86_400)}d`;
+}
+
 function shortenPath(path: string): string {
     const home = "/Users/";
     if (path.startsWith(home)) {
diff --git a/src/dev-dashboard/ui/src/lib/api.ts b/src/dev-dashboard/ui/src/lib/api.ts
index 9a323f97c..a3d8d1a42 100644
--- a/src/dev-dashboard/ui/src/lib/api.ts
+++ b/src/dev-dashboard/ui/src/lib/api.ts
@@ -25,6 +25,14 @@ export interface TmuxHubSession {
     name: string;
     attached: number;
     windows: number;
+    /** Active-pane facts from tmux itself — the only meta available for a session with no ttyd. */
+    command?: string;
+    cwd?: string;
+    /** Raw `#{pane_title}`: Claude's `<spinner> <topic>`, a shell's own title, or absent. */
+    title?: string;
+    /** Unix seconds. */
+    created?: number;
+    lastActivity?: number;
     ttydTabIds: string[];
     ttydTabs: Array<{
         id: string;
diff --git a/src/utils/tmux/sessions.ts b/src/utils/tmux/sessions.ts
index 8a08b3d15..3f989bf08 100644
--- a/src/utils/tmux/sessions.ts
+++ b/src/utils/tmux/sessions.ts
@@ -180,11 +180,23 @@ export async function listTmuxSessions(): Promise<TmuxSessionInfo[]> {
         return [];
     }
 
+    // Every extra field here is a format column on the SAME call, not another round-trip, so the
+    // richer payload is free. `pane_title` is last because it is the only field that can itself
+    // contain arbitrary user text.
     const result = await runTmux([
         tmuxBin,
         "list-sessions",
         "-F",
-        "#{session_name}\t#{session_attached}\t#{session_windows}",
+        [
+            "#{session_name}",
+            "#{session_attached}",
+            "#{session_windows}",
+            "#{pane_current_command}",
+            "#{pane_current_path}",
+            "#{session_created}",
+            "#{session_activity}",
+            "#{pane_title}",
+        ].join("\t"),
     ]);
 
     if (result.exitCode !== 0) {
@@ -194,20 +206,29 @@ export async function listTmuxSessions(): Promise<TmuxSessionInfo[]> {
     const sessions: TmuxSessionInfo[] = [];
 
     for (const line of result.stdout.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed) {
+        const trimmed = line.trimEnd();
+        if (!trimmed.trim()) {
             continue;
         }
 
-        const [name, attachedRaw, windowsRaw] = trimmed.split("\t");
+        const [name, attachedRaw, windowsRaw, command, cwd, createdRaw, activityRaw, ...titleParts] =
+            trimmed.split("\t");
         if (!name) {
             continue;
         }
 
+        const created = Number.parseInt(createdRaw ?? "", 10);
+        const lastActivity = Number.parseInt(activityRaw ?? "", 10);
+
         sessions.push({
             name,
             attached: Number.parseInt(attachedRaw ?? "0", 10) || 0,
             windows: Number.parseInt(windowsRaw ?? "0", 10) || 0,
+            command: command?.trim() || undefined,
+            cwd: cwd?.trim() || undefined,
+            title: titleParts.join("\t").trim() || undefined,
+            created: Number.isFinite(created) ? created : undefined,
+            lastActivity: Number.isFinite(lastActivity) ? lastActivity : undefined,
         });
     }
 
diff --git a/src/utils/tmux/types.ts b/src/utils/tmux/types.ts
index 2d8e995f2..1e8a7a506 100644
--- a/src/utils/tmux/types.ts
+++ b/src/utils/tmux/types.ts
@@ -2,4 +2,18 @@ export interface TmuxSessionInfo {
     name: string;
     attached: number;
     windows: number;
+    /**
+     * Active-pane facts, straight from tmux. These carry the ONLY information available for a
+     * session with no ttyd binding (the dashboard used to read command/cwd off the ttyd session,
+     * so a plain `tools tmux create` session rendered as a bare name with no meta at all).
+     * All of it rides the same single `list-sessions` call as the fields above.
+     */
+    command?: string;
+    cwd?: string;
+    /** Raw `#{pane_title}` — Claude Code's `<spinner> <topic>`, a shell's own title, or empty. */
+    title?: string;
+    /** Unix seconds. */
+    created?: number;
+    /** Unix seconds of the last activity in the session. */
+    lastActivity?: number;
 }

From 7c3c7f082043c0369a0f0ef2be2e503828298765 Mon Sep 17 00:00:00 2001
From: Martin <admin@phpcode.eu>
Date: Mon, 3 Aug 2026 18:29:01 +0200
Subject: [PATCH 6/6] fix(dev-dashboard): separate session name from Claude
 title, stop the title clobbering renames

---
 src/dev-dashboard/contract/dto.ts             |   1 +
 src/dev-dashboard/lib/tmux/hub.ts             |   5 +
 src/dev-dashboard/lib/ttyd/manager.ts         | 100 ++++--------------
 src/dev-dashboard/lib/ttyd/types.ts           |   6 ++
 .../ui/src/components/TmuxSessionsPanel.tsx   |   4 +-
 src/dev-dashboard/ui/src/lib/api.ts           |   1 +
 src/dev-dashboard/ui/src/lib/terminal-tabs.ts |   4 +
 src/dev-dashboard/ui/src/routes/ttyd.tsx      |   1 +
 8 files changed, 43 insertions(+), 79 deletions(-)

diff --git a/src/dev-dashboard/contract/dto.ts b/src/dev-dashboard/contract/dto.ts
index 4c7c8a6a5..55dfca150 100644
--- a/src/dev-dashboard/contract/dto.ts
+++ b/src/dev-dashboard/contract/dto.ts
@@ -128,6 +128,7 @@ export interface TmuxHubSession {
         label: string;
         cwd?: string;
         lastCommand?: string;
+        title?: string;
     }>;
     canAttachInTtyd: boolean;
     cmuxSurfaces: Array<{ workspaceId: string; surfaceId: string; title: string }>;
diff --git a/src/dev-dashboard/lib/tmux/hub.ts b/src/dev-dashboard/lib/tmux/hub.ts
index bdd7ff6cc..5fb206057 100644
--- a/src/dev-dashboard/lib/tmux/hub.ts
+++ b/src/dev-dashboard/lib/tmux/hub.ts
@@ -5,9 +5,12 @@ import type { TmuxSessionInfo } from "@genesiscz/utils/tmux/types";
 export interface TtydHubTab {
     id: string;
     port: number;
+    /** Identity. Never Claude's topic — see the name-vs-title note in ttyd/manager.ts. */
     label: string;
     cwd?: string;
     lastCommand?: string;
+    /** Claude's live topic, shown alongside the label rather than replacing it. */
+    title?: string;
 }
 
 export interface TmuxHubSession extends TmuxSessionInfo {
@@ -26,6 +29,7 @@ interface TtydBinding {
     tmuxSessionName?: string;
     name?: string;
     lastCommand?: string;
+    title?: string;
 }
 
 export function enrichSessionsForHub(
@@ -46,6 +50,7 @@ export function enrichSessionsForHub(
             label: ttydLabel(ttyd),
             cwd: ttyd.cwd,
             lastCommand: ttyd.lastCommand,
+            title: ttyd.title,
         };
         const existing = ttydByTmux.get(ttyd.tmuxSessionName) ?? [];
         existing.push(tab);
diff --git a/src/dev-dashboard/lib/ttyd/manager.ts b/src/dev-dashboard/lib/ttyd/manager.ts
index a37c877e4..46bf8f71a 100644
--- a/src/dev-dashboard/lib/ttyd/manager.ts
+++ b/src/dev-dashboard/lib/ttyd/manager.ts
@@ -19,6 +19,7 @@ import {
     listTmuxSessionActivePanes,
     renameTmuxSession,
     sessionExists,
+    type TmuxActivePaneInfo,
 } from "@genesiscz/utils/tmux/sessions";
 import type { Subprocess } from "bun";
 
@@ -655,96 +656,39 @@ export async function listTtyd(): Promise<TtydSession[]> {
     ]);
 
     await prof.measureAsync("list.heal", () => healStaleTtydTmuxTargets(new Set(panesByTmux.keys())));
-    // Can escalate into a tmux rename + full ttyd kill/relaunch inside this GET.
-    await prof.measureAsync("list.syncClaudeNames", () => syncNamesFromClaudePaneTitles(panesByTmux));
 
     return Array.from(registry.values()).map((tracked) => {
         const { session } = tracked;
         const pane = session.tmuxSessionName ? panesByTmux.get(session.tmuxSessionName) : undefined;
 
-        return { ...session, lastCommand: pane?.command || undefined };
+        return {
+            ...session,
+            lastCommand: pane?.command || undefined,
+            title: claudeTopicForPane(pane) ?? undefined,
+        };
     });
 }
 
 /**
- * Claude `/rename` only updates `#{pane_title}` (`✳ name`). Mirror that onto the real tmux
- * session name + ttyd display label so Session Hub / tabs stay in sync.
+ * NAME vs TITLE. These are two different things and neither may overwrite the other:
+ *
+ *   - `name` is IDENTITY. It comes from the tmux session name or an explicit rename (tab pencil,
+ *     hub rename, cmux rename) and is what every surface labels the session with.
+ *   - `title` is Claude Code's live topic, read off `#{pane_title}`. It is a derived, ephemeral
+ *     fact — Claude re-summarizes mid-session and animates a spinner marker in front of it.
+ *
+ * This used to promote the title INTO the name (renaming the real tmux session and rewriting
+ * `session.name`), which silently destroyed manual names: a tab renamed "aaa" came back as
+ * "testt" the moment Claude re-emitted its topic. Auto-topics and `/rename` ride the exact same
+ * OSC escape, so there is no way to honour only the deliberate ones. Surface the topic alongside
+ * the name instead and let the name win wherever a single label is shown.
  */
-async function syncNamesFromClaudePaneTitles(
-    panesByTmux: Awaited<ReturnType<typeof listTmuxSessionActivePanes>>
-): Promise<void> {
-    // Snapshot first — retarget mutates registry bindings mid-loop.
-    const candidates = Array.from(registry.values())
-        .map((tracked) => {
-            const fromName = tracked.session.tmuxSessionName;
-
-            if (!fromName) {
-                return null;
-            }
-
-            const pane = panesByTmux.get(fromName);
-
-            if (!pane || !isClaudeForegroundCommand(pane.command)) {
-                return null;
-            }
-
-            const toName = parseClaudePaneTitle(pane.title);
-
-            if (!toName || toName === fromName) {
-                // Tmux already matches; still mirror a stale ttyd display name.
-                if (toName && tracked.session.name !== toName) {
-                    return { id: tracked.session.id, fromName, toName, renameTmux: false };
-                }
-
-                return null;
-            }
-
-            return { id: tracked.session.id, fromName, toName, renameTmux: true };
-        })
-        .filter((c): c is { id: string; fromName: string; toName: string; renameTmux: boolean } => c !== null);
-
-    if (candidates.length === 0) {
-        return;
+function claudeTopicForPane(pane: TmuxActivePaneInfo | undefined): string | null {
+    if (!pane || !isClaudeForegroundCommand(pane.command)) {
+        return null;
     }
 
-    for (const { id, fromName, toName, renameTmux } of candidates) {
-        try {
-            if (renameTmux) {
-                // The pane map's keys are the full live session-name set from this
-                // poll's single list-sessions — no extra tmux call for the clash check.
-                if (panesByTmux.has(toName)) {
-                    logger.debug(
-                        { id, fromName, toName },
-                        "claude pane title sync skipped: destination tmux session already exists"
-                    );
-                    continue;
-                }
-
-                await renameTmuxSession(fromName, toName);
-                await retargetTtydTmuxBindings(fromName, toName);
-
-                // Retarget updates bindings under the new name; refresh the pane map key for later reads.
-                const pane = panesByTmux.get(fromName);
-
-                if (pane) {
-                    panesByTmux.delete(fromName);
-                    panesByTmux.set(toName, pane);
-                }
-            }
-
-            const tracked = registry.get(id);
-
-            if (!tracked) {
-                continue;
-            }
-
-            tracked.session.name = toName;
-            await persistRegistry();
-            logger.info({ id, fromName, toName, renameTmux }, "synced tmux/ttyd name from Claude pane title (/rename)");
-        } catch (err) {
-            logger.debug({ err, id, fromName, toName }, "claude pane title sync failed");
-        }
-    }
+    return parseClaudePaneTitle(pane.title);
 }
 
 /**
diff --git a/src/dev-dashboard/lib/ttyd/types.ts b/src/dev-dashboard/lib/ttyd/types.ts
index 56f9ff902..196b93224 100644
--- a/src/dev-dashboard/lib/ttyd/types.ts
+++ b/src/dev-dashboard/lib/ttyd/types.ts
@@ -17,6 +17,12 @@ export interface TtydSession {
      * a tmux binding exists. NOT persisted — derived live fact, recomputed each read.
      */
     lastCommand?: string;
+    /**
+     * Claude Code's live topic from `#{pane_title}`, marker stripped. Informational ONLY: it is
+     * never promoted into `name`, because auto-topics and `/rename` are indistinguishable on the
+     * wire and promoting them destroyed manual names. NOT persisted — recomputed each read.
+     */
+    title?: string;
 }
 
 export type SplitNode =
diff --git a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
index ca1c1782f..03609ece8 100644
--- a/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
+++ b/src/dev-dashboard/ui/src/components/TmuxSessionsPanel.tsx
@@ -189,7 +189,9 @@ function SessionRow({
     const cwd = primaryTab?.cwd ?? session.cwd;
     const lastCommand = primaryTab?.lastCommand ?? session.command;
     const shortCwd = cwd ? shortenPath(cwd) : null;
-    const topic = claudeTopicFromTitle(session.title);
+    // Prefer the server-parsed topic from the bound ttyd; fall back to parsing tmux's raw
+    // pane title so unbound sessions (a plain `tools tmux create`) show it too.
+    const topic = primaryTab?.title ?? claudeTopicFromTitle(session.title);
     const idleFor = session.lastActivity ? formatSinceSeconds(session.lastActivity) : null;
 
     return (
diff --git a/src/dev-dashboard/ui/src/lib/api.ts b/src/dev-dashboard/ui/src/lib/api.ts
index a3d8d1a42..6bedd9097 100644
--- a/src/dev-dashboard/ui/src/lib/api.ts
+++ b/src/dev-dashboard/ui/src/lib/api.ts
@@ -40,6 +40,7 @@ export interface TmuxHubSession {
         label: string;
         cwd?: string;
         lastCommand?: string;
+        title?: string;
     }>;
     canAttachInTtyd: boolean;
     cmuxSurfaces: Array<{ workspaceId: string; surfaceId: string; title: string }>;
diff --git a/src/dev-dashboard/ui/src/lib/terminal-tabs.ts b/src/dev-dashboard/ui/src/lib/terminal-tabs.ts
index f1f967453..9ae43373c 100644
--- a/src/dev-dashboard/ui/src/lib/terminal-tabs.ts
+++ b/src/dev-dashboard/ui/src/lib/terminal-tabs.ts
@@ -3,8 +3,11 @@ import type { TtydSession } from "@app/dev-dashboard/lib/ttyd/types";
 
 export interface TermTab {
     id: string;
+    /** Identity: the session name. Never Claude's topic. */
     label: string;
     active: boolean;
+    /** Claude's live topic, rendered as secondary meta beside the label. */
+    lastLine?: string;
 }
 
 export function buildTtydTabs(sessions: TtydSession[], activeId: string | null): TermTab[] {
@@ -12,5 +15,6 @@ export function buildTtydTabs(sessions: TtydSession[], activeId: string | null):
         id: session.id,
         label: ttydLabel(session),
         active: session.id === activeId,
+        lastLine: session.title,
     }));
 }
diff --git a/src/dev-dashboard/ui/src/routes/ttyd.tsx b/src/dev-dashboard/ui/src/routes/ttyd.tsx
index e625f1b51..0fd528b21 100644
--- a/src/dev-dashboard/ui/src/routes/ttyd.tsx
+++ b/src/dev-dashboard/ui/src/routes/ttyd.tsx
@@ -400,6 +400,7 @@ export function TtydRoute() {
                             return (
                                 <MosaicWindow<string>
                                     path={path}
+                                    // Name wins in the topbar; Claude's live topic is separate meta.
                                     title={ttydLabel(session)}
                                     additionalControls={null}
                                     toolbarControls={