opencode-sesh 2.0.1 → 2.0.2

package/dist/tui.js

@@ -0,0 +1,4359 @@
+import { use as _$use } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+/** @jsxImportSource @opentui/solid */
+import { Plugin } from "@opencode/plugin/tui";
+import { createEffect, createMemo, createRoot, createSignal, For, getOwner, on, onCleanup, onMount, runWithOwner, Show } from "solid-js";
+import { mkdir, readFile, rename, rmdir, unlink, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { getTreeSitterClient, RGBA, SyntaxStyle, TextAttributes } from "@opentui/core";
+import { Portal } from "@opentui/solid";
+let markdownStyleCache;
+function buildMarkdownStyle(theme, owner) {
+  return SyntaxStyle.fromTheme([{
+    scope: ["default"],
+    style: {
+      foreground: theme.text
+    }
+  }, {
+    scope: ["comment", "comment.documentation"],
+    style: {
+      foreground: theme.syntaxComment,
+      italic: true
+    }
+  }, {
+    scope: ["string", "symbol", "character"],
+    style: {
+      foreground: theme.syntaxString
+    }
+  }, {
+    scope: ["number", "boolean", "constant", "float"],
+    style: {
+      foreground: theme.syntaxNumber
+    }
+  }, {
+    scope: ["keyword", "keyword.import", "keyword.directive", "keyword.modifier", "keyword.exception"],
+    style: {
+      foreground: theme.syntaxKeyword,
+      italic: true
+    }
+  }, {
+    scope: ["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine"],
+    style: {
+      foreground: theme.syntaxKeyword,
+      italic: true
+    }
+  }, {
+    scope: ["keyword.type"],
+    style: {
+      foreground: theme.syntaxType,
+      bold: true,
+      italic: true
+    }
+  }, {
+    scope: ["keyword.function", "function.method", "function", "constructor", "variable.member"],
+    style: {
+      foreground: theme.syntaxFunction
+    }
+  }, {
+    scope: ["operator", "keyword.operator", "punctuation.delimiter", "punctuation.special"],
+    style: {
+      foreground: theme.syntaxOperator
+    }
+  }, {
+    scope: ["variable", "variable.parameter", "function.method.call", "function.call", "property", "parameter"],
+    style: {
+      foreground: theme.syntaxVariable
+    }
+  }, {
+    scope: ["type", "module", "class"],
+    style: {
+      foreground: theme.syntaxType
+    }
+  }, {
+    scope: ["punctuation", "punctuation.bracket"],
+    style: {
+      foreground: theme.syntaxPunctuation
+    }
+  }, {
+    scope: ["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"],
+    style: {
+      foreground: theme.error
+    }
+  },
+  // Some opencode themes give Markdown roles the same foreground as body
+  // text. Use their semantic accents here so transcript structure remains
+  // legible without recoloring the surrounding TUI or ordinary prose.
+  {
+    scope: ["markup.heading"],
+    style: {
+      foreground: theme.accent,
+      bold: true
+    }
+  }, {
+    scope: ["markup.heading.1"],
+    style: {
+      foreground: theme.primary,
+      bold: true,
+      underline: true
+    }
+  }, {
+    scope: ["markup.heading.2", "markup.heading.3", "markup.heading.4", "markup.heading.5", "markup.heading.6"],
+    style: {
+      foreground: theme.accent,
+      bold: true
+    }
+  }, {
+    scope: ["markup.bold", "markup.strong"],
+    style: {
+      foreground: theme.accent,
+      bold: true
+    }
+  }, {
+    scope: ["markup.italic"],
+    style: {
+      foreground: theme.syntaxString,
+      italic: true
+    }
+  }, {
+    scope: ["markup.list"],
+    style: {
+      foreground: theme.syntaxKeyword
+    }
+  }, {
+    scope: ["markup.quote"],
+    style: {
+      foreground: theme.markdownBlockQuote,
+      italic: true
+    }
+  }, {
+    scope: ["markup.raw", "markup.raw.block"],
+    style: {
+      foreground: theme.syntaxString
+    }
+  }, {
+    scope: ["markup.raw.inline"],
+    style: {
+      foreground: theme.syntaxString,
+      background: theme.backgroundElement
+    }
+  }, {
+    scope: ["markup.link", "markup.link.url", "string.special", "string.special.url"],
+    style: {
+      foreground: theme.markdownLink,
+      underline: true
+    }
+  }, {
+    scope: ["markup.link.label", "label"],
+    style: {
+      foreground: theme.markdownLinkText,
+      underline: true
+    }
+  }, {
+    scope: ["conceal"],
+    style: {
+      foreground: theme.textMuted
+    }
+  }], owner);
+}
+function getMarkdownStyle(theme, owner) {
+  if (markdownStyleCache?.theme === theme) return markdownStyleCache?.style;
+  try {
+    markdownStyleCache = {
+      theme,
+      style: buildMarkdownStyle(theme, owner)
+    };
+    return markdownStyleCache?.style;
+  } catch {
+    try {
+      return SyntaxStyle.create(owner);
+    } catch {
+      return undefined;
+    }
+  }
+}
+const emptyPins = () => ({
+  sessions: [],
+  directories: []
+});
+const pinsPath = () => process.env.SESH_PINS_FILE ?? join(process.env.XDG_DATA_HOME ?? join(process.env.HOME ?? "", ".local/share"), "sesh/pins.json");
+async function readPins() {
+  try {
+    const data = JSON.parse(await readFile(pinsPath(), "utf8"));
+    return {
+      sessions: Array.isArray(data.sessions) ? data.sessions.filter(id => typeof id === "string") : [],
+      directories: Array.isArray(data.directories) ? data.directories.filter(dir => typeof dir === "string") : []
+    };
+  } catch {
+    return emptyPins();
+  }
+}
+async function togglePin(kind, value) {
+  const file = pinsPath();
+  await mkdir(dirname(file), {
+    recursive: true
+  });
+  const lock = `${file}.lock`;
+  let locked = false;
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      await mkdir(lock);
+      locked = true;
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = Number((await readFile(join(lock, "pid"), "utf8")).trim());
+        if (Number.isSafeInteger(owner) && owner > 0) {
+          try {
+            process.kill(owner, 0);
+          } catch (check) {
+            if (check.code === "ESRCH") {
+              await unlink(join(lock, "pid")).catch(() => {});
+              await rmdir(lock).catch(() => {});
+            }
+          }
+        }
+      } catch {}
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+  if (!locked) throw new Error("pins are busy");
+  const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}`;
+  try {
+    await writeFile(join(lock, "pid"), `${process.pid}\n`);
+    const next = await readPins();
+    next[kind] = next[kind].includes(value) ? next[kind].filter(item => item !== value) : [...next[kind], value];
+    await writeFile(tmp, JSON.stringify(next) + "\n", {
+      mode: 0o600
+    });
+    await rename(tmp, file);
+    return next;
+  } finally {
+    await unlink(tmp).catch(() => {});
+    await unlink(join(lock, "pid")).catch(() => {});
+    await rmdir(lock);
+  }
+}
+function pinnedFirst(entries, pins) {
+  const sessions = new Set(pins.sessions);
+  const directories = new Set(pins.directories);
+  return [...entries].sort((a, b) => {
+    const aRank = sessions.has(a.id) ? 2 : directories.has(a.dir) ? 1 : 0;
+    const bRank = sessions.has(b.id) ? 2 : directories.has(b.dir) ? 1 : 0;
+    return bRank - aRank || b.updated - a.updated;
+  });
+}
+
+// Sessions panel: an opencode-native session switcher in two parts.
+//
+// 1. Sidebar (always visible): a compact recent-sessions section appended to
+//    the native sidebar via the `sidebar_content` slot. Native session_list
+//    (<leader>l) is left untouched; this complements it with a cross-project
+//    view. Rows are display-only; option+o opens the full picker.
+// 2. Picker (option+o, `/sesh`, command palette): an xlarge grouped picker over
+//    every session across all project directories, newest first.
+//
+// `/sesh` is registered by this plugin (a markdown command cannot open the
+// dialog). Native `/sessions` and session_list (<leader>l) stay untouched.
+const BASE_MODE = "base";
+const POLL_MS = 15_000;
+function shortDir(dir, home) {
+  if (!dir || dir === "/") return "other";
+  const pretty = home && dir.startsWith(home + "/") ? "~" + dir.slice(home.length) : dir;
+  return pretty.replace(/\/+$/, "").split("/").pop() || "other";
+}
+function prettyDir(dir, home) {
+  if (!dir) return "other";
+  if (home && dir === home) return "~";
+  const pretty = home && dir.startsWith(home + "/") ? "~" + dir.slice(home.length) : dir.replace(/\/+$/, "");
+  const parts = pretty.split("/").filter(Boolean);
+  if (parts.length <= 3) return pretty;
+  return "…/" + parts.slice(-2).join("/");
+}
+function ago(ms) {
+  const s = Math.max(0, Math.floor((Date.now() - ms) / 1000));
+  if (s < 60) return "now";
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return `${Math.floor(s / 86400)}d`;
+}
+function truncate(text, width) {
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  return text.slice(0, width - 1) + "…";
+}
+
+// Sidebar and home rows should read at a similar length. The sidebar title
+// column is ~2 chars narrower than the group column (status dot + timestamp),
+// so cap it a bit lower to guarantee separation.
+const SIDEBAR_TITLE_WIDTH = 27;
+const SIDEBAR_GROUP_WIDTH = 30;
+const HOME_TITLE_WIDTH = 30;
+
+// The sidebar lists every session (newest first, pins ahead) and fills
+// whatever vertical space it gets: overflow scrolls inside the stretched
+// scrollbox. The picker (option+o) remains the place for transcript search.
+
+// Uppercase is included deliberately: a search box that silently drops shifted
+// letters cannot be used for acronyms or paths like README.
+const SEARCH_KEYS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.@/+:,?!()[]".split("");
+function searchBindings(append, exit) {
+  return [...SEARCH_KEYS.map(ch => ({
+    key: ch,
+    preventDefault: true,
+    cmd: () => append(ch)
+  })), {
+    key: "space",
+    preventDefault: true,
+    cmd: () => append(" ")
+  }, {
+    key: "backspace",
+    preventDefault: true,
+    cmd: () => append("\b")
+  }, {
+    key: "escape",
+    preventDefault: true,
+    cmd: exit
+  }];
+}
+const rootMouseHandlers = new Set();
+let rootMouseInstalled = false;
+let removeRootMouse;
+const ROOT_MOUSE = Symbol.for("opencode-sesh.root-mouse");
+function ensureRootMouse(renderer) {
+  if (rootMouseInstalled || !renderer?.root) return;
+  rootMouseInstalled = true;
+  const root = renderer.root;
+  if (!root[ROOT_MOUSE]) {
+    const handlers = new Set();
+    root[ROOT_MOUSE] = handlers;
+    const previous = root._mouseListeners?.down;
+    root.onMouseDown = event => {
+      previous?.(event);
+      for (const handler of [...handlers]) handler();
+    };
+  }
+  const dispatch = () => {
+    for (const handler of [...rootMouseHandlers]) handler();
+  };
+  root[ROOT_MOUSE].add(dispatch);
+  removeRootMouse = () => {
+    root[ROOT_MOUSE]?.delete(dispatch);
+    rootMouseHandlers.clear();
+    rootMouseInstalled = false;
+  };
+}
+const LEFT_BUTTON = 0;
+const RIGHT_BUTTON = 2;
+function openInCmuxWorkspace(api, entry) {
+  if (!process.env.CMUX_WORKSPACE_ID) {
+    api.ui.toast({
+      message: "Right-click opens a new workspace only inside cmux",
+      variant: "info"
+    });
+    return;
+  }
+  const args = ["new-workspace", "--name", entry.title || entry.id, "--command", `opencode --session ${entry.id}`, "--focus", "true"];
+  if (entry.dir) args.push("--cwd", entry.dir);
+  const child = spawn("cmux", args, {
+    stdio: "ignore"
+  });
+  child.on("error", () => api.ui.toast({
+    message: "Could not open a cmux workspace",
+    variant: "error"
+  }));
+  child.on("exit", code => {
+    if (code) api.ui.toast({
+      message: "Could not open a cmux workspace",
+      variant: "error"
+    });
+  });
+}
+const CONTEXT_MENU_LAYER_PRIORITY = 30;
+function contextMenuItems(pinned, cmux) {
+  return [{
+    id: "open",
+    label: "Open"
+  }, {
+    id: "preview",
+    label: "Preview transcript"
+  }, ...(cmux ? [{
+    id: "workspace",
+    label: "Open in new cmux workspace"
+  }] : []), {
+    id: "fork",
+    label: "Fork"
+  }, {
+    id: "pin",
+    label: pinned ? "Unpin" : "Pin"
+  }, {
+    id: "delete",
+    label: "Delete"
+  }];
+}
+function contextMenuSize(items) {
+  return {
+    width: Math.max(...items.map(item => item.label.length)) + 4,
+    height: items.length + 2
+  };
+}
+function contextMenuBox(anchor, cols, rows) {
+  const width = Math.max(1, Math.min(anchor.width, cols));
+  const height = Math.max(1, Math.min(anchor.height, rows));
+  const left = Math.max(0, Math.min(anchor.x, cols - width));
+  const below = anchor.y + 1;
+  const top = below + height <= rows ? below : Math.max(0, anchor.y - height);
+  return {
+    left,
+    top,
+    width,
+    height
+  };
+}
+function createContextMenu(host) {
+  let state;
+  let dispose;
+  const publish = next => {
+    state = next;
+    host.onChange(next);
+  };
+  const close = () => {
+    dispose?.();
+    dispose = undefined;
+    if (state) publish(undefined);
+  };
+  const select = index => {
+    if (!state) return;
+    const next = Math.max(0, Math.min(state.items.length - 1, index));
+    // A still pointer re-fires over events; republishing an identical state
+    // would rebuild the keyed menu on every frame, churning renderables until
+    // clicks fall through to whatever is beneath.
+    if (next === state.index) return;
+    publish({
+      ...state,
+      index: next
+    });
+  };
+  const move = delta => {
+    if (!state) return;
+    const count = state.items.length;
+    const next = (state.index + delta + count) % count;
+    if (next === state.index) return;
+    publish({
+      ...state,
+      index: next
+    });
+  };
+  const activate = index => {
+    if (!state) return;
+    const current = state;
+    const item = current.items[index ?? current.index];
+    if (!item) return;
+    if (item.id === "delete") {
+      publish({
+        ...current,
+        confirming: true,
+        items: [{
+          id: "confirm",
+          label: "Confirm delete"
+        }, {
+          id: "cancel",
+          label: "Cancel"
+        }],
+        index: 1
+      });
+      return;
+    }
+    close();
+    if (item.id === "confirm") host.actions.delete(current.entry);else if (item.id !== "cancel") host.actions[item.id](current.entry);
+  };
+  const click = (index, button) => {
+    if ((button ?? LEFT_BUTTON) === LEFT_BUTTON) activate(index);
+  };
+  const guarded = run => () => {
+    if (host.blocked()) close();else run();
+  };
+  const open = (entry, x, y) => {
+    if (host.blocked()) return;
+    publish({
+      entry,
+      x,
+      y,
+      items: contextMenuItems(host.pinned(entry), host.cmux()),
+      index: 0,
+      confirming: false
+    });
+    if (dispose) return;
+    dispose = host.registerLayer({
+      mode: "base",
+      priority: CONTEXT_MENU_LAYER_PRIORITY,
+      bindings: [{
+        key: "up",
+        desc: "Previous menu item",
+        preventDefault: true,
+        cmd: guarded(() => move(-1))
+      }, {
+        key: "down",
+        desc: "Next menu item",
+        preventDefault: true,
+        cmd: guarded(() => move(1))
+      }, {
+        key: "enter",
+        desc: "Choose menu item",
+        preventDefault: true,
+        cmd: guarded(() => activate())
+      }, {
+        key: "escape",
+        desc: "Close menu",
+        preventDefault: true,
+        cmd: close
+      }]
+    });
+  };
+  return {
+    open,
+    close,
+    select,
+    activate,
+    click,
+    current: () => state
+  };
+}
+// Loading-spinner frames for the marker of a session whose agent is working.
+const SIDEBAR_SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function newestFirst(entries) {
+  return [...entries].sort((a, b) => b.updated - a.updated || a.id.localeCompare(b.id));
+}
+
+// A working agent is the only state the marker displays: everything that
+// finished goes back to the neutral row, with the open session marked inside.
+function sidebarMarker(current, live) {
+  if (live === "running" || live === "busy" || live === "retry") return "running";
+  return current ? "current" : "idle";
+}
+const SESSION_PAGE_LIMIT = 200;
+const SESSION_MAX = 5000;
+async function fetchEntries(api) {
+  const home = process.env.HOME ?? "";
+  const projectResult = await api.client.project.list();
+  const projects = projectResult?.data ?? projectResult ?? [];
+  const projectName = new Map(projects.map(p => [p.id, p.name?.trim() || shortDir(p.canonical, home)]));
+  const sessions = [];
+  let cursor;
+  let truncated = false;
+  for (;;) {
+    const result = await api.client.experimental.session.list({
+      limit: SESSION_PAGE_LIMIT,
+      roots: true,
+      ...(cursor === undefined ? {} : {
+        cursor
+      })
+    });
+    const page = result?.data ?? result ?? [];
+    if (!Array.isArray(page) || page.length === 0) break;
+    sessions.push(...page);
+    if (!result.cursor?.next) break;
+    if (sessions.length >= SESSION_MAX) {
+      truncated = true;
+      break;
+    }
+    const next = result.cursor.next;
+    if (next === cursor) {
+      truncated = true;
+      break;
+    }
+    cursor = next;
+  }
+  const entries = sessions.filter(s => !s.time?.archived && !s.parentID).sort((a, b) => b.time.updated - a.time.updated).map(s => {
+    const projectLabel = s.projectID ? projectName.get(s.projectID) : undefined;
+    const sDir = s.directory ?? s.location?.directory ?? "";
+    return {
+      id: s.id,
+      title: s.title?.trim() || "(untitled)",
+      dir: sDir,
+      group: (projectLabel && projectLabel !== "other" ? projectLabel : shortDir(sDir, home)) || "other",
+      updated: s.time.updated
+    };
+  });
+  return {
+    entries,
+    truncated
+  };
+}
+const SESSION_ID_PATTERN = /^ses_[A-Za-z0-9]+$/;
+const TRANSCRIPT_BATCH = 64;
+const REMOTE_CONCURRENCY = 8;
+const nextTick = () => new Promise(resolve => setTimeout(resolve, 0));
+function resolveDbPath() {
+  if (process.env.SESH_DB) return process.env.SESH_DB;
+  const home = process.env.HOME ?? "";
+  const dataHome = process.env.XDG_DATA_HOME ?? `${home}/.local/share`;
+  const xdgPath = `${dataHome}/opencode/opencode.db`;
+  if (existsSync(xdgPath)) return xdgPath;
+  try {
+    const result = spawnSync(process.env.SESH_OPENCODE ?? "opencode", ["debug", "paths"], {
+      encoding: "utf8"
+    });
+    const match = result.stdout?.match(/^db\s+(.+)$/m);
+    if (match) return match[1].trimEnd();
+  } catch {}
+  return xdgPath;
+}
+async function openTranscriptDb() {
+  try {
+    // @ts-ignore - bun:sqlite ships with the Bun runtime (verified); no type package installed
+    const sqlite = await import("bun:sqlite");
+    if (typeof sqlite?.Database !== "function") return undefined;
+    return new sqlite.Database(resolveDbPath(), {
+      readonly: true
+    });
+  } catch {
+    return undefined;
+  }
+}
+function costRowsQuery(cutoff, includeLegacy) {
+  const legacy = includeLegacy ? `UNION ALL
+SELECT s.directory, s.id AS session_id, m.time_created, m.data
+FROM message m JOIN session s ON s.id = m.session_id
+WHERE json_extract(m.data, '$.role') = 'assistant'
+  AND NOT EXISTS (SELECT 1 FROM session_v2 v WHERE v.id = s.id)` : "";
+  return `WITH costs AS (
+SELECT s.directory, s.id AS session_id, m.time_created, m.data
+FROM session_message m JOIN session_v2 s ON s.id = m.session_id
+WHERE m.type = 'assistant'
+${legacy}
+)
+SELECT m.directory AS directory,
+  ROUND(SUM(CASE WHEN m.time_created >= ${cutoff} THEN COALESCE(json_extract(m.data, '$.cost'), 0) ELSE 0 END), 4) AS window_cost,
+  ROUND(SUM(COALESCE(json_extract(m.data, '$.cost'), 0)), 4) AS lifetime_cost,
+  COUNT(DISTINCT m.session_id) AS sessions
+FROM costs m
+WHERE json_extract(m.data, '$.cost') IS NOT NULL
+GROUP BY m.directory
+ORDER BY lifetime_cost DESC`;
+}
+
+// NEEDS_INPUT_SQL: sessions waiting on the user (shared heuristic — keep in
+// sync with bin/sesh-waiting.sh). A session waits when it is not archived,
+// is not a child (subagent) session, and either has an unanswered `question`
+// tool part or a `tool` part still marked running older than STUCK_AFTER_MS
+// with no message activity in the session or its direct children since then (a
+// long-running subagent/shell tool with recent activity is not stuck; V2
+// resumes interrupted runs server-side, so `running` with no activity means
+// orphaned or awaiting approval). Server-independent on purpose: the TUI
+// sync layer only sees permission/question state for sessions owned by the
+// current server, which is invisible cross-project.
+const STUCK_AFTER_MS = 600000;
+const LIVE_TOOLS_CTE = sessionFilter => `
+WITH live AS (
+  SELECT m.session_id AS session_id, m.seq AS seq,
+    json_extract(c.value, '$.name') AS name,
+    json_extract(c.value, '$.state.status') AS status,
+    COALESCE(json_extract(c.value, '$.time.created'), m.time_created) AS created
+  FROM session_message m, json_each(m.data, '$.content') c
+  WHERE m.type = 'assistant'
+    AND (m.data LIKE '%"status":"running"%' OR m.data LIKE '%"status":"pending"%')
+    AND json_extract(c.value, '$.type') = 'tool'
+    AND json_extract(c.value, '$.state.status') IN ('pending', 'running')${sessionFilter}
+)`;
+const QUESTION_OPEN = `live.name = 'question'
+  AND NOT EXISTS (
+    SELECT 1 FROM session_message u
+    WHERE u.session_id = live.session_id AND u.type = 'user' AND u.seq > live.seq)`;
+const NO_RECENT_ACTIVITY = (sessionIdExpr, stuckBefore) => `NOT EXISTS (
+      SELECT 1 FROM session_message r JOIN session_v2 f ON f.id = r.session_id
+      WHERE (f.id = ${sessionIdExpr} OR f.parent_id = ${sessionIdExpr}) AND r.time_updated >= ${stuckBefore})`;
+const NEEDS_INPUT_SQL = stuckBefore => `${LIVE_TOOLS_CTE("")}
+SELECT s.id AS id,
+  CASE WHEN EXISTS (SELECT 1 FROM live WHERE live.session_id = s.id AND ${QUESTION_OPEN})
+    THEN 'question' ELSE 'stuck' END AS reason
+FROM session_v2 s
+WHERE COALESCE(s.time_archived, 0) = 0
+  AND s.parent_id IS NULL
+  AND (EXISTS (SELECT 1 FROM live WHERE live.session_id = s.id AND ${QUESTION_OPEN})
+    OR (EXISTS (
+      SELECT 1 FROM live
+      WHERE live.session_id = s.id AND live.status = 'running' AND live.created < ${stuckBefore})
+      AND ${NO_RECENT_ACTIVITY("s.id", stuckBefore)}))
+ORDER BY s.time_updated DESC`;
+async function queryWaitingIds(db) {
+  const rows = db.query(NEEDS_INPUT_SQL(Date.now() - STUCK_AFTER_MS)).all() ?? [];
+  const out = new Map();
+  for (const row of rows) {
+    if (typeof row?.id === "string" && SESSION_ID_PATTERN.test(row.id) && (row.reason === "question" || row.reason === "stuck")) {
+      out.set(row.id, row.reason);
+    }
+  }
+  return out;
+}
+// The shared needs-input query decides *which* sessions are waiting. Read the
+// oldest still-unanswered question or stuck tool for each result so triage can
+// show how long it has waited, rather than its last (unrelated) update time.
+async function queryWaitingDetails(db) {
+  const reasons = await queryWaitingIds(db);
+  const details = new Map([...reasons].map(([id, reason]) => [id, {
+    reason: reason
+  }]));
+  const ids = [...details.keys()];
+  const cutoff = Date.now() - STUCK_AFTER_MS;
+  for (let i = 0; i < ids.length; i += 200) {
+    const batch = ids.slice(i, i + 200);
+    const rows = db.query(`${LIVE_TOOLS_CTE(` AND m.session_id IN (${batch.map(() => "?").join(",")})`)}
+SELECT live.session_id AS id,
+  MIN(CASE WHEN ${QUESTION_OPEN} THEN live.created END) AS question_since,
+  MIN(CASE WHEN live.status = 'running' AND live.created < ${cutoff} THEN live.created END) AS stuck_since
+FROM live
+GROUP BY live.session_id`).all(...batch) ?? [];
+    for (const row of rows) {
+      const detail = details.get(row.id);
+      if (!detail) continue;
+      const since = detail.reason === "question" ? row.question_since : row.stuck_since;
+      if (typeof since === "number") detail.since = since;
+    }
+  }
+  return details;
+}
+function addTranscript(index, sid, data) {
+  try {
+    const message = JSON.parse(data);
+    const texts = [];
+    if (typeof message?.text === "string") texts.push(message.text);
+    if (Array.isArray(message?.content)) {
+      for (const part of message.content) {
+        if (part?.type === "text" && typeof part.text === "string") texts.push(part.text);
+      }
+    }
+    for (const text of texts) {
+      const base = index.get(sid) ?? "";
+      index.set(sid, `${base} ${text.toLowerCase()}`.trim());
+    }
+  } catch {
+    // ignore malformed messages
+  }
+}
+
+// Index titles/directories immediately, then add transcript text progressively
+// in batches so the render thread can breathe. Covers every entry, not a fixed
+// newest window; `onProgress` lets the picker show coverage.
+async function buildSearchIndex(api, entries, onProgress) {
+  const index = new Map();
+  for (const entry of entries) {
+    index.set(entry.id, `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`);
+  }
+  const ids = entries.map(entry => entry.id).filter(id => SESSION_ID_PATTERN.test(id));
+  const remaining = new Set(ids);
+  const total = ids.length;
+  let indexed = 0;
+  const report = complete => onProgress?.({
+    indexed,
+    total,
+    complete
+  }, index);
+  report(false);
+  const db = await openTranscriptDb();
+  if (db) {
+    try {
+      for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
+        const batch = ids.slice(i, i + TRANSCRIPT_BATCH);
+        const placeholders = batch.map(() => "?").join(",");
+        const rows = db.query(`SELECT session_id AS sid, data FROM session_message WHERE session_id IN (${placeholders}) AND type IN ('user', 'assistant') ORDER BY seq`).all(...batch) ?? [];
+        for (const row of rows) addTranscript(index, row.sid, row.data);
+        for (const id of batch) remaining.delete(id);
+        indexed += batch.length;
+        report(false);
+        await nextTick();
+      }
+    } catch {
+      // local store unavailable mid-walk; fall back to the remote path below
+    } finally {
+      db.close();
+    }
+  }
+  if (remaining.size > 0) {
+    await buildSearchIndexRemote(api, [...remaining], index, () => {
+      indexed += 1;
+      if (indexed % TRANSCRIPT_BATCH === 0) report(false);
+    });
+  }
+  report(true);
+  return index;
+}
+async function buildSearchIndexRemote(api, ids, index, onEach) {
+  const home = process.env.HOME ?? "";
+  const cacheDir = process.env.SESH_CACHE_DIR ?? `${process.env.XDG_CACHE_HOME ?? `${home}/.cache`}/sesh`;
+  let cursor = 0;
+  // Bounded concurrency: a fixed worker pool instead of one request per session.
+  const worker = async () => {
+    for (;;) {
+      const i = cursor++;
+      if (i >= ids.length) return;
+      const id = ids[i];
+      const base = index.get(id) ?? "";
+      try {
+        const raw = await readFile(`${cacheDir}/extractions/${id}.json`, "utf8");
+        const record = JSON.parse(raw);
+        const fulltext = typeof record?.fulltextLower === "string" ? record.fulltextLower : "";
+        // Extraction caches prefix the transcript with the cached title. The
+        // live entry already indexes its own title; strip that duplicate so a
+        // title-only match cannot appear as a transcript excerpt.
+        const title = typeof record?.title === "string" ? `${record.title.toLowerCase()} ` : "";
+        const transcript = title && fulltext.startsWith(title) ? fulltext.slice(title.length) : fulltext;
+        index.set(id, `${base} ${transcript}`.trim());
+      } catch {
+        try {
+          const result = await api.client.session.messages({
+            sessionID: id
+          });
+          const messages = result.data ?? [];
+          const text = messages.flatMap(message => message.parts.filter(part => part.type === "text").map(part => part.text)).join(" ").toLowerCase();
+          index.set(id, `${base} ${text}`.trim());
+        } catch {}
+      }
+      onEach();
+    }
+  };
+  await Promise.all(Array.from({
+    length: Math.min(REMOTE_CONCURRENCY, ids.length)
+  }, worker));
+}
+
+// The index is title + directory + text parts, all lowercased. Start looking
+// after the metadata so a title match never masquerades as a transcript hit.
+function transcriptMatchExcerpt(indexed, entry, query) {
+  const needle = query.trim().toLowerCase();
+  if (!indexed || !needle) return undefined;
+  const transcriptStart = `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`.length + 1;
+  const at = indexed.indexOf(needle, transcriptStart);
+  if (at < 0) return undefined;
+  const start = Math.max(transcriptStart, at - 28);
+  const end = Math.min(indexed.length, Math.max(at + needle.length + 28, start + 90));
+  const excerpt = indexed.slice(start, end).replace(/\s+/g, " ").trim();
+  return `${start > transcriptStart ? "…" : ""}${excerpt}${end < indexed.length ? "…" : ""}`;
+}
+function filterPickerEntries(entries, filters, index, waitingIds, pinnedSessions) {
+  const q = filters.query.trim().toLowerCase();
+  const pinned = new Set(pinnedSessions);
+  return entries.filter(entry => {
+    if (filters.scope && entry.group !== filters.scope) return false;
+    if (filters.waitingOnly && !waitingIds.has(entry.id)) return false;
+    if (filters.pinnedOnly && !pinned.has(entry.id)) return false;
+    if (!q) return true;
+    return (index.get(entry.id) ?? `${entry.title} ${entry.dir}`.toLowerCase()).includes(q);
+  });
+}
+const TRANSCRIPT_PREVIEW_TURNS = 8;
+const TRANSCRIPT_PREVIEW_CHARS = 2000;
+
+// Case-insensitive range of `query` inside `text`, so a matched row can show
+// which part of it the search hit instead of only filtering invisibly. Kept
+// below the data-layer markers that tests/tui.mjs evaluates: JSX must not enter
+// that extraction window.
+function matchRange(text, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return undefined;
+  const at = text.toLowerCase().indexOf(q);
+  return at < 0 ? undefined : [at, at + q.length];
+}
+function Highlighted(props) {
+  const parts = createMemo(() => {
+    const range = matchRange(props.text, props.query);
+    if (!range) return [props.text, "", ""];
+    return [props.text.slice(0, range[0]), props.text.slice(range[0], range[1]), props.text.slice(range[1])];
+  });
+  return (() => {
+    var _el$ = _$createElement("text"),
+      _el$2 = _$createElement("span");
+    _$insertNode(_el$, _el$2);
+    _$setProp(_el$, "flexGrow", 1);
+    _$setProp(_el$, "flexShrink", 1);
+    _$setProp(_el$, "overflow", "hidden");
+    _$setProp(_el$, "wrapMode", "none");
+    _$insert(_el$, () => parts()[0], _el$2);
+    _$insert(_el$2, () => parts()[1]);
+    _$insert(_el$, () => parts()[2], null);
+    _$effect(_p$ => {
+      var _v$ = props.bold ? TextAttributes.BOLD : undefined,
+        _v$2 = {
+          fg: props.color
+        },
+        _v$3 = {
+          fg: props.matchColor
+        };
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$, "attributes", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$, "style", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp(_el$2, "style", _v$3, _p$.a));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined
+    });
+    return _el$;
+  })();
+}
+async function fetchTranscriptText(api, sessionID) {
+  try {
+    const result = await api.client.session.messages({
+      sessionID,
+      preview: true
+    });
+    const messages = result.data ?? [];
+    const blocks = messages.map(message => {
+      const text = message.parts.filter(part => part.type === "text").map(part => part.text).join("\n").trim();
+      if (!text) return "";
+      const role = message.info.role;
+      return `**${role === "user" ? "You" : "Assistant"}**\n\n${text.slice(0, TRANSCRIPT_PREVIEW_CHARS)}`;
+    }).filter(Boolean).slice(-TRANSCRIPT_PREVIEW_TURNS).reverse();
+    const text = blocks.join("\n\n---\n\n");
+    return text || "(no text in this session)";
+  } catch {
+    return "(preview unavailable)";
+  }
+}
+
+// Shared transcript preview dialog. Call from a component's setup scope so the
+// preview key layer is torn down with it.
+function createTranscriptPreview(api) {
+  const [previewID, setPreviewID] = createSignal();
+  const [previewText, setPreviewText] = createSignal("");
+  let disposePreviewKeys;
+  const close = () => {
+    setPreviewID(undefined);
+    api.ui.dialog.clear();
+    disposePreviewKeys?.();
+    disposePreviewKeys = undefined;
+  };
+  const open = entry => {
+    if (previewID() === entry.id) {
+      close();
+      return;
+    }
+    if (previewID()) close();
+    setPreviewID(entry.id);
+    setPreviewText("Loading…");
+    void fetchTranscriptText(api, entry.id).then(text => {
+      if (previewID() === entry.id) setPreviewText(text);
+    });
+    api.ui.dialog.replace(() => (() => {
+      var _el$3 = _$createElement("box"),
+        _el$4 = _$createElement("box"),
+        _el$5 = _$createElement("text"),
+        _el$6 = _$createElement("text"),
+        _el$8 = _$createElement("text"),
+        _el$9 = _$createTextNode(` · `),
+        _el$0 = _$createElement("scrollbox");
+      _$insertNode(_el$3, _el$4);
+      _$insertNode(_el$3, _el$8);
+      _$insertNode(_el$3, _el$0);
+      _$setProp(_el$3, "flexDirection", "column");
+      _$setProp(_el$3, "paddingLeft", 4);
+      _$setProp(_el$3, "paddingRight", 4);
+      _$setProp(_el$3, "paddingBottom", 1);
+      _$setProp(_el$3, "gap", 1);
+      _$setProp(_el$3, "onMouseDown", event => event.stopPropagation());
+      _$insertNode(_el$4, _el$5);
+      _$insertNode(_el$4, _el$6);
+      _$setProp(_el$4, "flexDirection", "row");
+      _$setProp(_el$4, "justifyContent", "space-between");
+      _$insert(_el$5, () => entry.title);
+      _$insertNode(_el$6, _$createTextNode(`esc`));
+      _$setProp(_el$6, "onMouseUp", close);
+      _$insertNode(_el$8, _el$9);
+      _$insert(_el$8, () => prettyDir(entry.dir, process.env.HOME ?? ""), _el$9);
+      _$insert(_el$8, () => ago(entry.updated), null);
+      _$setProp(_el$0, "paddingLeft", 1);
+      _$setProp(_el$0, "paddingRight", 1);
+      _$setProp(_el$0, "scrollbarOptions", {
+        visible: false
+      });
+      _$insert(_el$0, (() => {
+        var _c$ = _$memo(() => !!getMarkdownStyle(api.theme.current, api.renderer?.nativeSession));
+        return () => _c$() ? (() => {
+          var _el$1 = _$createElement("markdown");
+          _$effect(_p$ => {
+            var _v$9 = previewText(),
+              _v$0 = getMarkdownStyle(api.theme.current, api.renderer?.nativeSession),
+              _v$1 = getTreeSitterClient();
+            _v$9 !== _p$.e && (_p$.e = _$setProp(_el$1, "content", _v$9, _p$.e));
+            _v$0 !== _p$.t && (_p$.t = _$setProp(_el$1, "syntaxStyle", _v$0, _p$.t));
+            _v$1 !== _p$.a && (_p$.a = _$setProp(_el$1, "treeSitterClient", _v$1, _p$.a));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined
+          });
+          return _el$1;
+        })() : (() => {
+          var _el$10 = _$createElement("text");
+          _$setProp(_el$10, "wrapMode", "word");
+          _$insert(_el$10, previewText);
+          return _el$10;
+        })();
+      })());
+      _$effect(_p$ => {
+        var _v$4 = api.theme.current.backgroundPanel,
+          _v$5 = TextAttributes.BOLD,
+          _v$6 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$7 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$8 = Math.max(6, Math.floor(api.renderer.height / 2));
+        _v$4 !== _p$.e && (_p$.e = _$setProp(_el$3, "backgroundColor", _v$4, _p$.e));
+        _v$5 !== _p$.t && (_p$.t = _$setProp(_el$5, "attributes", _v$5, _p$.t));
+        _v$6 !== _p$.a && (_p$.a = _$setProp(_el$6, "style", _v$6, _p$.a));
+        _v$7 !== _p$.o && (_p$.o = _$setProp(_el$8, "style", _v$7, _p$.o));
+        _v$8 !== _p$.i && (_p$.i = _$setProp(_el$0, "maxHeight", _v$8, _p$.i));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined,
+        a: undefined,
+        o: undefined,
+        i: undefined
+      });
+      return _el$3;
+    })(), () => {
+      setPreviewID(undefined);
+      disposePreviewKeys?.();
+      disposePreviewKeys = undefined;
+    });
+    api.ui.dialog.setSize("large");
+    disposePreviewKeys?.();
+    disposePreviewKeys = api.keymap.registerLayer({
+      mode: "modal",
+      bindings: [{
+        key: "escape",
+        desc: "Close preview",
+        preventDefault: true,
+        cmd: close
+      }]
+    });
+  };
+  onCleanup(() => disposePreviewKeys?.());
+
+  // Outside presses reach the root handler; close on the first one instead of
+  // relying on the host backdrop. Gated on our own preview so other dialogs
+  // are never touched.
+  const closeIfOpen = () => {
+    if (previewID()) close();
+  };
+  return {
+    open,
+    closeIfOpen
+  };
+}
+// Window by terminal lines, not session count: group spacing and transcript
+// excerpts each consume an extra line. Carry the directory heading forward
+// when a long group starts above the viewport.
+function pickerWindow(rows, start, height, excerpt) {
+  if (!rows.length) return [];
+  const first = Math.max(0, Math.min(start, rows.length - 1));
+  const shown = [];
+  let remaining = height;
+  if (rows[first].kind === "item") {
+    for (let i = first - 1; i >= 0; i--) {
+      const row = rows[i];
+      if (row.kind !== "group") continue;
+      shown.push({
+        ...row,
+        continued: true
+      });
+      remaining--;
+      break;
+    }
+  }
+  for (let i = first; i < rows.length; i++) {
+    const row = rows[i];
+    const lines = row.kind === "group" ? 2 : excerpt(row.entry) ? 2 : 1;
+    if (lines > remaining && shown.length) break;
+    shown.push(row);
+    remaining -= lines;
+  }
+  return shown;
+}
+function pickerLastStart(rows, height, excerpt) {
+  if (!rows.length) return 0;
+  let start = rows.length - 1;
+  while (start > 0 && pickerWindow(rows, start - 1, height, excerpt).at(-1) === rows.at(-1)) start--;
+  return start;
+}
+function SidebarSessions(props) {
+  const theme = () => props.api.theme.current;
+  const home = process.env.HOME ?? "";
+  const [entries, setEntries] = createSignal([]);
+  const [sectionCollapsed, setSectionCollapsed] = createSignal(false);
+  const [collapsed, setCollapsed] = createSignal({});
+  const [hovered, setHovered] = createSignal();
+  const preview = createTranscriptPreview(props.api);
+  const [menuState, setMenuState] = createSignal();
+  let portalContainer;
+  const [query, setQuery] = createSignal("");
+  const [deleting, setDeleting] = createSignal();
+  const [searching, setSearching] = createSignal(false);
+  const [loadFailed, setLoadFailed] = createSignal(false);
+  const [navActive, setNavActive] = createSignal(false);
+  const [cursor, setCursor] = createSignal(0);
+  const [pendingDelete, setPendingDelete] = createSignal();
+  const [waiting, setWaiting] = createSignal(new Map());
+  let confirmTimer;
+  const currentID = createMemo(() => {
+    const route = props.api.route.current;
+    if (route.name !== "session") return undefined;
+    const params = route.params;
+    return params && typeof params.sessionID === "string" ? params.sessionID : undefined;
+  });
+  onMount(() => {
+    let alive = true;
+    const load = async () => {
+      props.refreshPins();
+      try {
+        const {
+          entries: all
+        } = await fetchEntries(props.api);
+        if (alive) {
+          setEntries(all);
+          setLoadFailed(false);
+        }
+      } catch {
+        // leave the previous list in place rather than flashing to blank, but
+        // say so when there is nothing at all to show
+        if (alive && entries().length === 0) setLoadFailed(true);
+      }
+      try {
+        const db = await openTranscriptDb();
+        if (db) {
+          try {
+            const ids = await queryWaitingIds(db);
+            if (alive) setWaiting(ids);
+          } finally {
+            db.close();
+          }
+        }
+      } catch {
+        // leave the previous waiting set in place rather than flashing
+      }
+    };
+    void load();
+    const clock = setInterval(() => void load(), POLL_MS);
+    onCleanup(() => {
+      alive = false;
+      clearInterval(clock);
+    });
+  });
+  const filteredEntries = createMemo(() => {
+    const q = query().trim().toLowerCase();
+    const ordered = entries();
+    if (!q) return ordered;
+    return ordered.filter(entry => entry.title.toLowerCase().includes(q) || entry.dir.toLowerCase().includes(q));
+  });
+  const shownEntries = createMemo(() => filteredEntries());
+  const remaining = createMemo(() => Math.max(0, filteredEntries().length - shownEntries().length));
+  const NEEDS_INPUT_DIR = "__needs_input__";
+  const waitingEntries = createMemo(() => {
+    const ids = waiting();
+    return newestFirst(shownEntries().filter(entry => ids.has(entry.id)));
+  });
+  const tree = createMemo(() => {
+    const rows = [];
+    const pending = waitingEntries();
+    if (pending.length > 0) {
+      rows.push({
+        kind: "group",
+        dir: NEEDS_INPUT_DIR,
+        label: "Needs input",
+        count: pending.length
+      });
+      if (!collapsed()[NEEDS_INPUT_DIR]) {
+        for (let i = 0; i < pending.length; i++) {
+          rows.push({
+            kind: "item",
+            entry: pending[i],
+            last: i === pending.length - 1
+          });
+        }
+      }
+    }
+    const groups = new Map();
+    for (const entry of shownEntries()) {
+      if (waiting().has(entry.id)) continue;
+      const list = groups.get(entry.dir) ?? [];
+      list.push(entry);
+      groups.set(entry.dir, list);
+    }
+    const ordered = [...groups.entries()].map(([dir, list]) => ({
+      dir,
+      list,
+      updated: Math.max(...list.map(entry => entry.updated))
+    })).sort((a, b) => {
+      const pins = props.pins();
+      const rank = group => pins.directories.includes(group.dir) ? 2 : group.list.some(entry => pins.sessions.includes(entry.id)) ? 1 : 0;
+      return rank(b) - rank(a) || b.updated - a.updated;
+    });
+    for (const group of ordered) {
+      const sessions = newestFirst(group.list);
+      rows.push({
+        kind: "group",
+        dir: group.dir,
+        label: prettyDir(group.dir, home),
+        count: group.list.length
+      });
+      if (collapsed()[group.dir]) continue;
+      for (let i = 0; i < sessions.length; i++) {
+        rows.push({
+          kind: "item",
+          entry: sessions[i],
+          last: i === sessions.length - 1
+        });
+      }
+    }
+    return rows;
+  });
+  const toggleGroup = dir => {
+    setCollapsed(prev => ({
+      ...prev,
+      [dir]: !prev[dir]
+    }));
+  };
+  const toggleSection = () => {
+    if (!sectionCollapsed()) {
+      cancelDelete();
+      setNavActive(false);
+      setSearching(false);
+      setHovered(undefined);
+      menu.close();
+    }
+    setSectionCollapsed(value => !value);
+  };
+  const openSession = entry => {
+    // Opening a session hands input back to the main view: release every
+    // sidebar capture first, so its key layers cannot shadow the composer's
+    // once the new session is open.
+    menu.close();
+    cancelDelete();
+    setNavActive(false);
+    setSearching(false);
+    setHovered(undefined);
+    props.api.route.navigate("session", {
+      sessionID: entry.id
+    });
+  };
+
+  // Flat order of the rows a cursor can land on, so keyboard navigation and
+  // mouse hover resolve to the same row.
+  const itemRows = createMemo(() => tree().flatMap(row => row.kind === "item" ? [row.entry] : []));
+  const isActive = id => navActive() ? itemRows()[cursor()]?.id === id : hovered() === id;
+  const isPendingDelete = id => pendingDelete() === id;
+  const routeKey = createMemo(() => {
+    const route = props.api.route.current;
+    const id = route.name === "session" && typeof route.params?.sessionID === "string" ? route.params.sessionID : "";
+    return `${route.name}:${id}`;
+  });
+  createEffect(on(routeKey, () => menu.close(), {
+    defer: true
+  }));
+  // Navigating away also releases the sidebar's keyboard captures: a nav,
+  // search, hover or armed delete left over from the previous session must
+  // not shadow the composer's keys in the next one.
+  createEffect(on(routeKey, () => {
+    cancelDelete();
+    setNavActive(false);
+    setSearching(false);
+    setHovered(undefined);
+  }, {
+    defer: true
+  }));
+  createEffect(() => {
+    const state = menuState();
+    if (state && !itemRows().some(entry => entry.id === state.entry.id)) menu.close();
+  });
+  createEffect(() => {
+    if (props.api.ui.dialog.open) menu.close();
+    // A modal dialog owns input while open: yield the sidebar's keyboard
+    // captures too, so its layers cannot double-fire with the dialog's own.
+    if (props.api.ui.dialog.open) {
+      cancelDelete();
+      setNavActive(false);
+      setSearching(false);
+      setHovered(undefined);
+    }
+  });
+  const moveCursor = delta => {
+    const count = itemRows().length;
+    if (count === 0) return;
+    setCursor(value => Math.max(0, Math.min(count - 1, value + delta)));
+  };
+  let previousRows = [];
+  createEffect(() => {
+    const rows = itemRows();
+    const selected = previousRows[cursor()]?.id;
+    const position = rows.findIndex(entry => entry.id === selected);
+    if (position >= 0 && position !== cursor()) setCursor(position);else if (cursor() >= rows.length) setCursor(Math.max(0, rows.length - 1));
+    previousRows = rows;
+  });
+
+  // Marker only: a spinner for a working agent, the open-session dot, and the
+  // neutral row for idle sessions. Titles stay plain and no status text is
+  // rendered.
+  const markerOf = id => {
+    let live;
+    try {
+      live = props.api.state.session.status(id);
+    } catch {}
+    return sidebarMarker(id === currentID(), live);
+  };
+
+  // The spinner animates only while a listed session is actually running, so
+  // an idle list costs no timer and only running rows re-render per frame.
+  const [spinFrame, setSpinFrame] = createSignal(0);
+  let spinTimer;
+  createEffect(() => {
+    const spinning = itemRows().some(entry => markerOf(entry.id) === "running");
+    if (spinning && !spinTimer) {
+      spinTimer = setInterval(() => setSpinFrame(value => (value + 1) % SIDEBAR_SPINNER.length), 120);
+    } else if (!spinning && spinTimer) {
+      clearInterval(spinTimer);
+      spinTimer = undefined;
+      setSpinFrame(0);
+    }
+  });
+  onCleanup(() => {
+    if (spinTimer) clearInterval(spinTimer);
+  });
+  const cancelDelete = () => {
+    if (confirmTimer) clearTimeout(confirmTimer);
+    confirmTimer = undefined;
+    setPendingDelete(undefined);
+  };
+
+  // Deleting is irreversible, so ctrl+x arms the row and a second ctrl+x (or y)
+  // commits it. The arm survives pointer movement — edge-hover flicker must
+  // not eat the confirm — and is cleared by the five-second timeout, n, Esc,
+  // collapsing the section, or the delete itself.
+  const requestDelete = entry => {
+    if (deleting()) return;
+    if (pendingDelete() === entry.id) {
+      void deleteEntry(entry);
+      return;
+    }
+    setPendingDelete(entry.id);
+    if (confirmTimer) clearTimeout(confirmTimer);
+    confirmTimer = setTimeout(() => setPendingDelete(undefined), 5000);
+  };
+
+  // The confirm always targets the visibly armed row ("ctrl+x again"),
+  // wherever the pointer or cursor currently is. Returns true when an arm
+  // was pending (and is now committed or discarded as stale).
+  const confirmArmed = () => {
+    const id = pendingDelete();
+    if (!id) return false;
+    const entry = entries().find(e => e.id === id);
+    if (!entry) cancelDelete();else void deleteEntry(entry);
+    return true;
+  };
+  let sidebarScroll;
+  const deleteEntry = async entry => {
+    cancelDelete();
+    if (deleting()) return;
+    setDeleting(entry.id);
+    try {
+      const result = await props.api.client.session.delete({
+        sessionID: entry.id,
+        directory: entry.dir || undefined
+      });
+      if (result && "error" in result && result.error) throw result.error;
+      const {
+        entries: remaining
+      } = await fetchEntries(props.api);
+      if (remaining.some(item => item.id === entry.id)) {
+        setEntries(remaining);
+        props.api.ui.toast({
+          message: "Session was not deleted",
+          variant: "error"
+        });
+        return;
+      }
+      const scrollTop = sidebarScroll?.scrollTop ?? 0;
+      setEntries(remaining);
+      setHovered(undefined);
+      const restore = () => {
+        if (sidebarScroll) sidebarScroll.scrollTop = scrollTop;
+      };
+      queueMicrotask(restore);
+      setTimeout(restore, 0);
+      props.api.ui.toast({
+        message: `Deleted "${truncate(entry.title, 40)}"`,
+        variant: "info"
+      });
+      if (currentID() === entry.id) props.api.route.navigate("home");
+    } catch {
+      props.api.ui.toast({
+        message: "Could not delete session",
+        variant: "error"
+      });
+    } finally {
+      setDeleting(undefined);
+    }
+  };
+  const forkEntry = async entry => {
+    try {
+      const result = await props.api.client.session.fork({
+        sessionID: entry.id,
+        directory: entry.dir || undefined
+      });
+      const created = result?.data ?? result;
+      if (!created?.id) throw new Error("fork returned no session");
+      props.api.route.navigate("session", {
+        sessionID: created.id
+      });
+      props.api.ui.toast({
+        message: `Forked "${truncate(entry.title, 40)}"`,
+        variant: "info"
+      });
+    } catch {
+      props.api.ui.toast({
+        message: "Could not fork session",
+        variant: "error"
+      });
+    }
+  };
+  const menu = createContextMenu({
+    registerLayer: layer => props.api.keymap.registerLayer(layer),
+    actions: {
+      open: entry => void openSession(entry),
+      preview: entry => preview.open(entry),
+      workspace: entry => openInCmuxWorkspace(props.api, entry),
+      fork: entry => void forkEntry(entry),
+      pin: entry => props.onTogglePin("sessions", entry.id),
+      delete: entry => void deleteEntry(entry)
+    },
+    pinned: entry => props.pins().sessions.includes(entry.id),
+    cmux: () => Boolean(process.env.CMUX_WORKSPACE_ID),
+    blocked: () => props.api.ui.dialog.open,
+    onChange: setMenuState
+  });
+  const menuView = createMemo(() => {
+    const state = menuState();
+    if (!state) return undefined;
+    const box = contextMenuBox({
+      x: state.x,
+      y: state.y,
+      ...contextMenuSize(state.items)
+    }, props.api.renderer.width, props.api.renderer.height);
+    return {
+      state,
+      box
+    };
+  });
+  let disposeHoverSpace;
+  let disposeSearch;
+  let disposeNav;
+  let disposeConfirm;
+  let insideSearchBox = false;
+  createEffect(() => {
+    disposeConfirm?.();
+    disposeConfirm = undefined;
+    if (!pendingDelete()) return;
+    disposeConfirm = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 25,
+      bindings: [{
+        key: "y",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "alt+d",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "enter",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "n",
+        desc: "Cancel delete",
+        preventDefault: true,
+        cmd: cancelDelete
+      }, {
+        key: "escape",
+        desc: "Cancel delete",
+        preventDefault: true,
+        cmd: cancelDelete
+      }]
+    });
+  });
+  const onRootMouseDown = () => {
+    menu.close();
+    preview.closeIfOpen();
+    if (insideSearchBox) {
+      insideSearchBox = false;
+      return;
+    }
+    if (searching()) setSearching(false);
+    // A click anywhere outside the sidebar means input is back in the main
+    // view: release the nav layer, hover shortcuts and any armed delete so
+    // the sidebar's keys and rows stop shadowing the composer.
+    cancelDelete();
+    if (navActive()) setNavActive(false);
+    setHovered(undefined);
+  };
+  onMount(() => {
+    ensureRootMouse(props.api.renderer);
+    rootMouseHandlers.add(onRootMouseDown);
+    const closeMenu = () => menu.close();
+    props.api.renderer.on("resize", closeMenu);
+    onCleanup(() => {
+      rootMouseHandlers.delete(onRootMouseDown);
+      props.api.renderer.off("resize", closeMenu);
+    });
+  });
+  const appendQuery = input => {
+    if (input === "\b") setQuery(value => value.slice(0, -1));else setQuery(value => value + input);
+  };
+  createEffect(() => {
+    disposeSearch?.();
+    disposeSearch = undefined;
+    if (!searching()) return;
+    disposeSearch = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 20,
+      bindings: searchBindings(appendQuery, () => setSearching(false))
+    });
+  });
+  const openSidebarPreview = entry => preview.open(entry);
+  createEffect(() => {
+    disposeHoverSpace?.();
+    disposeHoverSpace = undefined;
+    const id = hovered();
+    if (!id) return;
+    const entry = entries().find(e => e.id === id);
+    if (!entry) return;
+    disposeHoverSpace = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 20,
+      bindings: [{
+        key: "alt+p",
+        desc: "Preview session transcript",
+        preventDefault: true,
+        cmd: () => openSidebarPreview(entry)
+      }, {
+        key: "alt+d",
+        desc: "Delete session",
+        preventDefault: true,
+        cmd: () => {
+          if (!confirmArmed()) requestDelete(entry);
+        }
+      }, {
+        key: "alt+s",
+        desc: "Pin session",
+        preventDefault: true,
+        cmd: () => props.onTogglePin("sessions", entry.id)
+      }, {
+        key: "alt+r",
+        desc: "Pin directory",
+        preventDefault: true,
+        cmd: () => props.onTogglePin("directories", entry.dir)
+      }, {
+        key: "/",
+        desc: "Search sessions",
+        preventDefault: true,
+        cmd: () => setSearching(true)
+      }]
+    });
+  });
+
+  // Keyboard navigation is opt-in (click the "Sessions" heading or the search
+  // box) so the sidebar never steals the arrow keys from the main prompt.
+  // Clicking anywhere outside the sidebar, opening a session, or navigating
+  // releases it again, so its layers cannot shadow the composer afterwards.
+  createEffect(() => {
+    disposeNav?.();
+    disposeNav = undefined;
+    if (!navActive()) return;
+    const bindings = [{
+      key: "up",
+      desc: "Previous session",
+      preventDefault: true,
+      cmd: () => moveCursor(-1)
+    }, {
+      key: "down",
+      desc: "Next session",
+      preventDefault: true,
+      cmd: () => moveCursor(1)
+    }, {
+      key: "pageup",
+      desc: "Page up",
+      preventDefault: true,
+      cmd: () => moveCursor(-5)
+    }, {
+      key: "pagedown",
+      desc: "Page down",
+      preventDefault: true,
+      cmd: () => moveCursor(5)
+    }, {
+      key: "home",
+      desc: "First session",
+      preventDefault: true,
+      cmd: () => setCursor(0)
+    }, {
+      key: "end",
+      desc: "Last session",
+      preventDefault: true,
+      cmd: () => setCursor(Math.max(0, itemRows().length - 1))
+    }, {
+      key: "alt+p",
+      desc: "Preview session transcript",
+      preventDefault: true,
+      cmd: () => {
+        const entry = itemRows()[cursor()];
+        if (entry) openSidebarPreview(entry);
+      }
+    }, {
+      key: "alt+d",
+      desc: "Delete session",
+      preventDefault: true,
+      cmd: () => {
+        if (confirmArmed()) return;
+        const entry = itemRows()[cursor()];
+        if (entry) requestDelete(entry);
+      }
+    }, {
+      key: "alt+s",
+      desc: "Pin session",
+      preventDefault: true,
+      cmd: () => {
+        const entry = itemRows()[cursor()];
+        if (entry) props.onTogglePin("sessions", entry.id);
+      }
+    }, {
+      key: "alt+r",
+      desc: "Pin directory",
+      preventDefault: true,
+      cmd: () => {
+        const entry = itemRows()[cursor()];
+        if (entry) props.onTogglePin("directories", entry.dir);
+      }
+    }, {
+      key: "enter",
+      desc: "Open session",
+      preventDefault: true,
+      cmd: () => {
+        if (confirmArmed()) return;
+        const entry = itemRows()[cursor()];
+        if (entry) void openSession(entry);
+      }
+    }, {
+      key: "escape",
+      desc: "Leave the session list",
+      preventDefault: true,
+      cmd: () => {
+        cancelDelete();
+        setNavActive(false);
+      }
+    }, ...(pendingDelete() ? [{
+      key: "y",
+      desc: "Confirm delete",
+      preventDefault: true,
+      cmd: () => {
+        confirmArmed();
+      }
+    }, {
+      key: "n",
+      desc: "Cancel delete",
+      preventDefault: true,
+      cmd: cancelDelete
+    }] : [])];
+    disposeNav = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 20,
+      bindings
+    });
+  });
+  onCleanup(() => {
+    disposeHoverSpace?.();
+    disposeSearch?.();
+    disposeNav?.();
+    disposeConfirm?.();
+    menu.close();
+    const container = portalContainer;
+    portalContainer = undefined;
+    process.nextTick(() => container?.destroyRecursively?.());
+    if (confirmTimer) clearTimeout(confirmTimer);
+  });
+  return (() => {
+    var _el$11 = _$createElement("box"),
+      _el$12 = _$createElement("box"),
+      _el$13 = _$createElement("text"),
+      _el$14 = _$createElement("b"),
+      _el$16 = _$createElement("span"),
+      _el$17 = _$createElement("span"),
+      _el$21 = _$createElement("text");
+    _$insertNode(_el$11, _el$12);
+    _$setProp(_el$11, "flexDirection", "column");
+    _$setProp(_el$11, "paddingRight", 1);
+    _$setProp(_el$11, "flexGrow", 1);
+    _$setProp(_el$11, "flexShrink", 1);
+    _$insertNode(_el$12, _el$13);
+    _$insertNode(_el$12, _el$21);
+    _$setProp(_el$12, "flexDirection", "row");
+    _$setProp(_el$12, "justifyContent", "space-between");
+    _$setProp(_el$12, "gap", 1);
+    _$insertNode(_el$13, _el$14);
+    _$insertNode(_el$13, _el$16);
+    _$insertNode(_el$13, _el$17);
+    _$setProp(_el$13, "flexShrink", 1);
+    _$setProp(_el$13, "onMouseDown", event => {
+      // Sidebar-internal: keep this click from reaching the root handler,
+      // which would release the nav layer this toggle just activated.
+      event.stopPropagation();
+      if (!sectionCollapsed()) setNavActive(value => !value);
+    });
+    _$insertNode(_el$14, _$createTextNode(`Sessions`));
+    _$insert(_el$16, (() => {
+      var _c$2 = _$memo(() => !!query().trim());
+      return () => _c$2() ? ` (${filteredEntries().length}/${entries().length})` : ` (${entries().length})`;
+    })());
+    _$insert(_el$17, () => navActive() ? " · nav" : "");
+    _$insert(_el$13, _$createComponent(Show, {
+      get when() {
+        return waitingEntries().length > 0;
+      },
+      get children() {
+        var _el$18 = _$createElement("span"),
+          _el$19 = _$createTextNode(` · `),
+          _el$20 = _$createTextNode(` need input`);
+        _$insertNode(_el$18, _el$19);
+        _$insertNode(_el$18, _el$20);
+        _$insert(_el$18, () => waitingEntries().length, _el$20);
+        _$effect(_$p => _$setProp(_el$18, "style", {
+          fg: theme().warning
+        }, _$p));
+        return _el$18;
+      }
+    }), null);
+    _$setProp(_el$21, "flexShrink", 0);
+    _$setProp(_el$21, "onMouseDown", event => {
+      event.stopPropagation();
+      toggleSection();
+    });
+    _$insert(_el$21, () => sectionCollapsed() ? "▸ show" : "▾ hide");
+    _$insert(_el$11, _$createComponent(Show, {
+      get when() {
+        return !sectionCollapsed();
+      },
+      get children() {
+        return _$createComponent(Show, {
+          get when() {
+            return entries().length > 0;
+          },
+          get fallback() {
+            return (() => {
+              var _el$33 = _$createElement("text");
+              _$insert(_el$33, () => loadFailed() ? "Session list unavailable · will retry" : "No sessions yet · option+o to browse");
+              _$effect(_$p => _$setProp(_el$33, "style", {
+                fg: theme().textMuted
+              }, _$p));
+              return _el$33;
+            })();
+          },
+          get children() {
+            return [(() => {
+              var _el$22 = _$createElement("box"),
+                _el$23 = _$createElement("text");
+              _$insertNode(_el$22, _el$23);
+              _$setProp(_el$22, "flexDirection", "row");
+              _$setProp(_el$22, "gap", 1);
+              _$setProp(_el$22, "paddingRight", 1);
+              _$setProp(_el$22, "onMouseDown", event => {
+                // Sidebar-internal: the root handler must not see this click, or
+                // it would clear the search this box just activated.
+                event.stopPropagation();
+                insideSearchBox = true;
+                setSearching(true);
+              });
+              _$setProp(_el$23, "flexGrow", 1);
+              _$setProp(_el$23, "flexShrink", 1);
+              _$setProp(_el$23, "overflow", "hidden");
+              _$setProp(_el$23, "wrapMode", "none");
+              _$insert(_el$23, () => query() || (searching() ? "" : "search…"), null);
+              _$insert(_el$23, () => searching() ? "▏" : "", null);
+              _$insert(_el$22, _$createComponent(Show, {
+                get when() {
+                  return query();
+                },
+                get children() {
+                  var _el$24 = _$createElement("text");
+                  _$insertNode(_el$24, _$createTextNode(`✕`));
+                  _$setProp(_el$24, "flexShrink", 0);
+                  _$setProp(_el$24, "onMouseDown", event => {
+                    event.stopPropagation();
+                    setQuery("");
+                  });
+                  _$effect(_$p => _$setProp(_el$24, "style", {
+                    fg: theme().textMuted
+                  }, _$p));
+                  return _el$24;
+                }
+              }), null);
+              _$effect(_p$ => {
+                var _v$10 = searching() ? theme().backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+                  _v$11 = {
+                    fg: query() ? theme().text : theme().textMuted
+                  };
+                _v$10 !== _p$.e && (_p$.e = _$setProp(_el$22, "backgroundColor", _v$10, _p$.e));
+                _v$11 !== _p$.t && (_p$.t = _$setProp(_el$23, "style", _v$11, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$22;
+            })(), (() => {
+              var _el$26 = _$createElement("scrollbox");
+              _$use(node => sidebarScroll = node, _el$26);
+              _$setProp(_el$26, "flexGrow", 1);
+              _$setProp(_el$26, "flexShrink", 1);
+              _$setProp(_el$26, "verticalScrollbarOptions", {
+                visible: false
+              });
+              _$setProp(_el$26, "horizontalScrollbarOptions", {
+                visible: false
+              });
+              _$setProp(_el$26, "onMouseScroll", () => menu.close());
+              _$insert(_el$26, _$createComponent(For, {
+                get each() {
+                  return tree();
+                },
+                children: row => {
+                  if (row.kind === "group") return (() => {
+                    var _el$34 = _$createElement("box"),
+                      _el$35 = _$createElement("text"),
+                      _el$36 = _$createElement("span"),
+                      _el$37 = _$createElement("b"),
+                      _el$38 = _$createElement("text"),
+                      _el$39 = _$createTextNode(` (`),
+                      _el$41 = _$createTextNode(`)`);
+                    _$insertNode(_el$34, _el$35);
+                    _$insertNode(_el$34, _el$38);
+                    _$setProp(_el$34, "flexDirection", "row");
+                    _$setProp(_el$34, "paddingTop", 1);
+                    _$setProp(_el$34, "onMouseDown", event => {
+                      event.stopPropagation();
+                      if (event.button === RIGHT_BUTTON) return;
+                      toggleGroup(row.dir);
+                    });
+                    _$insertNode(_el$35, _el$36);
+                    _$insertNode(_el$35, _el$37);
+                    _$setProp(_el$35, "flexGrow", 1);
+                    _$setProp(_el$35, "flexShrink", 1);
+                    _$setProp(_el$35, "wrapMode", "none");
+                    _$insert(_el$36, () => collapsed()[row.dir] ? "▸ " : "▾ ");
+                    _$insert(_el$37, () => props.pins().directories.includes(row.dir) ? "★ " : "", null);
+                    _$insert(_el$37, () => truncate(row.label, SIDEBAR_GROUP_WIDTH - (props.pins().directories.includes(row.dir) ? 2 : 0)), null);
+                    _$insertNode(_el$38, _el$39);
+                    _$insertNode(_el$38, _el$41);
+                    _$setProp(_el$38, "flexShrink", 0);
+                    _$insert(_el$38, () => row.count, _el$41);
+                    _$effect(_p$ => {
+                      var _v$15 = {
+                          fg: theme().textMuted
+                        },
+                        _v$16 = {
+                          fg: theme().textMuted
+                        };
+                      _v$15 !== _p$.e && (_p$.e = _$setProp(_el$36, "style", _v$15, _p$.e));
+                      _v$16 !== _p$.t && (_p$.t = _$setProp(_el$38, "style", _v$16, _p$.t));
+                      return _p$;
+                    }, {
+                      e: undefined,
+                      t: undefined
+                    });
+                    return _el$34;
+                  })();
+                  const marker = createMemo(() => markerOf(row.entry.id));
+                  return (() => {
+                    var _el$42 = _$createElement("box"),
+                      _el$43 = _$createElement("text"),
+                      _el$44 = _$createElement("span"),
+                      _el$45 = _$createElement("span"),
+                      _el$46 = _$createElement("text");
+                    _$insertNode(_el$42, _el$43);
+                    _$insertNode(_el$42, _el$46);
+                    _$setProp(_el$42, "flexDirection", "row");
+                    _$setProp(_el$42, "gap", 1);
+                    _$setProp(_el$42, "paddingLeft", 1);
+                    _$setProp(_el$42, "paddingRight", 1);
+                    _$setProp(_el$42, "onMouseOver", () => {
+                      setHovered(row.entry.id);
+                      // The keyboard layer wins over the hover layer while nav is
+                      // active. Keep its cursor on the hovered row so Ctrl-S/Ctrl-D
+                      // cannot silently pin a different (often current) session.
+                      if (navActive()) {
+                        const index = itemRows().findIndex(entry => entry.id === row.entry.id);
+                        if (index >= 0) setCursor(index);
+                      }
+                    });
+                    _$setProp(_el$42, "onMouseOut", () => setHovered(undefined));
+                    _$setProp(_el$42, "onMouseDown", event => {
+                      if (event.button === RIGHT_BUTTON) {
+                        event.stopPropagation();
+                        menu.open(row.entry, event.x, event.y);
+                      } else {
+                        // Sidebar-internal: openSession releases the sidebar's own
+                        // captures, so this click must not also reach the root
+                        // handler as an outside click.
+                        event.stopPropagation();
+                        void openSession(row.entry);
+                      }
+                    });
+                    _$insertNode(_el$43, _el$44);
+                    _$insertNode(_el$43, _el$45);
+                    _$setProp(_el$43, "flexShrink", 0);
+                    _$insert(_el$44, () => row.last ? "└" : "├");
+                    _$insert(_el$45, (() => {
+                      var _c$3 = _$memo(() => marker() === "current");
+                      return () => _c$3() ? "●" : _$memo(() => marker() === "running")() ? SIDEBAR_SPINNER[spinFrame()] : isActive(row.entry.id) ? "▸" : "○";
+                    })());
+                    _$insert(_el$42, _$createComponent(Highlighted, {
+                      get text() {
+                        return `${props.pins().sessions.includes(row.entry.id) ? "★ " : ""}${truncate(row.entry.title, SIDEBAR_TITLE_WIDTH - (props.pins().sessions.includes(row.entry.id) ? 2 : 0))}`;
+                      },
+                      get query() {
+                        return query();
+                      },
+                      get color() {
+                        return _$memo(() => !!isPendingDelete(row.entry.id))() ? theme().error : theme().text;
+                      },
+                      get matchColor() {
+                        return theme().warning;
+                      }
+                    }), _el$46);
+                    _$setProp(_el$46, "flexShrink", 0);
+                    _$insert(_el$46, (() => {
+                      var _c$4 = _$memo(() => !!isPendingDelete(row.entry.id));
+                      return () => _c$4() ? "option+d again" : ago(row.entry.updated);
+                    })());
+                    _$effect(_p$ => {
+                      var _v$17 = isActive(row.entry.id) && row.entry.id !== currentID() ? theme().backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+                        _v$18 = {
+                          fg: theme().textMuted
+                        },
+                        _v$19 = {
+                          fg: isPendingDelete(row.entry.id) ? theme().error : marker() === "current" ? theme().accent : marker() === "running" ? theme().success : theme().textMuted
+                        },
+                        _v$20 = {
+                          fg: isPendingDelete(row.entry.id) ? theme().error : theme().textMuted
+                        };
+                      _v$17 !== _p$.e && (_p$.e = _$setProp(_el$42, "backgroundColor", _v$17, _p$.e));
+                      _v$18 !== _p$.t && (_p$.t = _$setProp(_el$44, "style", _v$18, _p$.t));
+                      _v$19 !== _p$.a && (_p$.a = _$setProp(_el$45, "style", _v$19, _p$.a));
+                      _v$20 !== _p$.o && (_p$.o = _$setProp(_el$46, "style", _v$20, _p$.o));
+                      return _p$;
+                    }, {
+                      e: undefined,
+                      t: undefined,
+                      a: undefined,
+                      o: undefined
+                    });
+                    return _el$42;
+                  })();
+                }
+              }));
+              return _el$26;
+            })(), _$createComponent(Show, {
+              get when() {
+                return remaining() > 0;
+              },
+              get children() {
+                var _el$27 = _$createElement("text");
+                _$insert(_el$27, () => `… ${remaining()} more · option+o for all`);
+                _$effect(_$p => _$setProp(_el$27, "style", {
+                  fg: theme().textMuted
+                }, _$p));
+                return _el$27;
+              }
+            }), _$createComponent(Show, {
+              get when() {
+                return _$memo(() => !!query().trim())() && filteredEntries().length === 0;
+              },
+              get children() {
+                var _el$28 = _$createElement("text");
+                _$insertNode(_el$28, _$createTextNode(`No title or directory matches · option+o to search transcripts`));
+                _$effect(_$p => _$setProp(_el$28, "style", {
+                  fg: theme().textMuted
+                }, _$p));
+                return _el$28;
+              }
+            }), _$createComponent(Show, {
+              get when() {
+                return navActive();
+              },
+              get children() {
+                var _el$30 = _$createElement("box"),
+                  _el$31 = _$createElement("text");
+                _$insertNode(_el$30, _el$31);
+                _$setProp(_el$30, "paddingTop", 1);
+                _$insertNode(_el$31, _$createTextNode(`↑↓ move · enter open · option+p preview · option+s/r pin · option+d delete · esc done`));
+                _$effect(_$p => _$setProp(_el$31, "style", {
+                  fg: theme().textMuted
+                }, _$p));
+                return _el$30;
+              }
+            })];
+          }
+        });
+      }
+    }), null);
+    _$insert(_el$11, _$createComponent(Portal, {
+      get mount() {
+        return props.api.renderer.root;
+      },
+      ref: container => {
+        portalContainer = container;
+        container.position = "absolute";
+        container.left = 0;
+        container.top = 0;
+        container.zIndex = 1000;
+      },
+      get children() {
+        return _$createComponent(Show, {
+          get when() {
+            return menuView();
+          },
+          keyed: true,
+          children: view => (() => {
+            var _el$47 = _$createElement("box");
+            _$setProp(_el$47, "position", "absolute");
+            _$setProp(_el$47, "flexDirection", "column");
+            _$setProp(_el$47, "border", true);
+            _$setProp(_el$47, "borderStyle", "rounded");
+            _$setProp(_el$47, "paddingLeft", 1);
+            _$setProp(_el$47, "paddingRight", 1);
+            _$setProp(_el$47, "onMouseDown", event => event.stopPropagation());
+            _$setProp(_el$47, "onMouseUp", event => event.stopPropagation());
+            _$insert(_el$47, _$createComponent(For, {
+              get each() {
+                return view.state.items;
+              },
+              children: (item, index) => (() => {
+                var _el$48 = _$createElement("box"),
+                  _el$49 = _$createElement("text");
+                _$insertNode(_el$48, _el$49);
+                _$setProp(_el$48, "height", 1);
+                _$setProp(_el$48, "onMouseOver", () => menu.select(index()));
+                _$setProp(_el$48, "onMouseDown", event => event.stopPropagation());
+                _$setProp(_el$48, "onMouseUp", event => {
+                  event.stopPropagation();
+                  menu.click(index(), event.button);
+                });
+                _$setProp(_el$49, "wrapMode", "none");
+                _$insert(_el$49, () => item.label);
+                _$effect(_p$ => {
+                  var _v$27 = view.state.index === index() ? theme().backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+                    _v$28 = {
+                      fg: item.id === "delete" || item.id === "confirm" ? theme().error : view.state.index === index() ? theme().text : theme().textMuted
+                    };
+                  _v$27 !== _p$.e && (_p$.e = _$setProp(_el$48, "backgroundColor", _v$27, _p$.e));
+                  _v$28 !== _p$.t && (_p$.t = _$setProp(_el$49, "style", _v$28, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$48;
+              })()
+            }));
+            _$effect(_p$ => {
+              var _v$21 = view.box.left,
+                _v$22 = view.box.top,
+                _v$23 = view.box.width,
+                _v$24 = view.box.height,
+                _v$25 = theme().borderActive,
+                _v$26 = theme().backgroundPanel;
+              _v$21 !== _p$.e && (_p$.e = _$setProp(_el$47, "left", _v$21, _p$.e));
+              _v$22 !== _p$.t && (_p$.t = _$setProp(_el$47, "top", _v$22, _p$.t));
+              _v$23 !== _p$.a && (_p$.a = _$setProp(_el$47, "width", _v$23, _p$.a));
+              _v$24 !== _p$.o && (_p$.o = _$setProp(_el$47, "height", _v$24, _p$.o));
+              _v$25 !== _p$.i && (_p$.i = _$setProp(_el$47, "borderColor", _v$25, _p$.i));
+              _v$26 !== _p$.n && (_p$.n = _$setProp(_el$47, "backgroundColor", _v$26, _p$.n));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined,
+              o: undefined,
+              i: undefined,
+              n: undefined
+            });
+            return _el$47;
+          })()
+        });
+      }
+    }), null);
+    _$effect(_p$ => {
+      var _v$12 = {
+          fg: theme().textMuted
+        },
+        _v$13 = {
+          fg: theme().accent
+        },
+        _v$14 = {
+          fg: theme().textMuted
+        };
+      _v$12 !== _p$.e && (_p$.e = _$setProp(_el$16, "style", _v$12, _p$.e));
+      _v$13 !== _p$.t && (_p$.t = _$setProp(_el$17, "style", _v$13, _p$.t));
+      _v$14 !== _p$.a && (_p$.a = _$setProp(_el$21, "style", _v$14, _p$.a));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined
+    });
+    return _el$11;
+  })();
+}
+const HOME_SESSION_LIMIT = 6;
+function HomeSessions(props) {
+  const theme = () => props.api.theme.current;
+  const home = process.env.HOME ?? "";
+  const [entries, setEntries] = createSignal([]);
+  const [query, setQuery] = createSignal("");
+  const [hovered, setHovered] = createSignal();
+  const [searching, setSearching] = createSignal(false);
+  const [loadFailed, setLoadFailed] = createSignal(false);
+  const [pendingDelete, setPendingDelete] = createSignal();
+  const [deleting, setDeleting] = createSignal();
+  let confirmTimer;
+  let disposeConfirm;
+  const preview = createTranscriptPreview(props.api);
+  let disposeHoverSpace;
+  let disposeSearch;
+  let insideSearchBox = false;
+  const cancelDelete = () => {
+    if (confirmTimer) clearTimeout(confirmTimer);
+    confirmTimer = undefined;
+    disposeConfirm?.();
+    disposeConfirm = undefined;
+    setPendingDelete(undefined);
+  };
+  const confirmArmed = () => {
+    const id = pendingDelete();
+    if (!id) return false;
+    const entry = entries().find(e => e.id === id);
+    if (!entry) cancelDelete();else void deleteEntry(entry);
+    return true;
+  };
+  const requestDelete = entry => {
+    if (deleting()) return;
+    if (pendingDelete() === entry.id) {
+      void deleteEntry(entry);
+      return;
+    }
+    setPendingDelete(entry.id);
+    if (confirmTimer) clearTimeout(confirmTimer);
+    confirmTimer = setTimeout(() => setPendingDelete(undefined), 5000);
+  };
+  const deleteEntry = async entry => {
+    cancelDelete();
+    if (deleting()) return;
+    setDeleting(entry.id);
+    try {
+      const result = await props.api.client.session.delete({
+        sessionID: entry.id,
+        directory: entry.dir || undefined
+      });
+      if (result && "error" in result && result.error) throw result.error;
+      const {
+        entries: remaining
+      } = await fetchEntries(props.api);
+      if (remaining.some(item => item.id === entry.id)) {
+        setEntries(remaining);
+        props.api.ui.toast({
+          message: "Session was not deleted",
+          variant: "error"
+        });
+        return;
+      }
+      setEntries(remaining);
+      setHovered(undefined);
+      props.api.ui.toast({
+        message: `Deleted "${truncate(entry.title, 40)}"`,
+        variant: "info"
+      });
+      if ("params" in props.api.route.current && props.api.route.current.params?.sessionID === entry.id) {
+        props.api.route.navigate("home");
+      }
+    } catch {
+      props.api.ui.toast({
+        message: "Could not delete session",
+        variant: "error"
+      });
+    } finally {
+      setDeleting(undefined);
+    }
+  };
+  createEffect(() => {
+    disposeConfirm?.();
+    disposeConfirm = undefined;
+    if (!pendingDelete()) return;
+    disposeConfirm = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 25,
+      bindings: [{
+        key: "y",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "alt+d",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "enter",
+        desc: "Confirm delete",
+        preventDefault: true,
+        cmd: () => {
+          confirmArmed();
+        }
+      }, {
+        key: "n",
+        desc: "Cancel delete",
+        preventDefault: true,
+        cmd: cancelDelete
+      }, {
+        key: "escape",
+        desc: "Cancel delete",
+        preventDefault: true,
+        cmd: cancelDelete
+      }]
+    });
+  });
+  const onRootMouseDown = () => {
+    preview.closeIfOpen();
+    if (insideSearchBox) {
+      insideSearchBox = false;
+      return;
+    }
+    if (searching()) setSearching(false);
+  };
+
+  // A modal dialog owns input while open: yield this list's keyboard captures
+  // too, so its layers cannot double-fire with the dialog's own.
+  createEffect(() => {
+    if (props.api.ui.dialog.open) {
+      cancelDelete();
+      setSearching(false);
+      setHovered(undefined);
+    }
+  });
+  onMount(() => {
+    ensureRootMouse(props.api.renderer);
+    rootMouseHandlers.add(onRootMouseDown);
+    onCleanup(() => rootMouseHandlers.delete(onRootMouseDown));
+  });
+  const appendQuery = input => {
+    if (input === "\b") setQuery(value => value.slice(0, -1));else setQuery(value => value + input);
+  };
+  createEffect(() => {
+    disposeSearch?.();
+    disposeSearch = undefined;
+    if (!searching()) return;
+    disposeSearch = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 20,
+      bindings: searchBindings(appendQuery, () => setSearching(false))
+    });
+  });
+  createEffect(() => {
+    disposeHoverSpace?.();
+    disposeHoverSpace = undefined;
+    const id = hovered();
+    if (!id) return;
+    const entry = entries().find(e => e.id === id);
+    if (!entry) return;
+    disposeHoverSpace = props.api.keymap.registerLayer({
+      mode: "base",
+      priority: 20,
+      bindings: [{
+        key: "alt+p",
+        desc: "Preview session transcript",
+        preventDefault: true,
+        cmd: () => preview.open(entry)
+      }, {
+        key: "alt+d",
+        desc: "Delete session",
+        preventDefault: true,
+        cmd: () => {
+          if (!confirmArmed()) requestDelete(entry);
+        }
+      }, {
+        key: "alt+s",
+        desc: "Pin session",
+        preventDefault: true,
+        cmd: () => props.onTogglePin("sessions", entry.id)
+      }, {
+        key: "alt+r",
+        desc: "Pin directory",
+        preventDefault: true,
+        cmd: () => props.onTogglePin("directories", entry.dir)
+      }]
+    });
+  });
+  onCleanup(() => {
+    disposeSearch?.();
+    disposeHoverSpace?.();
+    disposeConfirm?.();
+    if (confirmTimer) clearTimeout(confirmTimer);
+  });
+  onMount(() => {
+    let alive = true;
+    const load = async () => {
+      props.refreshPins();
+      try {
+        const {
+          entries: all
+        } = await fetchEntries(props.api);
+        if (alive) {
+          setEntries(all);
+          setLoadFailed(false);
+        }
+      } catch {
+        if (alive && entries().length === 0) setLoadFailed(true);
+      }
+    };
+    void load();
+    const clock = setInterval(() => void load(), POLL_MS);
+    onCleanup(() => {
+      alive = false;
+      clearInterval(clock);
+    });
+  });
+  const visible = createMemo(() => {
+    const q = query().trim().toLowerCase();
+    const list = q ? entries().filter(entry => entry.title.toLowerCase().includes(q) || entry.dir.toLowerCase().includes(q)) : entries();
+    return pinnedFirst(list, props.pins()).slice(0, HOME_SESSION_LIMIT);
+  });
+  return (() => {
+    var _el$50 = _$createElement("box"),
+      _el$51 = _$createElement("box");
+    _$insertNode(_el$50, _el$51);
+    _$setProp(_el$50, "width", "100%");
+    _$setProp(_el$50, "alignItems", "center");
+    _$setProp(_el$51, "flexDirection", "column");
+    _$setProp(_el$51, "width", "100%");
+    _$setProp(_el$51, "maxWidth", 72);
+    _$setProp(_el$51, "paddingLeft", 1);
+    _$setProp(_el$51, "paddingRight", 1);
+    _$setProp(_el$51, "paddingTop", 1);
+    _$setProp(_el$51, "gap", 1);
+    _$insert(_el$51, _$createComponent(Show, {
+      get when() {
+        return entries().length > 0;
+      },
+      get fallback() {
+        return (() => {
+          var _el$65 = _$createElement("box"),
+            _el$66 = _$createElement("text"),
+            _el$68 = _$createElement("text");
+          _$insertNode(_el$65, _el$66);
+          _$insertNode(_el$65, _el$68);
+          _$setProp(_el$65, "flexDirection", "row");
+          _$setProp(_el$65, "gap", 1);
+          _$insertNode(_el$66, _$createTextNode(`Recent sessions`));
+          _$insert(_el$68, () => loadFailed() ? "· list unavailable, will retry" : "· none yet, option+o to browse");
+          _$effect(_p$ => {
+            var _v$33 = {
+                fg: theme().textMuted
+              },
+              _v$34 = {
+                fg: theme().textMuted
+              };
+            _v$33 !== _p$.e && (_p$.e = _$setProp(_el$66, "style", _v$33, _p$.e));
+            _v$34 !== _p$.t && (_p$.t = _$setProp(_el$68, "style", _v$34, _p$.t));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined
+          });
+          return _el$65;
+        })();
+      },
+      get children() {
+        return [(() => {
+          var _el$52 = _$createElement("box"),
+            _el$53 = _$createElement("box"),
+            _el$54 = _$createElement("text"),
+            _el$56 = _$createElement("text"),
+            _el$58 = _$createElement("box"),
+            _el$59 = _$createElement("box"),
+            _el$60 = _$createElement("text");
+          _$insertNode(_el$52, _el$53);
+          _$insertNode(_el$52, _el$58);
+          _$setProp(_el$52, "flexDirection", "row");
+          _$setProp(_el$52, "justifyContent", "space-between");
+          _$setProp(_el$52, "gap", 2);
+          _$insertNode(_el$53, _el$54);
+          _$insertNode(_el$53, _el$56);
+          _$setProp(_el$53, "flexDirection", "row");
+          _$setProp(_el$53, "gap", 1);
+          _$insertNode(_el$54, _$createTextNode(`Recent sessions`));
+          _$insertNode(_el$56, _$createTextNode(`· option+o for all`));
+          _$insertNode(_el$58, _el$59);
+          _$setProp(_el$58, "flexDirection", "row");
+          _$setProp(_el$58, "gap", 1);
+          _$setProp(_el$58, "paddingLeft", 1);
+          _$setProp(_el$58, "paddingRight", 1);
+          _$setProp(_el$58, "onMouseDown", () => {
+            insideSearchBox = true;
+            setSearching(true);
+          });
+          _$insertNode(_el$59, _el$60);
+          _$setProp(_el$59, "width", 24);
+          _$setProp(_el$60, "flexGrow", 1);
+          _$setProp(_el$60, "flexShrink", 1);
+          _$setProp(_el$60, "overflow", "hidden");
+          _$setProp(_el$60, "wrapMode", "none");
+          _$insert(_el$60, () => query() || (searching() ? "" : "search…"), null);
+          _$insert(_el$60, () => searching() ? "▏" : "", null);
+          _$insert(_el$58, _$createComponent(Show, {
+            get when() {
+              return query();
+            },
+            get children() {
+              var _el$61 = _$createElement("text");
+              _$insertNode(_el$61, _$createTextNode(`✕`));
+              _$setProp(_el$61, "flexShrink", 0);
+              _$setProp(_el$61, "onMouseDown", () => setQuery(""));
+              _$effect(_$p => _$setProp(_el$61, "style", {
+                fg: theme().textMuted
+              }, _$p));
+              return _el$61;
+            }
+          }), null);
+          _$effect(_p$ => {
+            var _v$29 = {
+                fg: theme().textMuted
+              },
+              _v$30 = {
+                fg: theme().textMuted
+              },
+              _v$31 = searching() ? theme().backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+              _v$32 = {
+                fg: query() ? theme().text : theme().textMuted
+              };
+            _v$29 !== _p$.e && (_p$.e = _$setProp(_el$54, "style", _v$29, _p$.e));
+            _v$30 !== _p$.t && (_p$.t = _$setProp(_el$56, "style", _v$30, _p$.t));
+            _v$31 !== _p$.a && (_p$.a = _$setProp(_el$58, "backgroundColor", _v$31, _p$.a));
+            _v$32 !== _p$.o && (_p$.o = _$setProp(_el$60, "style", _v$32, _p$.o));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined
+          });
+          return _el$52;
+        })(), _$createComponent(For, {
+          get each() {
+            return visible();
+          },
+          children: entry => (() => {
+            var _el$69 = _$createElement("box"),
+              _el$70 = _$createElement("text"),
+              _el$72 = _$createElement("text");
+            _$insertNode(_el$69, _el$70);
+            _$insertNode(_el$69, _el$72);
+            _$setProp(_el$69, "flexDirection", "row");
+            _$setProp(_el$69, "gap", 1);
+            _$setProp(_el$69, "onMouseOver", () => setHovered(entry.id));
+            _$setProp(_el$69, "onMouseOut", () => setHovered(undefined));
+            _$setProp(_el$69, "onMouseDown", event => event.button === RIGHT_BUTTON ? openInCmuxWorkspace(props.api, entry) : props.api.route.navigate("session", {
+              sessionID: entry.id
+            }));
+            _$insertNode(_el$70, _$createTextNode(`○`));
+            _$setProp(_el$70, "flexShrink", 0);
+            _$insert(_el$69, _$createComponent(Highlighted, {
+              get text() {
+                return `${props.pins().sessions.includes(entry.id) ? "★ " : ""}${truncate(entry.title, HOME_TITLE_WIDTH - (props.pins().sessions.includes(entry.id) ? 2 : 0))}`;
+              },
+              get query() {
+                return query();
+              },
+              get color() {
+                return theme().text;
+              },
+              get matchColor() {
+                return theme().warning;
+              }
+            }), _el$72);
+            _$setProp(_el$72, "flexShrink", 0);
+            _$insert(_el$72, (() => {
+              var _c$5 = _$memo(() => pendingDelete() === entry.id);
+              return () => _c$5() ? "option+d again" : `${props.pins().directories.includes(entry.dir) ? "★ " : ""}${prettyDir(entry.dir, home)} · ${ago(entry.updated)}`;
+            })());
+            _$effect(_p$ => {
+              var _v$35 = entry.id === hovered() ? theme().backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+                _v$36 = {
+                  fg: theme().textMuted
+                },
+                _v$37 = {
+                  fg: pendingDelete() === entry.id ? theme().error : theme().textMuted
+                };
+              _v$35 !== _p$.e && (_p$.e = _$setProp(_el$69, "backgroundColor", _v$35, _p$.e));
+              _v$36 !== _p$.t && (_p$.t = _$setProp(_el$70, "style", _v$36, _p$.t));
+              _v$37 !== _p$.a && (_p$.a = _$setProp(_el$72, "style", _v$37, _p$.a));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined
+            });
+            return _el$69;
+          })()
+        }), _$createComponent(Show, {
+          get when() {
+            return visible().length === 0;
+          },
+          get children() {
+            var _el$63 = _$createElement("text");
+            _$insertNode(_el$63, _$createTextNode(`No title or directory matches · option+o to search transcripts`));
+            _$effect(_$p => _$setProp(_el$63, "style", {
+              fg: theme().textMuted
+            }, _$p));
+            return _el$63;
+          }
+        })];
+      }
+    }));
+    return _el$50;
+  })();
+}
+const tui = async api => {
+  const [pins, setPins] = createSignal(emptyPins());
+  // Keep exploratory context while the plugin remains loaded; a full OpenCode
+  // restart starts with a clean picker rather than an old cross-project filter.
+  let pickerState = {
+    query: "",
+    waitingOnly: false,
+    pinnedOnly: false
+  };
+  let pinVersion = 0;
+  const refreshPins = () => {
+    const version = pinVersion;
+    void readPins().then(latest => {
+      if (version === pinVersion) setPins(latest);
+    });
+  };
+  refreshPins();
+  const onTogglePin = (kind, value) => {
+    if (!value) return;
+    pinVersion += 1;
+    void togglePin(kind, value).then(updated => {
+      setPins(updated);
+      api.ui.toast({
+        message: `${updated[kind].includes(value) ? "Pinned" : "Unpinned"} ${kind === "sessions" ? "session" : "directory"}`,
+        variant: "info"
+      });
+    }, () => api.ui.toast({
+      message: "Could not update pins",
+      variant: "error"
+    }));
+  };
+  api.slots.register({
+    order: 100,
+    slots: {
+      sidebar_content() {
+        return _$createComponent(SidebarSessions, {
+          api: api,
+          pins: pins,
+          onTogglePin: onTogglePin,
+          refreshPins: refreshPins
+        });
+      },
+      home_bottom() {
+        return _$createComponent(HomeSessions, {
+          api: api,
+          pins: pins,
+          onTogglePin: onTogglePin,
+          refreshPins: refreshPins
+        });
+      }
+    }
+  });
+  const openPicker = async (command = false) => {
+    refreshPins();
+    if (!command && api.mode.current() !== BASE_MODE) return;
+    if (!command && api.renderer.currentFocusedEditor === null) return;
+    let entriesResult;
+    try {
+      entriesResult = await fetchEntries(api);
+    } catch {
+      api.ui.toast({
+        message: "Could not load sessions",
+        variant: "error"
+      });
+      return;
+    }
+    const entries = entriesResult.entries;
+    if (entries.length === 0) {
+      api.ui.toast({
+        message: "No sessions found",
+        variant: "warning"
+      });
+      return;
+    }
+    const [allEntries, setAllEntries] = createSignal(entries);
+    const [previewText, setPreviewText] = createSignal("");
+    const [showPreview, setShowPreview] = createSignal(false);
+    const [query, setQuery] = createSignal(pickerState.query);
+    const [cursor, setCursor] = createSignal(0);
+    const [viewportStart, setViewportStart] = createSignal(0);
+    const [collapsed, setCollapsed] = createSignal({});
+    const [scope, setScope] = createSignal(entries.some(entry => entry.group === pickerState.scope) ? pickerState.scope : undefined);
+    const [waitingOnly, setWaitingOnly] = createSignal(pickerState.waitingOnly);
+    const [pinnedOnly, setPinnedOnly] = createSignal(pickerState.pinnedOnly);
+    const [waitingIds, setWaitingIds] = createSignal(new Set());
+    const [waitingCoverage, setWaitingCoverage] = createSignal("loading");
+    let alive = true;
+    void (async () => {
+      const db = await openTranscriptDb();
+      if (!db) {
+        if (alive) setWaitingCoverage("unavailable");
+        return;
+      }
+      try {
+        const ids = await queryWaitingIds(db);
+        if (alive) {
+          setWaitingIds(new Set(ids.keys()));
+          setWaitingCoverage("ready");
+        }
+      } catch {
+        if (alive) setWaitingCoverage("unavailable");
+      } finally {
+        db.close();
+      }
+    })();
+    const [pendingDelete, setPendingDelete] = createSignal();
+    const [searchIndex, setSearchIndex] = createSignal(new Map());
+    const [indexProgress, setIndexProgress] = createSignal({
+      indexed: 0,
+      total: 0,
+      complete: false
+    });
+    void buildSearchIndex(api, entries, (progress, index) => {
+      if (!alive) return;
+      setIndexProgress(progress);
+      // Publish a fresh snapshot: the indexing workers mutate their own map,
+      // while Solid needs a new reference to update search results mid-scan.
+      setSearchIndex(new Map(index));
+    });
+    const orderedEntries = createMemo(() => pinnedFirst(allEntries(), pins()));
+    const currentProject = () => {
+      const route = api.route.current;
+      const id = route.name === "session" ? route.params?.sessionID : undefined;
+      return allEntries().find(entry => entry.id === id)?.group ?? allEntries().find(entry => entry.dir === api.state.path.directory)?.group;
+    };
+    const matchedGroups = createMemo(() => {
+      const matched = filterPickerEntries(orderedEntries(), {
+        query: query(),
+        scope: scope(),
+        waitingOnly: waitingOnly(),
+        pinnedOnly: pinnedOnly()
+      }, searchIndex(), waitingIds(), pins().sessions);
+      const byGroup = new Map();
+      for (const entry of matched) {
+        const list = byGroup.get(entry.dir) ?? [];
+        list.push(entry);
+        byGroup.set(entry.dir, list);
+      }
+      const groups = [...byGroup.entries()].map(([dir, list]) => ({
+        dir,
+        list: newestFirst(list)
+      }));
+      const currentPins = pins();
+      const rank = group => currentPins.directories.includes(group.dir) ? 2 : group.list.some(entry => currentPins.sessions.includes(entry.id)) ? 1 : 0;
+      return groups.sort((a, b) => rank(b) - rank(a) || Math.max(...b.list.map(entry => entry.updated)) - Math.max(...a.list.map(entry => entry.updated)));
+    });
+    const selectableEntries = createMemo(() => matchedGroups().flatMap(g => collapsed()[g.dir] && !query().trim() ? [] : g.list));
+
+    // Visible bounding: say how much transcript text search actually covers and
+    // when the metadata walk hit its cap, instead of silently under-reporting.
+    const coverageLabel = createMemo(() => {
+      const progress = indexProgress();
+      const bits = [];
+      if (scope()) bits.push(`scope ${scope()}`);
+      if (waitingOnly()) bits.push(waitingCoverage() === "loading" ? "checking needs input" : waitingCoverage() === "unavailable" ? "needs-input unavailable" : "needs input");
+      if (pinnedOnly()) bits.push("pinned sessions");
+      if (progress.total > 0) {
+        bits.push(progress.complete ? `transcripts ${progress.total}` : `indexing transcripts ${progress.indexed}/${progress.total}`);
+      }
+      if (entriesResult.truncated) bits.push(`showing newest ${allEntries().length}`);
+      return bits.join(" · ");
+    });
+    const pickerRows = createMemo(() => {
+      const flat = [];
+      for (const group of matchedGroups()) {
+        flat.push({
+          kind: "group",
+          dir: group.dir,
+          label: prettyDir(group.dir, process.env.HOME ?? ""),
+          count: group.list.length,
+          pinned: pins().directories.includes(group.dir)
+        });
+        if (collapsed()[group.dir] && !query().trim()) continue;
+        for (let i = 0; i < group.list.length; i++) {
+          flat.push({
+            kind: "item",
+            entry: group.list[i],
+            last: i === group.list.length - 1
+          });
+        }
+      }
+      return flat;
+    });
+    const termHeight = api.renderer.height;
+    // The dialog host anchors content a quarter of the way down the screen and
+    // lets it size to content, so a taller picker drifts downward. Pin the
+    // content height and offset it up by the same amount to keep it centred.
+    const dialogWidth = Math.min(116, api.renderer.width - 2);
+    const CHROME_ROWS = 13;
+    const listHeight = () => Math.max(6, Math.floor(termHeight * 0.75) - CHROME_ROWS);
+    const dialogHeight = () => listHeight() + CHROME_ROWS;
+    const dialogOffset = () => Math.min(0, Math.floor(termHeight / 4 - dialogHeight() / 2 - 1));
+    const hasExcerpt = entry => !!transcriptMatchExcerpt(searchIndex().get(entry.id), entry, query());
+    const maxViewportStart = createMemo(() => pickerLastStart(pickerRows(), listHeight(), hasExcerpt));
+    const visiblePickerRows = createMemo(() => pickerWindow(pickerRows(), Math.min(viewportStart(), maxViewportStart()), listHeight(), hasExcerpt));
+    let previousSelection = [];
+    let deletedAt;
+    createEffect(() => {
+      const rows = selectableEntries();
+      const position = rows.findIndex(entry => entry.id === previousSelection[cursor()]?.id);
+      if (rows !== previousSelection && (rows.length !== previousSelection.length || rows.some((entry, index) => entry.id !== previousSelection[index]?.id))) {
+        // A search/filter/collapse changed the tree: reveal the retained row or
+        // start at the first result rather than leaving a stale window open.
+        if (deletedAt !== undefined) {
+          setCursor(Math.max(0, Math.min(deletedAt, rows.length - 1)));
+          deletedAt = undefined;
+        } else {
+          const next = position >= 0 ? position : 0;
+          setCursor(next);
+          const id = rows[next]?.id;
+          setViewportStart(position < 0 || next === 0 ? 0 : Math.max(0, pickerRows().findIndex(row => row.kind === "item" && row.entry.id === id)));
+        }
+      } else if (cursor() >= rows.length) setCursor(Math.max(0, rows.length - 1));
+      previousSelection = rows;
+    });
+    const previewCache = new Map();
+    let previewTimer;
+    const previewID = () => selectableEntries()[cursor()]?.id;
+    const loadPreview = async id => {
+      if (!id) return;
+      const cached = previewCache.get(id);
+      if (cached !== undefined) {
+        setPreviewText(cached);
+        return;
+      }
+      try {
+        const text = await fetchTranscriptText(api, id);
+        previewCache.set(id, text);
+        if (showPreview() && previewID() === id) setPreviewText(text);
+      } catch {}
+    };
+    const currentSessionID = () => {
+      const route = api.route.current;
+      if (route.name !== "session") return undefined;
+      const params = route.params;
+      return params && typeof params.sessionID === "string" ? params.sessionID : undefined;
+    };
+    const close = () => {
+      cleanup();
+      api.ui.dialog.clear();
+    };
+    createEffect(() => {
+      const showing = showPreview();
+      const id = previewID();
+      if (previewTimer) clearTimeout(previewTimer);
+      if (!showing || !id) return;
+      const cached = previewCache.get(id);
+      if (cached !== undefined) {
+        setPreviewText(cached);
+        return;
+      }
+      // Never show another session's transcript beneath the new selection.
+      setPreviewText("Loading…");
+      previewTimer = setTimeout(() => void loadPreview(id), 120);
+    });
+    const togglePreview = () => setShowPreview(value => !value);
+    const selectCursor = index => {
+      const count = selectableEntries().length;
+      if (count === 0) return;
+      cancelDelete();
+      const next = Math.max(0, Math.min(count - 1, index));
+      const id = selectableEntries()[next].id;
+      const flat = pickerRows();
+      const target = flat.findIndex(row => row.kind === "item" && row.entry.id === id);
+      let start = Math.min(viewportStart(), maxViewportStart());
+      if (target < start) start = target;else while (start < target && !pickerWindow(flat, start, listHeight(), hasExcerpt).some(row => row.kind === "item" && row.entry.id === id)) start++;
+      setViewportStart(Math.max(0, Math.min(start, maxViewportStart())));
+      setCursor(next);
+    };
+    const moveCursor = delta => selectCursor(cursor() + delta);
+
+    // Match OpenTUI's scrollbox: honor every wheel event's delta. The viewport
+    // stays independent of selection, so fast scrolling cannot recenter on hover.
+    const scrollPicker = scroll => {
+      if (showPreview() || !scroll || scroll.direction !== "up" && scroll.direction !== "down") return;
+      const amount = Math.trunc(scroll.delta) * (scroll.direction === "down" ? 1 : -1);
+      setViewportStart(start => Math.max(0, Math.min(maxViewportStart(), start + amount)));
+    };
+
+    // Delete confirmation lives in its own layer, registered only while a row
+    // is armed, so y/n never shadow the search box's typing.
+    let disposeConfirm;
+    let confirmTimer;
+    const cancelDelete = () => {
+      if (confirmTimer) clearTimeout(confirmTimer);
+      confirmTimer = undefined;
+      disposeConfirm?.();
+      disposeConfirm = undefined;
+      setPendingDelete(undefined);
+    };
+    const confirmArmed = () => {
+      const armed = pendingDelete();
+      if (!armed) return false;
+      void deleteEntry(armed);
+      return true;
+    };
+
+    // Escape first closes the transcript overlay, then the picker. One Escape
+    // can reach both the focused search input and the key layer (sometimes in
+    // separate ticks), so ignore the duplicate that trails right behind.
+    let escapeHandledAt = 0;
+    const handleEscape = () => {
+      const now = Date.now();
+      if (escapeHandledAt > now) return;
+      if (showPreview()) {
+        setShowPreview(false);
+        escapeHandledAt = now + 150;
+        return;
+      }
+      if (pendingDelete()) {
+        cancelDelete();
+        escapeHandledAt = now + 150;
+        return;
+      }
+      cancelDelete();
+      close();
+    };
+    const deleteEntry = async entry => {
+      cancelDelete();
+      try {
+        const result = await api.client.session.delete({
+          sessionID: entry.id,
+          directory: entry.dir || undefined
+        });
+        if (result && "error" in result && result.error) throw result.error;
+        const {
+          entries: remaining
+        } = await fetchEntries(api);
+        if (remaining.some(item => item.id === entry.id)) {
+          setAllEntries(remaining);
+          api.ui.toast({
+            message: "Session was not deleted",
+            variant: "error"
+          });
+          return;
+        }
+        deletedAt = selectableEntries().findIndex(item => item.id === entry.id);
+        if (deletedAt < 0) deletedAt = undefined;
+        setAllEntries(remaining);
+        api.ui.toast({
+          message: `Deleted "${truncate(entry.title, 40)}"`,
+          variant: "info"
+        });
+        if (currentSessionID() === entry.id) api.route.navigate("home");
+      } catch {
+        api.ui.toast({
+          message: "Could not delete session",
+          variant: "error"
+        });
+      }
+    };
+    const armDelete = entry => {
+      setPendingDelete(entry);
+      if (confirmTimer) clearTimeout(confirmTimer);
+      confirmTimer = setTimeout(cancelDelete, 5000);
+      disposeConfirm?.();
+      disposeConfirm = api.keymap.registerLayer({
+        mode: "modal",
+        priority: 20,
+        bindings: [{
+          key: "y",
+          desc: "Confirm delete",
+          preventDefault: true,
+          cmd: () => {
+            confirmArmed();
+          }
+        }, {
+          key: "alt+d",
+          desc: "Confirm delete",
+          preventDefault: true,
+          cmd: () => {
+            confirmArmed();
+          }
+        }, {
+          key: "enter",
+          desc: "Confirm delete",
+          preventDefault: true,
+          cmd: () => {
+            confirmArmed();
+          }
+        }, {
+          key: "n",
+          desc: "Cancel delete",
+          preventDefault: true,
+          cmd: cancelDelete
+        }, {
+          key: "escape",
+          desc: "Cancel delete",
+          preventDefault: true,
+          cmd: cancelDelete
+        }]
+      });
+    };
+    const forkEntry = async entry => {
+      try {
+        const result = await api.client.session.fork({
+          sessionID: entry.id,
+          directory: entry.dir || undefined
+        });
+        const created = result?.data ?? result;
+        if (!created?.id) throw new Error("fork returned no session");
+        cleanup();
+        api.ui.dialog.clear();
+        api.route.navigate("session", {
+          sessionID: created.id
+        });
+        api.ui.toast({
+          message: `Forked "${truncate(entry.title, 40)}"`,
+          variant: "info"
+        });
+      } catch {
+        api.ui.toast({
+          message: "Could not fork session",
+          variant: "error"
+        });
+      }
+    };
+    const choose = entry => {
+      const target = entry ?? selectableEntries()[cursor()];
+      if (!target) return;
+      cleanup();
+      api.ui.dialog.clear();
+      api.route.navigate("session", {
+        sessionID: target.id
+      });
+    };
+    const disposeNav = api.keymap.registerLayer({
+      mode: "modal",
+      priority: 1,
+      bindings: [{
+        key: "up",
+        desc: "Previous session",
+        preventDefault: true,
+        cmd: () => moveCursor(-1)
+      }, {
+        key: "down",
+        desc: "Next session",
+        preventDefault: true,
+        cmd: () => moveCursor(1)
+      }, {
+        key: "pageup",
+        desc: "Page up",
+        preventDefault: true,
+        cmd: () => moveCursor(-10)
+      }, {
+        key: "pagedown",
+        desc: "Page down",
+        preventDefault: true,
+        cmd: () => moveCursor(10)
+      }, {
+        key: "home",
+        desc: "First session",
+        preventDefault: true,
+        cmd: () => selectCursor(0)
+      }, {
+        key: "end",
+        desc: "Last session",
+        preventDefault: true,
+        cmd: () => selectCursor(selectableEntries().length - 1)
+      }, {
+        key: "enter",
+        desc: "Open session",
+        preventDefault: true,
+        cmd: () => {
+          if (confirmArmed()) return;
+          choose();
+        }
+      }, {
+        key: "alt+p",
+        desc: "Toggle transcript preview",
+        preventDefault: true,
+        cmd: togglePreview
+      }, {
+        key: "ctrl+s",
+        desc: "Pin session",
+        preventDefault: true,
+        cmd: () => {
+          const entry = selectableEntries()[cursor()];
+          if (entry) onTogglePin("sessions", entry.id);
+        }
+      }, {
+        key: "ctrl+d",
+        desc: "Pin directory",
+        preventDefault: true,
+        cmd: () => {
+          const entry = selectableEntries()[cursor()];
+          if (entry) onTogglePin("directories", entry.dir);
+        }
+      }, {
+        key: "alt+d",
+        desc: "Delete session",
+        preventDefault: true,
+        cmd: () => {
+          if (confirmArmed()) return;
+          const target = selectableEntries()[cursor()];
+          if (target) armDelete(target);
+        }
+      }, {
+        key: "ctrl+f",
+        desc: "Fork session",
+        preventDefault: true,
+        cmd: () => {
+          const target = selectableEntries()[cursor()];
+          if (target) void forkEntry(target);
+        }
+      }, {
+        key: "ctrl+g",
+        desc: "Toggle project scope",
+        preventDefault: true,
+        cmd: () => {
+          const target = selectableEntries()[cursor()];
+          if (scope()) setScope(undefined);else if (target) setScope(target.group);
+        }
+      }, {
+        key: "alt+w",
+        desc: "Filter needs input",
+        preventDefault: true,
+        cmd: () => setWaitingOnly(value => !value)
+      }, {
+        key: "alt+s",
+        desc: "Filter pinned sessions",
+        preventDefault: true,
+        cmd: () => setPinnedOnly(value => !value)
+      }, {
+        key: "escape",
+        desc: "Close",
+        preventDefault: true,
+        cmd: handleEscape
+      }]
+    });
+    const cleanup = () => {
+      if (!alive) return;
+      alive = false;
+      if (confirmTimer) clearTimeout(confirmTimer);
+      pickerState = {
+        query: query(),
+        scope: scope(),
+        waitingOnly: waitingOnly(),
+        pinnedOnly: pinnedOnly()
+      };
+      disposeNav();
+      disposeConfirm?.();
+      disposeConfirm = undefined;
+      if (previewTimer) clearTimeout(previewTimer);
+    };
+    api.ui.dialog.replace(() => (() => {
+      var _el$73 = _$createElement("box"),
+        _el$74 = _$createElement("box"),
+        _el$75 = _$createElement("box"),
+        _el$76 = _$createElement("text"),
+        _el$77 = _$createTextNode(`Sessions `),
+        _el$78 = _$createElement("span"),
+        _el$79 = _$createTextNode(`(`),
+        _el$80 = _$createTextNode(`)`),
+        _el$81 = _$createElement("text"),
+        _el$83 = _$createElement("box"),
+        _el$84 = _$createElement("input"),
+        _el$87 = _$createElement("box"),
+        _el$88 = _$createElement("text"),
+        _el$89 = _$createElement("text"),
+        _el$90 = _$createElement("text"),
+        _el$91 = _$createElement("box"),
+        _el$94 = _$createElement("box"),
+        _el$95 = _$createElement("text");
+      _$insertNode(_el$73, _el$74);
+      _$insertNode(_el$73, _el$91);
+      _$insertNode(_el$73, _el$94);
+      _$setProp(_el$73, "flexDirection", "column");
+      _$setProp(_el$73, "paddingTop", 1);
+      _$setProp(_el$73, "paddingBottom", 1);
+      _$setProp(_el$73, "gap", 1);
+      _$insertNode(_el$74, _el$75);
+      _$insertNode(_el$74, _el$83);
+      _$insertNode(_el$74, _el$87);
+      _$setProp(_el$74, "paddingLeft", 4);
+      _$setProp(_el$74, "paddingRight", 4);
+      _$insertNode(_el$75, _el$76);
+      _$insertNode(_el$75, _el$81);
+      _$setProp(_el$75, "flexDirection", "row");
+      _$setProp(_el$75, "justifyContent", "space-between");
+      _$insertNode(_el$76, _el$77);
+      _$insertNode(_el$76, _el$78);
+      _$insertNode(_el$78, _el$79);
+      _$insertNode(_el$78, _el$80);
+      _$insert(_el$78, () => selectableEntries().length, _el$80);
+      _$insertNode(_el$81, _$createTextNode(`esc`));
+      _$setProp(_el$81, "onMouseUp", close);
+      _$insertNode(_el$83, _el$84);
+      _$setProp(_el$83, "paddingTop", 1);
+      _$setProp(_el$84, "focused", true);
+      _$setProp(_el$84, "placeholder", "Search title, directory, transcript…");
+      _$setProp(_el$84, "cursorStyle", {
+        style: "line",
+        blinking: false
+      });
+      _$setProp(_el$84, "onInput", value => {
+        if (pendingDelete()) return;
+        setQuery(value);
+      });
+      _$setProp(_el$84, "onSubmit", () => {
+        if (confirmArmed()) return;
+        choose();
+      });
+      _$setProp(_el$84, "onKeyDown", event => {
+        if (event.name === "escape") {
+          event.preventDefault();
+          handleEscape();
+          return;
+        }
+        if (event.ctrl && event.name === "x") {
+          event.preventDefault();
+          if (confirmArmed()) return;
+          const target = selectableEntries()[cursor()];
+          if (target) armDelete(target);
+          return;
+        }
+        if (event.ctrl && event.name === "f") {
+          event.preventDefault();
+          const target = selectableEntries()[cursor()];
+          if (target) void forkEntry(target);
+          return;
+        }
+        if (pendingDelete()) {
+          if (event.name === "y" || event.name === "enter" || event.name === "return") {
+            event.preventDefault();
+            confirmArmed();
+            return;
+          }
+          if (event.name === "n") {
+            event.preventDefault();
+            cancelDelete();
+            return;
+          }
+        }
+      });
+      _$insert(_el$74, _$createComponent(Show, {
+        get when() {
+          return coverageLabel();
+        },
+        get children() {
+          var _el$85 = _$createElement("box"),
+            _el$86 = _$createElement("text");
+          _$insertNode(_el$85, _el$86);
+          _$setProp(_el$85, "paddingTop", 1);
+          _$insert(_el$86, coverageLabel);
+          _$effect(_$p => _$setProp(_el$86, "style", {
+            fg: api.theme.current.textMuted
+          }, _$p));
+          return _el$85;
+        }
+      }), _el$87);
+      _$insertNode(_el$87, _el$88);
+      _$insertNode(_el$87, _el$89);
+      _$insertNode(_el$87, _el$90);
+      _$setProp(_el$87, "flexDirection", "row");
+      _$setProp(_el$87, "gap", 2);
+      _$setProp(_el$87, "paddingTop", 1);
+      _$setProp(_el$88, "onMouseDown", () => {
+        const group = currentProject();
+        if (group) setScope(scope() === group ? undefined : group);else api.ui.toast({
+          message: "No current project to filter",
+          variant: "info"
+        });
+      });
+      _$insert(_el$88, (() => {
+        var _c$6 = _$memo(() => !!scope());
+        return () => _c$6() ? `Project: ${truncate(scope(), 22)}` : "Project: all";
+      })());
+      _$setProp(_el$89, "onMouseDown", () => setWaitingOnly(value => !value));
+      _$insert(_el$89, () => waitingOnly() ? "● Needs input" : "○ Needs input");
+      _$setProp(_el$90, "onMouseDown", () => setPinnedOnly(value => !value));
+      _$insert(_el$90, () => pinnedOnly() ? "★ Pinned" : "☆ Pinned");
+      _$setProp(_el$91, "flexDirection", "column");
+      _$setProp(_el$91, "flexGrow", 1);
+      _$setProp(_el$91, "overflow", "hidden");
+      _$setProp(_el$91, "onMouseScroll", event => {
+        scrollPicker(event.scroll);
+      });
+      _$insert(_el$91, _$createComponent(For, {
+        get each() {
+          return visiblePickerRows();
+        },
+        children: row => {
+          if (row.kind === "group") return (() => {
+            var _el$108 = _$createElement("box"),
+              _el$109 = _$createElement("text"),
+              _el$110 = _$createElement("text"),
+              _el$111 = _$createTextNode(` (`),
+              _el$112 = _$createTextNode(`)`);
+            _$insertNode(_el$108, _el$109);
+            _$insertNode(_el$108, _el$110);
+            _$setProp(_el$108, "flexDirection", "row");
+            _$setProp(_el$108, "paddingLeft", 4);
+            _$setProp(_el$108, "paddingRight", 4);
+            _$setProp(_el$108, "onMouseDown", () => setCollapsed(state => ({
+              ...state,
+              [row.dir]: !state[row.dir]
+            })));
+            _$setProp(_el$109, "flexGrow", 1);
+            _$setProp(_el$109, "flexShrink", 1);
+            _$setProp(_el$109, "wrapMode", "none");
+            _$insert(_el$109, () => collapsed()[row.dir] && !query().trim() ? "▸ " : "▾ ", null);
+            _$insert(_el$109, () => row.pinned ? "★ " : "", null);
+            _$insert(_el$109, () => row.label, null);
+            _$insertNode(_el$110, _el$111);
+            _$insertNode(_el$110, _el$112);
+            _$setProp(_el$110, "flexShrink", 0);
+            _$insert(_el$110, () => row.count, _el$112);
+            _$effect(_p$ => {
+              var _v$58 = row.continued ? 0 : 1,
+                _v$59 = {
+                  fg: api.theme.current.accent
+                },
+                _v$60 = TextAttributes.BOLD,
+                _v$61 = {
+                  fg: api.theme.current.textMuted
+                };
+              _v$58 !== _p$.e && (_p$.e = _$setProp(_el$108, "paddingTop", _v$58, _p$.e));
+              _v$59 !== _p$.t && (_p$.t = _$setProp(_el$109, "style", _v$59, _p$.t));
+              _v$60 !== _p$.a && (_p$.a = _$setProp(_el$109, "attributes", _v$60, _p$.a));
+              _v$61 !== _p$.o && (_p$.o = _$setProp(_el$110, "style", _v$61, _p$.o));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined,
+              o: undefined
+            });
+            return _el$108;
+          })();
+          const excerpt = createMemo(() => transcriptMatchExcerpt(searchIndex().get(row.entry.id), row.entry, query()));
+          return (() => {
+            var _el$113 = _$createElement("box"),
+              _el$114 = _$createElement("box"),
+              _el$115 = _$createElement("text"),
+              _el$118 = _$createElement("text");
+            _$insertNode(_el$113, _el$114);
+            _$setProp(_el$113, "flexDirection", "column");
+            _$setProp(_el$113, "paddingLeft", 6);
+            _$setProp(_el$113, "paddingRight", 4);
+            _$setProp(_el$113, "onMouseMove", () => {
+              // Repainting under a stationary pointer must not select
+              // another row while the wheel is moving the viewport.
+              const index = selectableEntries().findIndex(entry => entry.id === row.entry.id);
+              if (index >= 0) setCursor(index);
+            });
+            _$setProp(_el$113, "onMouseDown", event => event.button === RIGHT_BUTTON ? (cleanup(), api.ui.dialog.clear(), openInCmuxWorkspace(api, row.entry)) : choose(row.entry));
+            _$insertNode(_el$114, _el$115);
+            _$insertNode(_el$114, _el$118);
+            _$setProp(_el$114, "flexDirection", "row");
+            _$setProp(_el$114, "gap", 1);
+            _$setProp(_el$115, "flexShrink", 0);
+            _$insert(_el$115, () => row.last ? "└" : "├");
+            _$insert(_el$114, _$createComponent(Show, {
+              get when() {
+                return row.entry.id === currentSessionID();
+              },
+              get children() {
+                var _el$116 = _$createElement("text");
+                _$insertNode(_el$116, _$createTextNode(`●`));
+                _$setProp(_el$116, "flexShrink", 0);
+                _$effect(_$p => _$setProp(_el$116, "style", {
+                  fg: row.entry.id === selectableEntries()[cursor()]?.id ? api.theme.current.text : api.theme.current.primary
+                }, _$p));
+                return _el$116;
+              }
+            }), _el$118);
+            _$insert(_el$114, _$createComponent(Highlighted, {
+              get text() {
+                return `${pins().sessions.includes(row.entry.id) ? "★ " : ""}${truncate(row.entry.title, pins().sessions.includes(row.entry.id) ? 59 : 61)}`;
+              },
+              get query() {
+                return query();
+              },
+              get bold() {
+                return row.entry.id === selectableEntries()[cursor()]?.id;
+              },
+              get color() {
+                return _$memo(() => row.entry.id === selectableEntries()[cursor()]?.id)() ? api.theme.current.text : api.theme.current.text;
+              },
+              get matchColor() {
+                return _$memo(() => row.entry.id === selectableEntries()[cursor()]?.id)() ? api.theme.current.text : api.theme.current.warning;
+              }
+            }), _el$118);
+            _$setProp(_el$118, "flexShrink", 0);
+            _$insert(_el$118, (() => {
+              var _c$0 = _$memo(() => pendingDelete()?.id === row.entry.id);
+              return () => _c$0() ? "press y to delete" : `${ago(row.entry.updated)}${query().trim() && !`${row.entry.title} ${row.entry.dir}`.toLowerCase().includes(query().trim().toLowerCase()) ? " · transcript match" : ""}`;
+            })());
+            _$insert(_el$113, _$createComponent(Show, {
+              get when() {
+                return excerpt();
+              },
+              children: match => (() => {
+                var _el$119 = _$createElement("box"),
+                  _el$120 = _$createElement("text");
+                _$insertNode(_el$119, _el$120);
+                _$setProp(_el$119, "flexDirection", "row");
+                _$setProp(_el$119, "gap", 1);
+                _$setProp(_el$119, "paddingLeft", 2);
+                _$insertNode(_el$120, _$createTextNode(`↳`));
+                _$setProp(_el$120, "flexShrink", 0);
+                _$insert(_el$119, _$createComponent(Highlighted, {
+                  get text() {
+                    return match();
+                  },
+                  get query() {
+                    return query();
+                  },
+                  get color() {
+                    return _$memo(() => row.entry.id === selectableEntries()[cursor()]?.id)() ? api.theme.current.text : api.theme.current.textMuted;
+                  },
+                  get matchColor() {
+                    return api.theme.current.warning;
+                  }
+                }), null);
+                _$effect(_$p => _$setProp(_el$120, "style", {
+                  fg: api.theme.current.textMuted
+                }, _$p));
+                return _el$119;
+              })()
+            }), null);
+            _$effect(_p$ => {
+              var _v$62 = row.entry.id === selectableEntries()[cursor()]?.id ? api.theme.current.backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+                _v$63 = {
+                  fg: row.entry.id === selectableEntries()[cursor()]?.id ? api.theme.current.text : api.theme.current.textMuted
+                },
+                _v$64 = {
+                  fg: pendingDelete()?.id === row.entry.id ? api.theme.current.error : row.entry.id === selectableEntries()[cursor()]?.id ? api.theme.current.text : api.theme.current.textMuted
+                };
+              _v$62 !== _p$.e && (_p$.e = _$setProp(_el$113, "backgroundColor", _v$62, _p$.e));
+              _v$63 !== _p$.t && (_p$.t = _$setProp(_el$115, "style", _v$63, _p$.t));
+              _v$64 !== _p$.a && (_p$.a = _$setProp(_el$118, "style", _v$64, _p$.a));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined
+            });
+            return _el$113;
+          })();
+        }
+      }), null);
+      _$insert(_el$91, _$createComponent(Show, {
+        get when() {
+          return matchedGroups().length === 0;
+        },
+        get children() {
+          var _el$92 = _$createElement("box"),
+            _el$93 = _$createElement("text");
+          _$insertNode(_el$92, _el$93);
+          _$setProp(_el$92, "paddingLeft", 4);
+          _$setProp(_el$92, "paddingRight", 4);
+          _$insert(_el$93, (() => {
+            var _c$7 = _$memo(() => !!(waitingOnly() && waitingCoverage() === "loading"));
+            return () => _c$7() ? "Checking which sessions need input…" : _$memo(() => !!(waitingOnly() && waitingCoverage() === "unavailable"))() ? "Needs-input data unavailable · turn off the filter" : _$memo(() => !!(pinnedOnly() && pins().sessions.length === 0))() ? "No pinned sessions yet · ctrl+s pins a session" : _$memo(() => !!(!indexProgress().complete && query().trim()))() ? "No matches yet · still searching transcripts…" : _$memo(() => !!scope())() ? `No matches in ${scope()} · ctrl+g for all projects` : waitingOnly() ? "No sessions need input with these filters" : "No sessions match · try another search";
+          })());
+          _$effect(_$p => _$setProp(_el$93, "style", {
+            fg: api.theme.current.textMuted
+          }, _$p));
+          return _el$92;
+        }
+      }), null);
+      _$insertNode(_el$94, _el$95);
+      _$setProp(_el$94, "paddingLeft", 4);
+      _$setProp(_el$94, "paddingRight", 4);
+      _$setProp(_el$94, "flexShrink", 0);
+      _$setProp(_el$94, "flexDirection", "column");
+      _$insert(_el$95, (() => {
+        var _c$8 = _$memo(() => !!pendingDelete());
+        return () => _c$8() ? `Delete "${truncate(pendingDelete().title, 40)}"? y confirm · n cancel` : "↑↓ move · enter open · ctrl+g project · option+w input · option+s pinned · option+p preview";
+      })());
+      _$insert(_el$94, _$createComponent(Show, {
+        get when() {
+          return !pendingDelete();
+        },
+        get children() {
+          var _el$96 = _$createElement("text");
+          _$insertNode(_el$96, _$createTextNode(`ctrl+s/d pin · option+d delete · ctrl+f fork · esc close`));
+          _$effect(_$p => _$setProp(_el$96, "style", {
+            fg: api.theme.current.textMuted
+          }, _$p));
+          return _el$96;
+        }
+      }), null);
+      _$insert(_el$73, _$createComponent(Show, {
+        get when() {
+          return showPreview();
+        },
+        get children() {
+          var _el$98 = _$createElement("box"),
+            _el$99 = _$createElement("box"),
+            _el$100 = _$createElement("text"),
+            _el$101 = _$createElement("text"),
+            _el$105 = _$createElement("scrollbox"),
+            _el$106 = _$createElement("text");
+          _$insertNode(_el$98, _el$99);
+          _$insertNode(_el$98, _el$105);
+          _$insertNode(_el$98, _el$106);
+          _$setProp(_el$98, "position", "absolute");
+          _$setProp(_el$98, "left", 0);
+          _$setProp(_el$98, "top", 0);
+          _$setProp(_el$98, "width", dialogWidth);
+          _$setProp(_el$98, "flexDirection", "column");
+          _$setProp(_el$98, "paddingLeft", 4);
+          _$setProp(_el$98, "paddingRight", 4);
+          _$setProp(_el$98, "paddingTop", 1);
+          _$setProp(_el$98, "paddingBottom", 1);
+          _$setProp(_el$98, "gap", 1);
+          _$insertNode(_el$99, _el$100);
+          _$insertNode(_el$99, _el$101);
+          _$setProp(_el$99, "flexDirection", "row");
+          _$setProp(_el$99, "justifyContent", "space-between");
+          _$insert(_el$100, (() => {
+            var _c$9 = _$memo(() => !!previewID());
+            return () => _c$9() ? truncate(selectableEntries()[cursor()].title, dialogWidth - 18) : "Preview";
+          })());
+          _$insertNode(_el$101, _$createTextNode(`esc close`));
+          _$insert(_el$98, _$createComponent(Show, {
+            get when() {
+              return previewID();
+            },
+            get children() {
+              var _el$103 = _$createElement("text"),
+                _el$104 = _$createTextNode(` · `);
+              _$insertNode(_el$103, _el$104);
+              _$insert(_el$103, () => prettyDir(selectableEntries()[cursor()].dir, process.env.HOME ?? ""), _el$104);
+              _$insert(_el$103, () => ago(selectableEntries()[cursor()].updated), null);
+              _$effect(_$p => _$setProp(_el$103, "style", {
+                fg: api.theme.current.textMuted
+              }, _$p));
+              return _el$103;
+            }
+          }), _el$105);
+          _$setProp(_el$105, "flexGrow", 1);
+          _$setProp(_el$105, "scrollbarOptions", {
+            visible: false
+          });
+          _$insert(_el$105, _$createComponent(Show, {
+            get when() {
+              return previewID();
+            },
+            get fallback() {
+              return (() => {
+                var _el$122 = _$createElement("text");
+                _$insertNode(_el$122, _$createTextNode(`Select a session to preview`));
+                _$effect(_$p => _$setProp(_el$122, "style", {
+                  fg: api.theme.current.textMuted
+                }, _$p));
+                return _el$122;
+              })();
+            },
+            get children() {
+              return _$createComponent(Show, {
+                get when() {
+                  return previewText();
+                },
+                get fallback() {
+                  return (() => {
+                    var _el$124 = _$createElement("text");
+                    _$insertNode(_el$124, _$createTextNode(`Loading…`));
+                    _$effect(_$p => _$setProp(_el$124, "style", {
+                      fg: api.theme.current.textMuted
+                    }, _$p));
+                    return _el$124;
+                  })();
+                },
+                children: text => getMarkdownStyle(api.theme.current, api.renderer?.nativeSession) ? (() => {
+                  var _el$126 = _$createElement("markdown");
+                  _$effect(_p$ => {
+                    var _v$65 = text(),
+                      _v$66 = getMarkdownStyle(api.theme.current, api.renderer?.nativeSession),
+                      _v$67 = getTreeSitterClient();
+                    _v$65 !== _p$.e && (_p$.e = _$setProp(_el$126, "content", _v$65, _p$.e));
+                    _v$66 !== _p$.t && (_p$.t = _$setProp(_el$126, "syntaxStyle", _v$66, _p$.t));
+                    _v$67 !== _p$.a && (_p$.a = _$setProp(_el$126, "treeSitterClient", _v$67, _p$.a));
+                    return _p$;
+                  }, {
+                    e: undefined,
+                    t: undefined,
+                    a: undefined
+                  });
+                  return _el$126;
+                })() : (() => {
+                  var _el$127 = _$createElement("text");
+                  _$setProp(_el$127, "wrapMode", "word");
+                  _$insert(_el$127, text);
+                  return _el$127;
+                })()
+              });
+            }
+          }));
+          _$insertNode(_el$106, _$createTextNode(`↑↓ switch session · esc back to picker`));
+          _$effect(_p$ => {
+            var _v$38 = dialogHeight(),
+              _v$39 = api.theme.current.backgroundPanel,
+              _v$40 = TextAttributes.BOLD,
+              _v$41 = {
+                fg: api.theme.current.textMuted
+              },
+              _v$42 = {
+                fg: api.theme.current.textMuted
+              };
+            _v$38 !== _p$.e && (_p$.e = _$setProp(_el$98, "height", _v$38, _p$.e));
+            _v$39 !== _p$.t && (_p$.t = _$setProp(_el$98, "backgroundColor", _v$39, _p$.t));
+            _v$40 !== _p$.a && (_p$.a = _$setProp(_el$100, "attributes", _v$40, _p$.a));
+            _v$41 !== _p$.o && (_p$.o = _$setProp(_el$101, "style", _v$41, _p$.o));
+            _v$42 !== _p$.i && (_p$.i = _$setProp(_el$106, "style", _v$42, _p$.i));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined,
+            i: undefined
+          });
+          return _el$98;
+        }
+      }), null);
+      _$effect(_p$ => {
+        var _v$43 = dialogHeight(),
+          _v$44 = dialogOffset(),
+          _v$45 = api.theme.current.backgroundPanel,
+          _v$46 = TextAttributes.BOLD,
+          _v$47 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$48 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$49 = query(),
+          _v$50 = api.theme.current.textMuted,
+          _v$51 = api.theme.current.backgroundPanel,
+          _v$52 = api.theme.current.text,
+          _v$53 = api.theme.current.primary,
+          _v$54 = {
+            fg: scope() ? api.theme.current.accent : api.theme.current.textMuted
+          },
+          _v$55 = {
+            fg: waitingOnly() ? api.theme.current.warning : api.theme.current.textMuted
+          },
+          _v$56 = {
+            fg: pinnedOnly() ? api.theme.current.accent : api.theme.current.textMuted
+          },
+          _v$57 = {
+            fg: pendingDelete() ? api.theme.current.warning : api.theme.current.textMuted
+          };
+        _v$43 !== _p$.e && (_p$.e = _$setProp(_el$73, "height", _v$43, _p$.e));
+        _v$44 !== _p$.t && (_p$.t = _$setProp(_el$73, "marginTop", _v$44, _p$.t));
+        _v$45 !== _p$.a && (_p$.a = _$setProp(_el$73, "backgroundColor", _v$45, _p$.a));
+        _v$46 !== _p$.o && (_p$.o = _$setProp(_el$76, "attributes", _v$46, _p$.o));
+        _v$47 !== _p$.i && (_p$.i = _$setProp(_el$78, "style", _v$47, _p$.i));
+        _v$48 !== _p$.n && (_p$.n = _$setProp(_el$81, "style", _v$48, _p$.n));
+        _v$49 !== _p$.s && (_p$.s = _$setProp(_el$84, "value", _v$49, _p$.s));
+        _v$50 !== _p$.h && (_p$.h = _$setProp(_el$84, "placeholderColor", _v$50, _p$.h));
+        _v$51 !== _p$.r && (_p$.r = _$setProp(_el$84, "focusedBackgroundColor", _v$51, _p$.r));
+        _v$52 !== _p$.d && (_p$.d = _$setProp(_el$84, "focusedTextColor", _v$52, _p$.d));
+        _v$53 !== _p$.l && (_p$.l = _$setProp(_el$84, "cursorColor", _v$53, _p$.l));
+        _v$54 !== _p$.u && (_p$.u = _$setProp(_el$88, "style", _v$54, _p$.u));
+        _v$55 !== _p$.c && (_p$.c = _$setProp(_el$89, "style", _v$55, _p$.c));
+        _v$56 !== _p$.w && (_p$.w = _$setProp(_el$90, "style", _v$56, _p$.w));
+        _v$57 !== _p$.m && (_p$.m = _$setProp(_el$95, "style", _v$57, _p$.m));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined,
+        a: undefined,
+        o: undefined,
+        i: undefined,
+        n: undefined,
+        s: undefined,
+        h: undefined,
+        r: undefined,
+        d: undefined,
+        l: undefined,
+        u: undefined,
+        c: undefined,
+        w: undefined,
+        m: undefined
+      });
+      return _el$73;
+    })(), () => {
+      cleanup();
+    });
+    api.ui.dialog.setSize("xlarge");
+  };
+
+  // Read-only digest dialog: spend per project, last day beside lifetime.
+  // Same message-level sums as `sesh costs`; the dialog just renders them.
+  const openCosts = async (command = false) => {
+    if (!command && api.mode.current() !== BASE_MODE) return;
+    if (!command && api.renderer.currentFocusedEditor === null) return;
+    let rows = [];
+    let failed = false;
+    try {
+      const db = await openTranscriptDb();
+      if (!db) failed = true;else {
+        try {
+          const cutoff = Date.now() - 86400000;
+          const legacyTables = db.query("SELECT count(*) AS count FROM sqlite_master WHERE type = 'table' AND name IN ('session', 'message')").get();
+          const raw = db.query(costRowsQuery(cutoff, legacyTables?.count === 2)).all() ?? [];
+          rows = raw.filter(row => typeof row?.directory === "string" && typeof row?.window_cost === "number" && typeof row?.lifetime_cost === "number" && typeof row?.sessions === "number" && row.lifetime_cost > 0).map(row => ({
+            directory: row.directory,
+            window: row.window_cost,
+            lifetime: row.lifetime_cost,
+            sessions: row.sessions
+          }));
+        } finally {
+          db.close();
+        }
+      }
+    } catch {
+      failed = true;
+    }
+    const money = n => n === 0 ? "—" : `$${n.toFixed(2)}`;
+    const home = process.env.HOME ?? "";
+    const disposeKeys = api.keymap.registerLayer({
+      mode: "modal",
+      bindings: [{
+        key: "escape",
+        desc: "Close",
+        preventDefault: true,
+        cmd: () => api.ui.dialog.clear()
+      }]
+    });
+    api.ui.dialog.replace(() => (() => {
+      var _el$128 = _$createElement("box"),
+        _el$129 = _$createElement("text"),
+        _el$130 = _$createTextNode(`Cost digest `),
+        _el$132 = _$createElement("span"),
+        _el$134 = _$createElement("box"),
+        _el$135 = _$createElement("text");
+      _$insertNode(_el$128, _el$129);
+      _$insertNode(_el$128, _el$134);
+      _$setProp(_el$128, "flexDirection", "column");
+      _$setProp(_el$128, "paddingLeft", 4);
+      _$setProp(_el$128, "paddingRight", 4);
+      _$setProp(_el$128, "paddingTop", 1);
+      _$setProp(_el$128, "gap", 1);
+      _$insertNode(_el$129, _el$130);
+      _$insertNode(_el$129, _el$132);
+      _$insertNode(_el$132, _$createTextNode(`(24h · lifetime)`));
+      _$insert(_el$128, _$createComponent(Show, {
+        get when() {
+          return !failed && rows.length > 0;
+        },
+        get fallback() {
+          return (() => {
+            var _el$137 = _$createElement("text");
+            _$insert(_el$137, failed ? "Cost data unavailable." : "No assistant cost recorded.");
+            _$effect(_$p => _$setProp(_el$137, "style", {
+              fg: api.theme.current.textMuted
+            }, _$p));
+            return _el$137;
+          })();
+        },
+        get children() {
+          return _$createComponent(For, {
+            each: rows,
+            children: row => (() => {
+              var _el$138 = _$createElement("box"),
+                _el$139 = _$createElement("text"),
+                _el$140 = _$createElement("text"),
+                _el$141 = _$createElement("text"),
+                _el$142 = _$createTextNode(`(`),
+                _el$143 = _$createTextNode(`)`),
+                _el$144 = _$createElement("text");
+              _$insertNode(_el$138, _el$139);
+              _$insertNode(_el$138, _el$140);
+              _$insertNode(_el$138, _el$141);
+              _$insertNode(_el$138, _el$144);
+              _$setProp(_el$138, "flexDirection", "row");
+              _$setProp(_el$138, "gap", 2);
+              _$setProp(_el$139, "flexShrink", 0);
+              _$insert(_el$139, () => money(row.window));
+              _$setProp(_el$140, "flexShrink", 0);
+              _$insert(_el$140, () => money(row.lifetime));
+              _$insertNode(_el$141, _el$142);
+              _$insertNode(_el$141, _el$143);
+              _$setProp(_el$141, "flexShrink", 0);
+              _$insert(_el$141, () => row.sessions, _el$143);
+              _$setProp(_el$144, "flexGrow", 1);
+              _$setProp(_el$144, "flexShrink", 1);
+              _$setProp(_el$144, "wrapMode", "none");
+              _$insert(_el$144, () => prettyDir(row.directory, home));
+              _$effect(_p$ => {
+                var _v$72 = {
+                    fg: api.theme.current.success
+                  },
+                  _v$73 = {
+                    fg: api.theme.current.textMuted
+                  },
+                  _v$74 = {
+                    fg: api.theme.current.textMuted
+                  };
+                _v$72 !== _p$.e && (_p$.e = _$setProp(_el$139, "style", _v$72, _p$.e));
+                _v$73 !== _p$.t && (_p$.t = _$setProp(_el$140, "style", _v$73, _p$.t));
+                _v$74 !== _p$.a && (_p$.a = _$setProp(_el$141, "style", _v$74, _p$.a));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined,
+                a: undefined
+              });
+              return _el$138;
+            })()
+          });
+        }
+      }), _el$134);
+      _$insertNode(_el$134, _el$135);
+      _$setProp(_el$134, "flexShrink", 0);
+      _$insertNode(_el$135, _$createTextNode(`esc close`));
+      _$effect(_p$ => {
+        var _v$68 = api.theme.current.backgroundPanel,
+          _v$69 = TextAttributes.BOLD,
+          _v$70 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$71 = {
+            fg: api.theme.current.textMuted
+          };
+        _v$68 !== _p$.e && (_p$.e = _$setProp(_el$128, "backgroundColor", _v$68, _p$.e));
+        _v$69 !== _p$.t && (_p$.t = _$setProp(_el$129, "attributes", _v$69, _p$.t));
+        _v$70 !== _p$.a && (_p$.a = _$setProp(_el$132, "style", _v$70, _p$.a));
+        _v$71 !== _p$.o && (_p$.o = _$setProp(_el$135, "style", _v$71, _p$.o));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined,
+        a: undefined,
+        o: undefined
+      });
+      return _el$128;
+    })(), () => {
+      disposeKeys();
+    });
+    api.ui.dialog.setSize("large");
+  };
+
+  // Triage dialog: the waiting set as an openable list. Enter opens the
+  // highlighted session; the sidebar section stays the always-visible view.
+  let lastNeedsID;
+  const openNeeds = async (command = false) => {
+    if (!command && api.mode.current() !== BASE_MODE) return;
+    if (!command && api.renderer.currentFocusedEditor === null) return;
+    let items = [];
+    try {
+      const {
+        entries
+      } = await fetchEntries(api);
+      const db = await openTranscriptDb();
+      if (!db) {
+        api.ui.toast({
+          message: "Needs-input data unavailable",
+          variant: "error"
+        });
+        return;
+      }
+      let waiting;
+      try {
+        waiting = await queryWaitingDetails(db);
+      } finally {
+        db.close();
+      }
+      items = entries.filter(entry => waiting.has(entry.id)).map(entry => ({
+        entry,
+        reason: waiting.get(entry.id)?.reason === "question" ? "awaiting answer" : "run stuck",
+        since: waiting.get(entry.id)?.since
+      })).sort((a, b) => (a.since ?? a.entry.updated) - (b.since ?? b.entry.updated));
+    } catch {
+      api.ui.toast({
+        message: "Could not load sessions",
+        variant: "error"
+      });
+      return;
+    }
+    if (items.length === 0) {
+      api.ui.toast({
+        message: "No sessions are waiting on you.",
+        variant: "info"
+      });
+      return;
+    }
+    const route = api.route.current;
+    const currentID = route.name === "session" ? route.params?.sessionID : undefined;
+    const previous = items.findIndex(item => item.entry.id === (currentID ?? lastNeedsID));
+    const [cursor, setCursor] = createSignal(previous < 0 ? 0 : (previous + 1) % items.length);
+    const moveCursor = delta => setCursor(value => Math.max(0, Math.min(items.length - 1, value + delta)));
+    const choose = (target = items[cursor()]) => {
+      if (!target) return;
+      lastNeedsID = target.entry.id;
+      disposeNav();
+      api.ui.dialog.clear();
+      api.route.navigate("session", {
+        sessionID: target.entry.id
+      });
+    };
+    const disposeNav = api.keymap.registerLayer({
+      mode: "modal",
+      bindings: [{
+        key: "up",
+        desc: "Previous session",
+        preventDefault: true,
+        cmd: () => moveCursor(-1)
+      }, {
+        key: "down",
+        desc: "Next session",
+        preventDefault: true,
+        cmd: () => moveCursor(1)
+      }, {
+        key: "enter",
+        desc: "Open session",
+        preventDefault: true,
+        cmd: () => choose()
+      }, {
+        key: "n",
+        desc: "Open next waiting session",
+        preventDefault: true,
+        cmd: () => {
+          const at = items.findIndex(item => item.entry.id === currentID);
+          choose(items[at < 0 ? cursor() : (at + 1) % items.length]);
+        }
+      }, {
+        key: "escape",
+        desc: "Close",
+        preventDefault: true,
+        cmd: () => api.ui.dialog.clear()
+      }]
+    });
+    const home = process.env.HOME ?? "";
+    api.ui.dialog.replace(() => (() => {
+      var _el$145 = _$createElement("box"),
+        _el$146 = _$createElement("text"),
+        _el$147 = _$createTextNode(`Needs input `),
+        _el$149 = _$createElement("span"),
+        _el$150 = _$createTextNode(`(`),
+        _el$151 = _$createTextNode(` · longest waiting first)`),
+        _el$152 = _$createElement("scrollbox"),
+        _el$153 = _$createElement("box"),
+        _el$154 = _$createElement("text");
+      _$insertNode(_el$145, _el$146);
+      _$insertNode(_el$145, _el$152);
+      _$insertNode(_el$145, _el$153);
+      _$setProp(_el$145, "flexDirection", "column");
+      _$setProp(_el$145, "paddingLeft", 4);
+      _$setProp(_el$145, "paddingRight", 4);
+      _$setProp(_el$145, "paddingTop", 1);
+      _$setProp(_el$145, "gap", 1);
+      _$insertNode(_el$146, _el$147);
+      _$insertNode(_el$146, _el$149);
+      _$insertNode(_el$149, _el$150);
+      _$insertNode(_el$149, _el$151);
+      _$insert(_el$149, () => items.length, _el$151);
+      _$setProp(_el$152, "flexGrow", 1);
+      _$setProp(_el$152, "scrollbarOptions", {
+        visible: false
+      });
+      _$insert(_el$152, _$createComponent(For, {
+        each: items,
+        children: (item, index) => (() => {
+          var _el$156 = _$createElement("box"),
+            _el$157 = _$createElement("text"),
+            _el$158 = _$createElement("text"),
+            _el$159 = _$createElement("text"),
+            _el$160 = _$createTextNode(` · `);
+          _$insertNode(_el$156, _el$157);
+          _$insertNode(_el$156, _el$158);
+          _$insertNode(_el$156, _el$159);
+          _$setProp(_el$156, "flexDirection", "row");
+          _$setProp(_el$156, "gap", 2);
+          _$setProp(_el$156, "paddingLeft", 1);
+          _$setProp(_el$156, "paddingRight", 1);
+          _$setProp(_el$156, "onMouseDown", () => {
+            setCursor(index());
+            choose(item);
+          });
+          _$setProp(_el$157, "flexGrow", 1);
+          _$setProp(_el$157, "flexShrink", 1);
+          _$setProp(_el$157, "wrapMode", "none");
+          _$insert(_el$157, () => truncate(item.entry.title, 48));
+          _$setProp(_el$158, "flexShrink", 0);
+          _$insert(_el$158, () => item.reason);
+          _$insertNode(_el$159, _el$160);
+          _$setProp(_el$159, "flexShrink", 0);
+          _$insert(_el$159, () => prettyDir(item.entry.dir, home), _el$160);
+          _$insert(_el$159, (() => {
+            var _c$1 = _$memo(() => item.since === undefined);
+            return () => _c$1() ? "time unknown" : `waiting ${ago(item.since)}`;
+          })(), null);
+          _$effect(_p$ => {
+            var _v$80 = index() === cursor() ? api.theme.current.backgroundElement : RGBA.fromInts(0, 0, 0, 0),
+              _v$81 = {
+                fg: index() === cursor() ? api.theme.current.text : api.theme.current.text
+              },
+              _v$82 = {
+                fg: index() === cursor() ? api.theme.current.text : api.theme.current.warning
+              },
+              _v$83 = {
+                fg: index() === cursor() ? api.theme.current.text : api.theme.current.textMuted
+              };
+            _v$80 !== _p$.e && (_p$.e = _$setProp(_el$156, "backgroundColor", _v$80, _p$.e));
+            _v$81 !== _p$.t && (_p$.t = _$setProp(_el$157, "style", _v$81, _p$.t));
+            _v$82 !== _p$.a && (_p$.a = _$setProp(_el$158, "style", _v$82, _p$.a));
+            _v$83 !== _p$.o && (_p$.o = _$setProp(_el$159, "style", _v$83, _p$.o));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined
+          });
+          return _el$156;
+        })()
+      }));
+      _$insertNode(_el$153, _el$154);
+      _$setProp(_el$153, "flexShrink", 0);
+      _$insertNode(_el$154, _$createTextNode(`↑↓ navigate · enter open · n open next waiting · esc close`));
+      _$effect(_p$ => {
+        var _v$75 = api.theme.current.backgroundPanel,
+          _v$76 = TextAttributes.BOLD,
+          _v$77 = {
+            fg: api.theme.current.textMuted
+          },
+          _v$78 = Math.max(6, Math.floor(api.renderer.height / 2) - 10),
+          _v$79 = {
+            fg: api.theme.current.textMuted
+          };
+        _v$75 !== _p$.e && (_p$.e = _$setProp(_el$145, "backgroundColor", _v$75, _p$.e));
+        _v$76 !== _p$.t && (_p$.t = _$setProp(_el$146, "attributes", _v$76, _p$.t));
+        _v$77 !== _p$.a && (_p$.a = _$setProp(_el$149, "style", _v$77, _p$.a));
+        _v$78 !== _p$.o && (_p$.o = _$setProp(_el$152, "height", _v$78, _p$.o));
+        _v$79 !== _p$.i && (_p$.i = _$setProp(_el$154, "style", _v$79, _p$.i));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined,
+        a: undefined,
+        o: undefined,
+        i: undefined
+      });
+      return _el$145;
+    })(), () => {
+      disposeNav();
+    });
+    api.ui.dialog.setSize("large");
+  };
+  api.command?.register(() => [{
+    title: "Pick session (all directories)",
+    value: "sesh.pick",
+    description: "Switch to any session across all project directories",
+    category: "Sessions",
+    slash: {
+      name: "sesh"
+    },
+    onSelect: () => {
+      void openPicker(true);
+    }
+  }, {
+    title: "Cost digest (per project)",
+    value: "sesh.costs",
+    description: "Spend per project, last day and lifetime",
+    category: "Sessions",
+    slash: {
+      name: "sesh-costs"
+    },
+    onSelect: () => {
+      void openCosts(true);
+    }
+  }, {
+    title: "Sessions waiting on you",
+    value: "sesh.needs",
+    description: "Unanswered questions and stuck runs",
+    category: "Sessions",
+    slash: {
+      name: "sesh-needs"
+    },
+    onSelect: () => {
+      void openNeeds(true);
+    }
+  }]);
+  api.keymap.registerLayer({
+    bindings: [{
+      key: "alt+o",
+      desc: "Pick session",
+      preventDefault: true,
+      cmd: () => void openPicker()
+    }]
+  });
+};
+let hostOwner = null;
+function adaptTheme(theme) {
+  const opaque = color => RGBA.fromValues(color.r, color.g, color.b, 1);
+  return {
+    text: theme.text.base,
+    textMuted: theme.text.muted,
+    background: theme.background.base,
+    backgroundPanel: opaque(theme.background.raised.base),
+    backgroundElement: opaque(theme.background.raised.high),
+    border: theme.border.base,
+    borderActive: theme.hue.accent[200],
+    borderSubtle: theme.border.base,
+    accent: theme.hue.accent[200],
+    primary: theme.hue.accent[200],
+    secondary: theme.text.action.secondary.base,
+    error: theme.text.feedback.error.base,
+    warning: theme.text.feedback.warning.base,
+    success: theme.text.feedback.success.base,
+    info: theme.text.feedback.info.base,
+    selectedListItemText: theme.text.base,
+    syntaxComment: theme.syntax.comment,
+    syntaxString: theme.syntax.string,
+    syntaxNumber: theme.syntax.number,
+    syntaxKeyword: theme.syntax.keyword,
+    syntaxType: theme.syntax.type,
+    syntaxFunction: theme.syntax.function,
+    syntaxOperator: theme.syntax.operator,
+    syntaxVariable: theme.syntax.variable,
+    syntaxPunctuation: theme.syntax.punctuation,
+    markdownLink: theme.markdown.link,
+    markdownLinkText: theme.markdown.linkText,
+    markdownBlockQuote: theme.markdown.blockQuote
+  };
+}
+function createApi(ctx) {
+  const [dialogOpen, setDialogOpen] = createSignal(false);
+  let sourceTheme;
+  let currentTheme;
+  return {
+    theme: {
+      get current() {
+        if (sourceTheme !== ctx.theme) {
+          sourceTheme = ctx.theme;
+          currentTheme = adaptTheme(sourceTheme);
+        }
+        return currentTheme;
+      }
+    },
+    ui: {
+      toast(opts) {
+        ctx.ui.toast.show({
+          title: opts.title ?? "Sessions",
+          message: opts.message,
+          variant: opts.variant ?? "info"
+        });
+      },
+      dialog: {
+        clear() {
+          ctx.ui.dialog.clear();
+          setDialogOpen(false);
+        },
+        replace(render, onClose) {
+          let closed = false;
+          ctx.ui.dialog.show(render, () => {
+            if (closed) return;
+            closed = true;
+            setDialogOpen(false);
+            onClose?.();
+          });
+          setDialogOpen(true);
+        },
+        setSize(size) {
+          ctx.ui.dialog.set({
+            size
+          });
+        },
+        // V2's Dialog has no reactive open/isOpen accessor; track it locally
+        // from the replace/clear calls above and the host's onClose callback.
+        get open() {
+          return dialogOpen();
+        }
+      }
+    },
+    route: {
+      get current() {
+        const r = ctx.ui.router.current();
+        if (r.type === "session") {
+          return {
+            name: "session",
+            params: {
+              sessionID: r.sessionID
+            }
+          };
+        }
+        return {
+          name: r.type,
+          params: {}
+        };
+      },
+      navigate(name, params) {
+        if (name === "session" && params?.sessionID) {
+          ctx.ui.router.navigate({
+            type: "session",
+            sessionID: params.sessionID
+          });
+        } else if (name === "home") {
+          ctx.ui.router.navigate({
+            type: "home"
+          });
+        }
+      }
+    },
+    state: {
+      path: {
+        get directory() {
+          return ctx.location?.directory ?? process.cwd();
+        }
+      },
+      session: {
+        status(id) {
+          return ctx.data.session.status(id);
+        }
+      }
+    },
+    mode: {
+      current() {
+        return ctx.keymap.mode.current();
+      }
+    },
+    renderer: {
+      get height() {
+        return ctx.renderer?.height ?? 40;
+      },
+      get width() {
+        return ctx.renderer?.width ?? 120;
+      },
+      get root() {
+        return ctx.renderer.root;
+      },
+      get currentFocusedEditor() {
+        return ctx.renderer.currentFocusedEditor;
+      },
+      get nativeSession() {
+        return ctx.renderer?.nativeSession;
+      },
+      on(event, handler) {
+        ctx.renderer.on(event, handler);
+      },
+      off(event, handler) {
+        ctx.renderer.off(event, handler);
+      }
+    },
+    keymap: {
+      registerLayer(layer) {
+        return runWithOwner(hostOwner, () => createRoot(dispose => {
+          ctx.keymap.layer(() => ({
+            mode: layer.mode ?? "base",
+            priority: layer.priority ?? 20,
+            commands: (layer.bindings ?? []).map(b => ({
+              title: b.desc,
+              bind: b.key,
+              run: () => {
+                b.cmd();
+              }
+            }))
+          }));
+          return dispose;
+        }));
+      }
+    },
+    slots: {
+      register(cfg) {
+        if (cfg.slots.sidebar_content) {
+          ctx.ui.slot({
+            prepend: "sidebar.content",
+            render: cfg.slots.sidebar_content
+          });
+        }
+        if (cfg.slots.home_bottom) {
+          ctx.ui.slot({
+            prepend: "home.footer",
+            render: cfg.slots.home_bottom
+          });
+        }
+      }
+    },
+    command: {
+      register(factory) {
+        ctx.keymap.layer(() => ({
+          mode: "global",
+          priority: 20,
+          commands: factory().map(cmd => ({
+            id: cmd.value,
+            title: cmd.title,
+            description: cmd.description,
+            group: cmd.category,
+            palette: true,
+            slash: cmd.slash ? {
+              name: cmd.slash.name
+            } : undefined,
+            run: () => {
+              cmd.onSelect();
+            }
+          }))
+        }));
+      }
+    },
+    client: {
+      project: {
+        async list() {
+          const res = await ctx.client.project.list();
+          return {
+            data: Array.isArray(res) ? res : res?.data ?? []
+          };
+        }
+      },
+      session: {
+        async delete(req) {
+          await ctx.client.session.remove({
+            sessionID: req.sessionID
+          });
+          return {
+            data: undefined
+          };
+        },
+        async fork(req) {
+          const res = await ctx.client.session.fork({
+            sessionID: req.sessionID
+          });
+          return {
+            data: res
+          };
+        },
+        async messages(req) {
+          let cursor;
+          const all = [];
+          do {
+            const res = await ctx.client.message.list({
+              sessionID: req.sessionID,
+              order: req.preview ? "desc" : "asc",
+              limit: 100,
+              cursor
+            });
+            all.push(...res.data);
+            const next = res.cursor.next;
+            if (req.preview || !next || next === cursor) break;
+            cursor = next;
+          } while (true);
+          if (req.preview) all.reverse();
+          const messages = all.map(m => {
+            let text = "";
+            if (m.type === "user") text = m.text ?? "";else if (m.type === "assistant") {
+              text = (m.content ?? []).filter(c => c.type === "text").map(c => c.text).join("\n");
+            }
+            return {
+              id: m.id,
+              info: {
+                role: m.type
+              },
+              parts: [{
+                type: "text",
+                text
+              }]
+            };
+          });
+          return {
+            data: messages
+          };
+        }
+      },
+      experimental: {
+        session: {
+          async list(input) {
+            const res = await ctx.client.session.list({
+              parentID: null,
+              order: "desc",
+              limit: input.limit,
+              cursor: input.cursor
+            });
+            return {
+              cursor: res.cursor,
+              data: res.data.map(s => ({
+                ...s,
+                directory: s.location?.directory ?? ""
+              }))
+            };
+          }
+        }
+      }
+    }
+  };
+}
+export default Plugin.define({
+  id: "sesh-panel",
+  async setup(ctx) {
+    const api = createApi(ctx);
+    let initialized = false;
+    const disposeSlot = ctx.ui.slot({
+      append: "app",
+      render: () => {
+        if (!initialized) {
+          initialized = true;
+          hostOwner = getOwner();
+          void tui(api);
+        }
+        return _$createElement("box");
+      }
+    });
+    return () => {
+      if (api.ui.dialog.open) api.ui.dialog.clear();
+      disposeSlot();
+      removeRootMouse?.();
+    };
+  }
+});