@multiclawcli/dashboard 0.9.0 → 0.10.0

package/dist/tui/App.d.ts

@@ -1,5 +1,19 @@
 import type { EventBus, MultiClawConfig } from "@multiclawcli/core";
 import { AgentSessionManager } from "@multiclawcli/core";
+/**
+ * How the console should choose its session on launch.
+ *
+ * Absent means the default: continue the most recent session, or start one when
+ * the workspace has none. `new` always starts fresh. `resume` opens the named
+ * session, or — with no id — the most recent one with the picker already open,
+ * so `multiclaw -r` lands on the list the way `claude -r` does.
+ */
+export type InitialSession = {
+    kind: "new";
+} | {
+    kind: "resume";
+    id?: string;
+};
 export interface AppProps {
     config: MultiClawConfig;
     /**
@@ -11,5 +25,7 @@ export interface AppProps {
     sessions?: AgentSessionManager;
     /** Gives the terminal host an awaitable cleanup barrier, including render failures. */
     onCleanupReady?: (cleanup: () => Promise<void>) => void;
+    /** How to choose the session on launch; defaults to continuing the latest. */
+    initialSession?: InitialSession;
 }
-export declare function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }: AppProps): import("react").JSX.Element;
+export declare function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady, initialSession, }: AppProps): import("react").JSX.Element;

package/dist/tui/atomic.d.ts

@@ -19,3 +19,13 @@ export declare function writeJsonFile(target: string, json: string): Promise<voi
  * the temporary file behind and the previous — older — file in place.
  */
 export declare function pendingWrite(target: string): Promise<void>;
+/**
+ * Append newline-terminated lines to `target`, serialized per path on the same
+ * chain as {@link writeJsonFile}.
+ *
+ * Unlike the rewrite path this does not go through a temp file: an append is the
+ * cheap O(1) write a JSONL log wants, and a crash mid-append can only tear the
+ * *last* line, which every line-oriented reader here already skips. Sharing the
+ * `writes` chain keeps a `pendingWrite` on the same path able to await it.
+ */
+export declare function appendLines(target: string, lines: readonly string[]): Promise<void>;

package/dist/tui/components/overlays.d.ts

@@ -1,3 +1,4 @@
+import type { SessionMeta } from "../sessions";
 import { type TurnView } from "../state";
 interface HelpGroup {
     title: string;
@@ -61,4 +62,22 @@ export declare function HistoryOverlay({ turns, selected, width, maxRows, }: {
     /** Rows available in the body. The list is windowed against this. */
     maxRows: number;
 }): import("react").JSX.Element;
+/**
+ * The session picker: every session in the workspace, newest activity first.
+ *
+ * The level above {@link HistoryOverlay}. Where the history list browses the
+ * turns *within* a session, this switches between whole sessions — the thing a
+ * restart, a `/new`, or opening the console again all create. The one the
+ * console is attached to is marked, because "which am I on" is the first
+ * question the list has to answer.
+ */
+export declare function SessionsOverlay({ sessions, selected, currentId, width, maxRows, now, }: {
+    sessions: SessionMeta[];
+    selected: number;
+    currentId: string | undefined;
+    width: number;
+    /** Rows available in the body. The list is windowed against this. */
+    maxRows: number;
+    now: number;
+}): import("react").JSX.Element;
 export {};

package/dist/tui/format.d.ts

@@ -43,6 +43,14 @@ export declare function wrapLine(line: string, width: number): string[];
  * scan a stack of durations only if they share a shape.
  */
 export declare function formatDuration(ms: number): string;
+/**
+ * A coarse "how long ago", for the session list.
+ *
+ * Deliberately low-resolution — the picker wants "which one did I touch last",
+ * not a precise clock. Future timestamps (a clock that moved backwards) read as
+ * "just now" rather than a negative age.
+ */
+export declare function formatAgo(timestamp: number, now: number): string;
 /** Stage markers read as an ordered sequence at a glance; past twenty, fall back. */
 export declare function circled(n: number): string;
 /** Pad to a fixed column so sibling rows line up. */

package/dist/tui/history.d.ts

@@ -1,14 +1,12 @@
 import { type TurnView } from "./state";
-/** Directory, under a workspace's `.multiclaw/`, that holds console state. */
-export declare const CONSOLE_DIR = "console";
-/** The finished-turn record the console keeps across sessions. */
-export declare const HISTORY_FILE = "history.json";
+/** The finished-turn log a session keeps, one JSON turn per line. */
+export declare const TURNS_FILE = "turns.jsonl";
 /** Where exported turn markdown files are written by default. */
 export declare const EXPORT_DIR = "exports";
-/** Where the console keeps its turn history for a workspace. */
-export declare function historyPath(workDir: string): string;
+/** Where a session keeps its finished turns. */
+export declare function turnsPath(workDir: string, sessionId: string): string;
 /**
- * Read the workspace's turn history.
+ * Read a session's turn history.
  *
  * Synchronous on purpose: it runs once, inside the reducer's lazy initialiser,
  * before the first frame. An async load would race the user's first keystroke
@@ -16,18 +14,21 @@ export declare function historyPath(workDir: string): string;
  *
  * Never throws. A missing directory, malformed JSON, or a value of the wrong
  * shape all mean "no history": the console can always start from empty, and
- * crashing on startup because a side file got corrupted would be far worse.
+ * crashing on startup because a side file got corrupted would be far worse. The
+ * log is line-oriented, so a single torn line (a crash mid-append) is skipped
+ * rather than costing the whole session's history.
  */
-export declare function loadHistory(workDir: string): TurnView[];
+export declare function loadTurns(workDir: string, sessionId: string): TurnView[];
 /**
- * Write the workspace's turn history.
+ * Append finished turns to a session's log, one JSON object per line.
  *
- * Atomic and serialized per path (see {@link writeJsonFile}), because a crash
- * mid-write must leave the previous history readable rather than half a
- * document: `loadHistory` can only drop a file it cannot parse, so a torn write
- * would cost the user *all* of their history rather than the last one.
+ * Append-only and serialized per path (see {@link appendLines}): each settled
+ * turn is an O(1) write rather than a rewrite of the whole history, and a crash
+ * mid-append can only tear the last line, which {@link loadTurns} skips. Callers
+ * pass only the turns not yet persisted, tracked by the highest turn number
+ * already written.
  */
-export declare function saveHistory(workDir: string, turns: readonly TurnView[]): Promise<void>;
-export declare function exportPath(workDir: string, turn: number): string;
+export declare function appendTurns(workDir: string, sessionId: string, turns: readonly TurnView[]): Promise<void>;
+export declare function exportPath(workDir: string, sessionId: string, turn: number): string;
 export declare function exportTurn(turn: TurnView, filePath: string): Promise<void>;
 export declare function formatTurnMarkdown(turn: TurnView): string;

package/dist/tui/index.d.ts

@@ -1,11 +1,14 @@
 import { type EventBus, type MultiClawConfig } from "@multiclawcli/core";
-export type { AppProps } from "./App";
+import { type InitialSession } from "./App";
+export type { AppProps, InitialSession } from "./App";
 export * from "./layout";
 export * from "./state";
 export interface TuiOptions {
     config: MultiClawConfig;
     /** Attach per-turn reporters (e.g. a file log writer) here. */
     onTurnStart?: (eventBus: EventBus, logDir: string) => void | (() => void | Promise<void>);
+    /** How to choose the session on launch; defaults to continuing the latest. */
+    initialSession?: InitialSession;
 }
 /**
  * Render the interactive team console.

package/dist/tui/session.d.ts

@@ -5,10 +5,10 @@ import { type AgentView, type TuiStageInfo, type TuiState, type TurnView } from
  * Live agent sessions are child processes, and a pending approval is an RPC in
  * flight to one of them — neither survives the process that owns them. So this
  * file deliberately does not try to *continue* a turn. It records the boundary
- * instead: which turn was running, what the user had typed but not run, where
- * the current task began, and how many decisions were waiting. A restart can
- * then say what happened, show the interrupted turn as a turn, and hand the
- * queued input back — without pretending a dead agent is still working.
+ * instead: which turn was running, what the user had typed but not run, and how
+ * many decisions were waiting. A restart can then say what happened, show the
+ * interrupted turn as a turn, and hand the queued input back — without
+ * pretending a dead agent is still working.
  */
 export declare const SESSION_FILE = "session.json";
 /** Bumped when the on-disk shape changes in a way an older console cannot read. */
@@ -48,29 +48,21 @@ export interface JournalTurn {
 }
 export interface SessionJournal {
     version: number;
-    /**
-     * Turn number the current task began at.
-     *
-     * `/task` closes the previous task's context, and that boundary has to outlive
-     * the process: without it a restart would hand the leader every turn ever run
-     * in the workspace, including the ones the user explicitly closed.
-     */
-    taskStart?: number;
     /** Follow-ups typed but never run, in the order they were typed. */
     queue?: string[];
     inFlight?: JournalTurn;
 }
-/** Where the console keeps its session journal for a workspace. */
-export declare function sessionPath(workDir: string): string;
+/** Where a session keeps its journal. */
+export declare function sessionPath(workDir: string, sessionId: string): string;
 /**
- * Read the workspace's session journal.
+ * Read a session's journal.
  *
- * Never throws, for the same reason `loadHistory` does not: a corrupted side
- * file means "no journal", and a console that refuses to start over it would be
- * far worse than one that starts with an empty past. A journal written by a
- * newer console (unknown `version`) is ignored rather than guessed at.
+ * Never throws, for the same reason `loadTurns` does not: a corrupted side file
+ * means "no journal", and a console that refuses to start over it would be far
+ * worse than one that starts with an empty past. A journal written by a newer
+ * console (unknown `version`) is ignored rather than guessed at.
  */
-export declare function loadJournal(workDir: string): SessionJournal | undefined;
+export declare function loadJournal(workDir: string, sessionId: string): SessionJournal | undefined;
 /**
  * Write the workspace's session journal.
  *
@@ -78,12 +70,12 @@ export declare function loadJournal(workDir: string): SessionJournal | undefined
  * to survive a process that dies mid-write, so the write itself must never be
  * the thing that leaves a torn file behind.
  *
- * An empty journal does not create the file. A console that was opened and quit
- * without doing anything should not leave `.multiclaw/console/` behind — but an
- * *existing* journal is still rewritten when it empties, because "nothing is in
- * flight" is exactly what the next start needs to read.
+ * An empty journal does not create the file. A session that was opened and quit
+ * without doing anything should not leave a journal behind — but an *existing*
+ * journal is still rewritten when it empties, because "nothing is in flight" is
+ * exactly what the next start needs to read.
  */
-export declare function saveJournal(workDir: string, journal: SessionJournal): Promise<void>;
+export declare function saveJournal(workDir: string, sessionId: string, journal: SessionJournal): Promise<void>;
 /**
  * The journal entry for a turn that is running right now.
  *
@@ -115,20 +107,25 @@ export declare function interruptedTurn(entry: JournalTurn): TurnView;
 export interface RestoredConsole {
     history: TurnView[];
     queue: string[];
-    taskStart: number;
+    /**
+     * Highest turn number already on disk in `turns.jsonl` — the watermark the
+     * console appends past. Excludes a journal-recovered interrupted turn, which
+     * lives only in the journal until the next save writes it to the log.
+     */
+    persistedTurn: number;
     /** The last turn ended by asking the user something, so the console reopens ready for it. */
     awaitingAnswer: boolean;
     /** One line for the notice bar, when the previous session left work behind. */
     notice?: string;
 }
 /**
- * Everything the console should open with, read once at startup.
+ * Everything the console should open a session with, read once at startup.
  *
  * The interrupted turn is appended to the restored history rather than replacing
- * it: the turns before it still happened. It is skipped when history already
- * holds that turn number, because a restored turn is written back to
- * `history.json` on the very next save — a second restart must not add it twice.
- * A journal *behind* the last recorded turn is stale (the history was written by
- * a later session) and is dropped for the same reason.
+ * it: the turns before it still happened. It is skipped when the log already
+ * holds that turn number, because a restored turn is written to the log on the
+ * very next save — a second restart must not add it twice. A journal *behind*
+ * the last recorded turn is stale (the log was written by a later session) and
+ * is dropped for the same reason.
  */
-export declare function restoreConsole(workDir: string): RestoredConsole;
+export declare function restoreConsole(workDir: string, sessionId: string): RestoredConsole;

package/dist/tui/sessions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Sessions: the unit of history and resumption.
+ *
+ * A session is one continuous line of work — a sequence of turns, each fanning
+ * out to the same team of agents. It is what Claude Code / Codex call a session:
+ * an independent, listable, resumable, deletable record. Everything a session
+ * owns lives under its own directory (`turns.jsonl`, `session.json`, exports),
+ * and a small `index.json` holds just the summaries the picker needs so it never
+ * has to open a session to list one.
+ */
+export declare const SESSIONS_DIR = "sessions";
+/** The summary index, read by the picker; one entry per session. */
+export declare const INDEX_FILE = "index.json";
+/** How long a session title may grow before it is truncated for the index. */
+export declare const MAX_TITLE_CHARS = 80;
+export interface SessionMeta {
+    id: string;
+    /** First turn's requirement, truncated. Empty until the session runs a turn. */
+    title: string;
+    createdAt: number;
+    lastActiveAt: number;
+    /** Highest turn number the session has recorded. */
+    turnCount: number;
+}
+export declare function sessionsRoot(workDir: string): string;
+export declare function sessionDir(workDir: string, id: string): string;
+/**
+ * Read the session index, newest-first by last activity.
+ *
+ * Never throws, like `loadTurns`: a missing or corrupt index means "no sessions
+ * the picker can show", which is always a safe place to start from. A single bad
+ * entry is dropped rather than losing the whole list.
+ */
+export declare function listSessions(workDir: string): SessionMeta[];
+/** The most recently active session, or undefined when there is none. */
+export declare function latestSession(workDir: string): SessionMeta | undefined;
+/**
+ * Register a new, empty session and return its metadata.
+ *
+ * The directory is not created here — `appendTurns` and `saveJournal` both
+ * `mkdir` lazily, so a session that is created and never run leaves nothing but
+ * an index entry behind.
+ */
+export declare function createSession(workDir: string): SessionMeta;
+/** Remove a session's directory and its index entry. Idempotent. */
+export declare function deleteSession(workDir: string, id: string): void;
+/** Update a session's summary in the index. `lastActiveAt` defaults to now. */
+export declare function touchSession(workDir: string, id: string, patch: Partial<Pick<SessionMeta, "title" | "turnCount" | "lastActiveAt">>): void;

package/dist/tui/state.d.ts

@@ -210,6 +210,27 @@ export type TuiAction = {
 /** Flip whether tool detail is shown in the stream. */
  | {
     type: "verbose:toggle";
+}
+/**
+ * Start a fresh session in place: empty history, turn counter back to zero,
+ * roster reseeded. Carries the seeded agents and leader ids the same way
+ * `turn:start` does, so no module-level object is shared into live state.
+ */
+ | {
+    type: "session:reset";
+    agents: Record<string, AgentView>;
+    leaderIds: string[];
+}
+/**
+ * Switch to an existing session: like `session:reset`, but seeded with that
+ * session's finished turns so its history is on screen and the turn counter
+ * continues from where it left off.
+ */
+ | {
+    type: "session:load";
+    agents: Record<string, AgentView>;
+    leaderIds: string[];
+    history: TurnView[];
 };
 export declare function stripAnsi(text: string): string;
 /** Append a chunk, keeping only the last {@link MAX_LOG_CHARS} characters. */

package/dist/tui.js

@@ -4,7 +4,7 @@ import { render } from "ink";
 import { createElement } from "react";
 
 // src/tui/App.tsx
-import * as path4 from "path";
+import * as path5 from "path";
 import {
   AgentSessionManager,
   describeResumePlan,
@@ -38,6 +38,22 @@ function pendingWrite(target) {
   return (writes.get(target) ?? Promise.resolve()).catch(() => {
   });
 }
+function appendLines(target, lines) {
+  if (lines.length === 0) return pendingWrite(target);
+  const payload = `${lines.join("\n")}
+`;
+  const write = (writes.get(target) ?? Promise.resolve()).catch(() => {
+  }).then(async () => {
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
+    await fs.promises.appendFile(target, payload, "utf-8");
+  });
+  writes.set(target, write);
+  void write.finally(() => {
+    if (writes.get(target) === write) writes.delete(target);
+  }).catch(() => {
+  });
+  return write;
+}
 
 // src/tui/commands.ts
 var COMMANDS = [
@@ -55,6 +71,11 @@ var COMMANDS = [
     description: "Browse finished turns, or continue one",
     availability: "always"
   },
+  {
+    name: "sessions",
+    description: "Switch between, or delete, saved sessions",
+    availability: "always"
+  },
   {
     name: "verbose",
     description: "Toggle tool detail in the stream",
@@ -101,9 +122,9 @@ var COMMANDS = [
     availability: "running"
   },
   {
-    name: "task",
+    name: "new",
     args: "<requirement>",
-    description: "Start a new task with fresh agent sessions",
+    description: "Start a new session with fresh agent sessions",
     availability: "idle"
   },
   {
@@ -326,6 +347,15 @@ function formatDuration(ms) {
   const hours = Math.floor(minutes / 60);
   return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
 }
+function formatAgo(timestamp, now) {
+  const seconds = Math.max(0, Math.floor((now - timestamp) / 1e3));
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
 var CIRCLED = "\u2460\u2461\u2462\u2463\u2464\u2465\u2466\u2467\u2468\u2469\u246A\u246B\u246C\u246D\u246E\u246F\u2470\u2471\u2472\u2473";
 function circled(n) {
   return CIRCLED[n - 1] ?? `(${n})`;
@@ -1045,8 +1075,42 @@ ${action.text}
       return state.view ? { ...state, view: void 0 } : state;
     case "verbose:toggle":
       return { ...state, verbose: !state.verbose };
+    case "session:reset":
+      return seededState(state, action.agents, action.leaderIds, []);
+    case "session:load":
+      return seededState(state, action.agents, action.leaderIds, action.history);
   }
 }
+function seededState(state, agents, leaderIds, history) {
+  const ids = Object.keys(agents);
+  return {
+    phase: "idle",
+    name: state.name,
+    turn: history[history.length - 1]?.turn ?? 0,
+    requirement: void 0,
+    effectiveRequirement: void 0,
+    startedAt: void 0,
+    endedAt: void 0,
+    cancelled: void 0,
+    interrupted: void 0,
+    success: void 0,
+    acceptance: void 0,
+    totalDuration: void 0,
+    totalCostUsd: void 0,
+    reason: void 0,
+    warning: void 0,
+    reply: void 0,
+    stages: [],
+    leaderIds,
+    agents,
+    focusId: ids[0],
+    autoFollow: true,
+    scroll: 0,
+    history,
+    view: void 0,
+    verbose: state.verbose
+  };
+}
 function stageStatus(stage, agents) {
   if (stage.outcome !== void 0) return stage.outcome;
   const statuses = stage.agents.map((a) => agents[a.id]?.status ?? "pending");
@@ -1497,6 +1561,54 @@ function HistoryOverlay({
     /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `\u2191\u2193 select \xB7 enter open \xB7 c continue \xB7 esc close${range}` }) })
   ] });
 }
+function SessionsOverlay({
+  sessions,
+  selected,
+  currentId,
+  width,
+  maxRows,
+  now
+}) {
+  const capacity = historyCapacity(maxRows);
+  const start = listWindowStart(selected, sessions.length, capacity);
+  const visible = sessions.slice(start, start + capacity);
+  const range = sessions.length > capacity ? ` \xB7 showing ${start + 1}\u2013${start + visible.length} of ${sessions.length}` : "";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexShrink: 0, paddingLeft: 2, paddingTop: 1, width, children: [
+    /* @__PURE__ */ jsxs2(Box2, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "SESSIONS" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        sessions.length,
+        " total",
+        range
+      ] })
+    ] }),
+    sessions.length === 0 ? /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No sessions yet." }) }) : /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, children: visible.map((session, offset) => {
+      const index = start + offset;
+      const focused = index === selected;
+      const current = session.id === currentId;
+      const count = session.turnCount;
+      return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [
+        /* @__PURE__ */ jsxs2(Box2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: focused ? COLOR.accent : void 0, children: focused ? `${GLYPH.caret} ` : "  " }),
+          /* @__PURE__ */ jsxs2(Text2, { bold: focused, color: focused ? COLOR.accent : void 0, children: [
+            current ? "\u25CF " : "",
+            truncate(session.title || "(untitled session)", Math.max(8, width - 30))
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          "    ",
+          count,
+          " turn",
+          count === 1 ? "" : "s",
+          " \xB7 ",
+          formatAgo(session.lastActiveAt, now),
+          current ? " \xB7 current" : ""
+        ] })
+      ] }, session.id);
+    }) }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2191\u2193 select \xB7 enter open \xB7 d delete \xB7 esc close" }) })
+  ] });
+}
 
 // src/tui/components/interaction.tsx
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
@@ -1916,13 +2028,93 @@ function CommandMenu({ rows, selected }) {
 }
 
 // src/tui/history.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/tui/sessions.ts
+import { randomUUID } from "crypto";
 import * as fs2 from "fs";
 import * as path2 from "path";
-var CONSOLE_DIR = "console";
-var HISTORY_FILE = "history.json";
+var SESSIONS_DIR = "sessions";
+var INDEX_FILE = "index.json";
+var MAX_TITLE_CHARS = 80;
+function sessionsRoot(workDir) {
+  return path2.join(workDir, ".multiclaw", SESSIONS_DIR);
+}
+function sessionDir(workDir, id) {
+  return path2.join(sessionsRoot(workDir), id);
+}
+function indexPath(workDir) {
+  return path2.join(sessionsRoot(workDir), INDEX_FILE);
+}
+function isSessionMeta(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const meta = value;
+  return typeof meta.id === "string" && typeof meta.title === "string" && typeof meta.createdAt === "number" && typeof meta.lastActiveAt === "number" && typeof meta.turnCount === "number";
+}
+function listSessions(workDir) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(indexPath(workDir), "utf-8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isSessionMeta).sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+  } catch {
+    return [];
+  }
+}
+function latestSession(workDir) {
+  return listSessions(workDir)[0];
+}
+function mutateIndex(workDir, fn) {
+  const next = fn(readIndex(workDir));
+  const target = indexPath(workDir);
+  fs2.mkdirSync(path2.dirname(target), { recursive: true });
+  const tmp = `${target}.tmp`;
+  fs2.writeFileSync(tmp, JSON.stringify(next), "utf-8");
+  fs2.renameSync(tmp, target);
+}
+function readIndex(workDir) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(indexPath(workDir), "utf-8"));
+    return Array.isArray(parsed) ? parsed.filter(isSessionMeta) : [];
+  } catch {
+    return [];
+  }
+}
+function createSession(workDir) {
+  const now = Date.now();
+  const meta = {
+    id: randomUUID(),
+    title: "",
+    createdAt: now,
+    lastActiveAt: now,
+    turnCount: 0
+  };
+  mutateIndex(workDir, (metas) => [meta, ...metas]);
+  return meta;
+}
+function deleteSession(workDir, id) {
+  fs2.rmSync(sessionDir(workDir, id), { recursive: true, force: true });
+  mutateIndex(workDir, (metas) => metas.filter((meta) => meta.id !== id));
+}
+function touchSession(workDir, id, patch) {
+  mutateIndex(
+    workDir,
+    (metas) => metas.map(
+      (meta) => meta.id === id ? {
+        ...meta,
+        ...patch.title !== void 0 ? { title: patch.title.slice(0, MAX_TITLE_CHARS) } : {},
+        ...patch.turnCount !== void 0 ? { turnCount: patch.turnCount } : {},
+        lastActiveAt: patch.lastActiveAt ?? Date.now()
+      } : meta
+    )
+  );
+}
+
+// src/tui/history.ts
+var TURNS_FILE = "turns.jsonl";
 var EXPORT_DIR = "exports";
-function historyPath(workDir) {
-  return path2.join(workDir, ".multiclaw", CONSOLE_DIR, HISTORY_FILE);
+function turnsPath(workDir, sessionId) {
+  return path3.join(sessionDir(workDir, sessionId), TURNS_FILE);
 }
 function isObject(value) {
   return typeof value === "object" && value !== null;
@@ -1952,25 +2144,36 @@ function isTurnView(value) {
     ))
   ) && Array.isArray(turn.leaderIds);
 }
-function loadHistory(workDir) {
+function loadTurns(workDir, sessionId) {
   try {
-    const raw = fs2.readFileSync(historyPath(workDir), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(isTurnView).slice(-MAX_HISTORY);
+    const raw = fs3.readFileSync(turnsPath(workDir, sessionId), "utf-8");
+    const turns = [];
+    for (const line of raw.split("\n")) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (isTurnView(parsed)) turns.push(parsed);
+      } catch {
+      }
+    }
+    return turns.slice(-MAX_HISTORY);
   } catch {
     return [];
   }
 }
-function saveHistory(workDir, turns) {
-  return writeJsonFile(historyPath(workDir), JSON.stringify(turns));
+function appendTurns(workDir, sessionId, turns) {
+  if (turns.length === 0) return Promise.resolve();
+  return appendLines(
+    turnsPath(workDir, sessionId),
+    turns.map((turn) => JSON.stringify(turn))
+  );
 }
-function exportPath(workDir, turn) {
-  return path2.join(workDir, ".multiclaw", CONSOLE_DIR, EXPORT_DIR, `turn-${turn}.md`);
+function exportPath(workDir, sessionId, turn) {
+  return path3.join(sessionDir(workDir, sessionId), EXPORT_DIR, `turn-${turn}.md`);
 }
 async function exportTurn(turn, filePath) {
-  await fs2.promises.mkdir(path2.dirname(filePath), { recursive: true });
-  await fs2.promises.writeFile(filePath, formatTurnMarkdown(turn), "utf-8");
+  await fs3.promises.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs3.promises.writeFile(filePath, formatTurnMarkdown(turn), "utf-8");
 }
 function formatTurnMarkdown(turn) {
   const lines = [`# Turn ${turn.turn}`, ""];
@@ -2012,13 +2215,13 @@ function formatTurnMarkdown(turn) {
 }
 
 // src/tui/session.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var SESSION_FILE = "session.json";
 var SESSION_VERSION = 1;
 var MAX_JOURNAL_LOG_CHARS = 1200;
-function sessionPath(workDir) {
-  return path3.join(workDir, ".multiclaw", CONSOLE_DIR, SESSION_FILE);
+function sessionPath(workDir, sessionId) {
+  return path4.join(sessionDir(workDir, sessionId), SESSION_FILE);
 }
 function isObject2(value) {
   return typeof value === "object" && value !== null;
@@ -2040,14 +2243,13 @@ function isJournalTurn(value) {
   if (!isObject2(value)) return false;
   return Number.isInteger(value.turn) && typeof value.requirement === "string" && typeof value.savedAt === "number" && Number.isFinite(value.savedAt) && (value.startedAt === void 0 || typeof value.startedAt === "number") && (value.effectiveRequirement === void 0 || typeof value.effectiveRequirement === "string") && (value.reason === void 0 || typeof value.reason === "string") && (value.warning === void 0 || typeof value.warning === "string") && (value.focusId === void 0 || typeof value.focusId === "string") && isObject2(value.agents) && Object.values(value.agents).every(isAgentView) && Array.isArray(value.leaderIds) && value.leaderIds.every((id) => typeof id === "string") && Array.isArray(value.stages) && value.stages.every(isObject2) && (value.pending === void 0 || isObject2(value.pending) && Number.isInteger(value.pending.permissions) && Number.isInteger(value.pending.questions));
 }
-function loadJournal(workDir) {
+function loadJournal(workDir, sessionId) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(sessionPath(workDir), "utf-8"));
+    const parsed = JSON.parse(fs4.readFileSync(sessionPath(workDir, sessionId), "utf-8"));
     if (!isObject2(parsed) || parsed.version !== SESSION_VERSION) return void 0;
     const queue = Array.isArray(parsed.queue) ? parsed.queue.filter((item) => typeof item === "string" && item !== "") : [];
     return {
       version: SESSION_VERSION,
-      ...Number.isInteger(parsed.taskStart) && parsed.taskStart >= 0 ? { taskStart: parsed.taskStart } : {},
       ...queue.length > 0 ? { queue } : {},
       ...isJournalTurn(parsed.inFlight) ? { inFlight: parsed.inFlight } : {}
     };
@@ -2056,11 +2258,11 @@ function loadJournal(workDir) {
   }
 }
 function isEmpty(journal) {
-  return journal.inFlight === void 0 && journal.queue === void 0 && !journal.taskStart;
+  return journal.inFlight === void 0 && journal.queue === void 0;
 }
-function saveJournal(workDir, journal) {
-  const target = sessionPath(workDir);
-  if (isEmpty(journal) && !fs3.existsSync(target)) return Promise.resolve();
+function saveJournal(workDir, sessionId, journal) {
+  const target = sessionPath(workDir, sessionId);
+  if (isEmpty(journal) && !fs4.existsSync(target)) return Promise.resolve();
   return writeJsonFile(target, JSON.stringify(journal));
 }
 function tail(text, max) {
@@ -2114,11 +2316,12 @@ function interruptedTurn(entry) {
 function plural(count, word) {
   return count === 1 ? word : `${word}s`;
 }
-function restoreConsole(workDir) {
-  const history = loadHistory(workDir);
-  const journal = loadJournal(workDir);
+function restoreConsole(workDir, sessionId) {
+  const history = loadTurns(workDir, sessionId);
+  const journal = loadJournal(workDir, sessionId);
   const inFlight = journal?.inFlight;
   const last = history[history.length - 1];
+  const persistedTurn = last?.turn ?? 0;
   const parts = [];
   if (inFlight && (!last || inFlight.turn > last.turn)) {
     history.push(interruptedTurn(inFlight));
@@ -2138,7 +2341,7 @@ function restoreConsole(workDir) {
   return {
     history: restored,
     queue,
-    taskStart: journal?.taskStart ?? 0,
+    persistedTurn,
     // Read from the *final* last turn: a recovered interrupted turn has no
     // reply, so it correctly clears the "waiting for an answer" state.
     awaitingAnswer: restored[restored.length - 1]?.reply?.mode === "ask",
@@ -2235,12 +2438,41 @@ function StatusLine({
     stages > 0 ? ` \xB7 ${stages} stages` : ""
   ] });
 }
-function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }) {
+function App({
+  config,
+  onTurnStart,
+  sessions: providedSessions,
+  onCleanupReady,
+  initialSession
+}) {
   const { exit } = useApp();
   const { columns, rows } = useWindowSize();
+  const sessionIdRef = useRef(null);
+  const launchNoticeRef = useRef(void 0);
+  const openPickerOnMountRef = useRef(false);
+  if (!sessionIdRef.current) {
+    const latest = () => latestSession(config.workDir)?.id ?? createSession(config.workDir).id;
+    if (initialSession?.kind === "new") {
+      sessionIdRef.current = createSession(config.workDir).id;
+    } else if (initialSession?.kind === "resume" && initialSession.id) {
+      const target = initialSession.id;
+      if (listSessions(config.workDir).some((s) => s.id === target)) {
+        sessionIdRef.current = target;
+      } else {
+        sessionIdRef.current = latest();
+        launchNoticeRef.current = `session "${target}" not found \u2014 opened the most recent instead`;
+      }
+    } else {
+      sessionIdRef.current = latest();
+      if (initialSession?.kind === "resume") openPickerOnMountRef.current = true;
+    }
+  }
   const restoredRef = useRef(null);
-  if (!restoredRef.current) restoredRef.current = restoreConsole(config.workDir);
+  if (!restoredRef.current) {
+    restoredRef.current = restoreConsole(config.workDir, sessionIdRef.current);
+  }
   const restored = restoredRef.current;
+  const persistedTurnRef = useRef(restored.persistedTurn);
   const [state, dispatch] = useReducer(
     tuiReducer,
     config,
@@ -2257,10 +2489,15 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   queueRef.current = queue;
   const [cancelled, setCancelled] = useState(false);
   const [error, setError] = useState();
-  const [notice, setNotice] = useState(restored.notice);
+  const [notice, setNotice] = useState(
+    launchNoticeRef.current ?? restored.notice
+  );
   const [helpOpen, setHelpOpen] = useState(false);
   const [historyOpen, setHistoryOpen] = useState(false);
   const [historyCursor, setHistoryCursor] = useState(0);
+  const [sessionsOpen, setSessionsOpen] = useState(false);
+  const [sessionCursor, setSessionCursor] = useState(0);
+  const [sessionList, setSessionList] = useState([]);
   const [menuCursor, setMenuCursor] = useState({
     query: void 0,
     index: 0
@@ -2274,7 +2511,6 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   const closingRef = useRef(false);
   const shutdownRef = useRef(null);
   const busyRef = useRef(false);
-  const taskStartRef = useRef(restored.taskStart);
   const turnSerialRef = useRef(0);
   const [awaitingAnswer, setAwaitingAnswer] = useState(restored.awaitingAnswer);
   const [queuePaused, setQueuePaused] = useState(restored.queue.length > 0);
@@ -2375,16 +2611,21 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
     const timer = setInterval(() => setCaretOn((on) => !on), BLINK_INTERVAL_MS);
     return () => clearInterval(timer);
   }, [running, line.text]);
-  const lastSaved = useRef(void 0);
   useEffect(() => {
-    const turns = recordedTurns(stateRef.current).slice(-MAX_HISTORY);
-    if (turns.length === 0) return;
-    const json = JSON.stringify(turns);
-    if (json === lastSaved.current) return;
-    lastSaved.current = json;
-    void saveHistory(config.workDir, turns).catch(
+    const sessionId = sessionIdRef.current;
+    if (!sessionId) return;
+    const turns = recordedTurns(stateRef.current);
+    const fresh = turns.filter((turn) => turn.turn > persistedTurnRef.current);
+    if (fresh.length === 0) return;
+    persistedTurnRef.current = fresh[fresh.length - 1].turn;
+    void appendTurns(config.workDir, sessionId, fresh).catch(
       (err) => setNotice(`history not saved: ${err.message}`)
     );
+    const title = turns.find((turn) => turn.requirement)?.requirement;
+    touchSession(config.workDir, sessionId, {
+      turnCount: fresh[fresh.length - 1].turn,
+      ...title ? { title } : {}
+    });
   }, [state.history, state.phase]);
   const persistSession = useCallback(() => {
     if (closingRef.current) return;
@@ -2394,15 +2635,16 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       if (entry.kind === "permission") waiting.permissions += 1;
       else waiting.questions += 1;
     }
+    const sessionId = sessionIdRef.current;
+    if (!sessionId) return;
     const journal = {
       version: SESSION_VERSION,
-      taskStart: taskStartRef.current,
       ...queueRef.current.length > 0 ? { queue: [...queueRef.current] } : {},
       // Only a turn that is actually running is in flight. Writing one for an
       // idle console would invent work the next session would then "recover".
       ...current.phase === "running" && current.requirement !== void 0 ? { inFlight: journalTurn(current, waiting) } : {}
     };
-    void saveJournal(config.workDir, journal).catch((err) => {
+    void saveJournal(config.workDir, sessionId, journal).catch((err) => {
       if (mountedRef.current) setNotice(`session not saved: ${err.message}`);
     });
   }, [config.workDir]);
@@ -2424,10 +2666,10 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       if (closingRef.current || busyRef.current) return;
       busyRef.current = true;
       setRunning(true);
-      const continuation = opts?.newTask ? null : continuationRef.current;
+      const continuation = opts?.newSession ? null : continuationRef.current;
       continuationRef.current = null;
       const resume = opts?.resume ?? continuationResume(continuation, sessionsRef.current);
-      if (opts?.newTask) {
+      if (opts?.newSession) {
         try {
           await sessionsRef.current?.reset();
           if (closingRef.current) {
@@ -2435,7 +2677,14 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
             setRunning(false);
             return;
           }
-          taskStartRef.current = stateRef.current.turn;
+          const created = createSession(config.workDir);
+          sessionIdRef.current = created.id;
+          persistedTurnRef.current = 0;
+          dispatch({
+            type: "session:reset",
+            agents: seedAgents(config),
+            leaderIds: leaderAgentIds(config)
+          });
         } catch (err) {
           busyRef.current = false;
           setRunning(false);
@@ -2453,11 +2702,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       setError(void 0);
       setCancelled(false);
       setNotice(void 0);
-      const earlierTurns = conversationTurns({
-        ...stateRef.current,
-        history: stateRef.current.history.filter((turn) => turn.turn > taskStartRef.current),
-        ...stateRef.current.turn <= taskStartRef.current ? { phase: "idle" } : {}
-      });
+      const earlierTurns = opts?.newSession ? [] : conversationTurns(stateRef.current);
       dispatch({
         type: "turn:start",
         requirement,
@@ -2466,7 +2711,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
         startedAt: Date.now()
       });
       const stamp = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${++turnSerialRef.current}`;
-      const logDir = path4.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`, "logs");
+      const logDir = path5.join(config.workDir, ".multiclaw", "runs", `run-${stamp}`, "logs");
       const runConfig = {
         ...config,
         context: { ...config.context, requirement },
@@ -2549,16 +2794,53 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
     setQueue(rest);
     void startTurn(next);
   }, [running, queue, queuePaused, awaitingAnswer, startTurn]);
+  const switchSession = useCallback(
+    async (id) => {
+      if (id === sessionIdRef.current || busyRef.current || closingRef.current) return;
+      try {
+        await sessionsRef.current?.reset();
+      } catch (err) {
+        setError(`session switch failed: ${err.message}`);
+        return;
+      }
+      if (closingRef.current) return;
+      const restored2 = restoreConsole(config.workDir, id);
+      sessionIdRef.current = id;
+      persistedTurnRef.current = restored2.persistedTurn;
+      const resumable = [...restored2.history].reverse().find((turn) => Object.keys(turnSessions(turn)).length > 0);
+      continuationRef.current = resumable ? { turn: resumable.turn, sessions: turnSessions(resumable) } : null;
+      dispatch({
+        type: "session:load",
+        agents: seedAgents(config),
+        leaderIds: leaderAgentIds(config),
+        history: restored2.history
+      });
+      setQueue(restored2.queue);
+      queuePausedRef.current = restored2.queue.length > 0;
+      setQueuePaused(restored2.queue.length > 0);
+      awaitingAnswerRef.current = restored2.awaitingAnswer;
+      setAwaitingAnswer(restored2.awaitingAnswer);
+      setError(void 0);
+      setCancelled(false);
+      setNotice(
+        restored2.notice ?? (resumable ? `switched session \xB7 continue with your next instruction` : `switched session \xB7 ${restored2.history.length} turn${restored2.history.length === 1 ? "" : "s"}`)
+      );
+    },
+    [config]
+  );
   const cleanup = useCallback(async () => {
     closingRef.current = true;
     abortRef.current?.abort();
     clearInteractions();
     await activeTurnRef.current;
     await sessionsRef.current?.close();
-    await Promise.all([
-      pendingWrite(historyPath(config.workDir)),
-      pendingWrite(sessionPath(config.workDir))
-    ]);
+    const sessionId = sessionIdRef.current;
+    if (sessionId) {
+      await Promise.all([
+        pendingWrite(turnsPath(config.workDir, sessionId)),
+        pendingWrite(sessionPath(config.workDir, sessionId))
+      ]);
+    }
     if (reporterErrorRef.current) throw reporterErrorRef.current;
   }, [clearInteractions, config.workDir]);
   useEffect(() => {
@@ -2570,6 +2852,15 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       });
     };
   }, [cleanup, onCleanupReady]);
+  useEffect(() => {
+    if (!openPickerOnMountRef.current) return;
+    openPickerOnMountRef.current = false;
+    const list = listSessions(config.workDir);
+    setSessionList(list);
+    const current = list.findIndex((session) => session.id === sessionIdRef.current);
+    setSessionCursor(current === -1 ? 0 : current);
+    setSessionsOpen(true);
+  }, []);
   const shutdown = useCallback(() => {
     if (shutdownRef.current) return shutdownRef.current;
     closingRef.current = true;
@@ -2582,13 +2873,20 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
     shutdownRef.current = (async () => {
       try {
         await cleanup();
-        const turns = recordedTurns(stateRef.current).slice(-MAX_HISTORY);
-        if (turns.length) await saveHistory(config.workDir, turns);
-        await saveJournal(config.workDir, {
-          version: SESSION_VERSION,
-          taskStart: taskStartRef.current,
-          ...leftover.length > 0 ? { queue: leftover } : {}
-        });
+        const sessionId = sessionIdRef.current;
+        if (sessionId) {
+          const fresh = recordedTurns(stateRef.current).filter(
+            (turn) => turn.turn > persistedTurnRef.current
+          );
+          if (fresh.length) {
+            persistedTurnRef.current = fresh[fresh.length - 1].turn;
+            await appendTurns(config.workDir, sessionId, fresh);
+          }
+          await saveJournal(config.workDir, sessionId, {
+            version: SESSION_VERSION,
+            ...leftover.length > 0 ? { queue: leftover } : {}
+          });
+        }
         exit();
       } catch (err) {
         setError(`shutdown failed: ${err.message}`);
@@ -2617,8 +2915,8 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   const paletteTotal = allRows.length;
   const menuIndex = menuCursor.query === paletteKey ? menuCursor.index : 0;
   const selected = paletteTotal === 0 ? 0 : Math.min(menuIndex, paletteTotal - 1);
-  const menuOpen = !helpOpen && !historyOpen && query !== void 0 && matches.length > 0;
-  const argOpen = !helpOpen && !historyOpen && arg !== void 0 && argRows.length > 0;
+  const menuOpen = !helpOpen && !historyOpen && !sessionsOpen && query !== void 0 && matches.length > 0;
+  const argOpen = !helpOpen && !historyOpen && !sessionsOpen && arg !== void 0 && argRows.length > 0;
   const paletteOpen = menuOpen || argOpen;
   const front = interactions[0];
   const menu = front?.kind === "permission" && permissionMenu.id === front.shortId ? permissionMenu : { id: front?.shortId ?? "", cursor: void 0, released: false };
@@ -2639,7 +2937,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
     columns,
     rows,
     turn: state.turn,
-    overlay: helpOpen || historyOpen,
+    overlay: helpOpen || historyOpen || sessionsOpen,
     menuRows: paletteOpen ? paletteTotal : 0,
     queueRows: queue.length,
     interactionRows: interactionRows(interactions, Math.max(MIN_COLUMNS, columns)),
@@ -2785,16 +3083,16 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           setNotice(`selected ${clean(option.name)} for ${entry.shortId}`);
           return;
         }
-        case "task": {
+        case "new": {
           const text = args.join(" ");
           if (!text) {
-            setNotice("usage: /task <new requirement> \u2014 closes prior agent sessions");
+            setNotice("usage: /new <requirement> \u2014 starts a new session with fresh agent sessions");
             return;
           }
           setQueue([]);
           queuePausedRef.current = false;
           setQueuePaused(false);
-          void startTurn(text, { newTask: true });
+          void startTurn(text, { newSession: true });
           return;
         }
         case "answer": {
@@ -2892,6 +3190,15 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           setHistoryCursor(0);
           setHistoryOpen(true);
           return;
+        case "sessions": {
+          const list = listSessions(config.workDir);
+          setSessionList(list);
+          const current = list.findIndex((session) => session.id === sessionIdRef.current);
+          setSessionCursor(current === -1 ? 0 : current);
+          setNotice(void 0);
+          setSessionsOpen(true);
+          return;
+        }
         case "verbose":
           dispatch({ type: "verbose:toggle" });
           setNotice(state.verbose ? "verbose off" : "verbose on \u2014 showing tool detail");
@@ -2969,7 +3276,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
             setNotice(target.error);
             return;
           }
-          const file = args[1] ? path4.resolve(config.workDir, args[1]) : exportPath(config.workDir, target.record.turn);
+          const file = args[1] ? path5.resolve(config.workDir, args[1]) : exportPath(config.workDir, sessionIdRef.current ?? "", target.record.turn);
           void exportTurn(target.record, file).then(() => setNotice(`exported turn ${target.record.turn} to ${file}`)).catch((err) => setNotice(`export failed: ${err.message}`));
           return;
         }
@@ -3090,6 +3397,8 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
         setHelpOpen(false);
       } else if (historyOpen) {
         setHistoryOpen(false);
+      } else if (sessionsOpen) {
+        setSessionsOpen(false);
       } else if (abortRef.current) {
         abortRef.current.abort();
         clearInteractions();
@@ -3144,6 +3453,50 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       }
       return;
     }
+    if (sessionsOpen) {
+      if (key.escape) {
+        setSessionsOpen(false);
+        return;
+      }
+      if (sessionList.length === 0) return;
+      const index = Math.min(sessionCursor, sessionList.length - 1);
+      if (key.upArrow) {
+        setSessionCursor((index - 1 + sessionList.length) % sessionList.length);
+        return;
+      }
+      if (key.downArrow) {
+        setSessionCursor((index + 1) % sessionList.length);
+        return;
+      }
+      if (key.return) {
+        const target = sessionList[index];
+        setSessionsOpen(false);
+        if (target.id === sessionIdRef.current) {
+          setNotice("already on this session");
+          return;
+        }
+        if (running || busyRef.current) {
+          setNotice("finish or cancel the current turn before switching sessions");
+          return;
+        }
+        void switchSession(target.id);
+        return;
+      }
+      if (char === "d") {
+        const target = sessionList[index];
+        if (target.id === sessionIdRef.current) {
+          setNotice("can't delete the current session");
+          return;
+        }
+        deleteSession(config.workDir, target.id);
+        const next = listSessions(config.workDir);
+        setSessionList(next);
+        setSessionCursor(Math.min(index, Math.max(0, next.length - 1)));
+        setNotice(`deleted session \xB7 ${next.length} left`);
+        return;
+      }
+      return;
+    }
     if (key.ctrl && char === "d") {
       if (!line.text) void shutdown();
       return;
@@ -3390,7 +3743,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   const handlerRef = useRef(handleKey);
   handlerRef.current = handleKey;
   useInput((char, key) => handlerRef.current(char, key));
-  const keys = helpOpen ? "esc close" : historyOpen ? "\u2191\u2193 select \xB7 enter open \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 tab complete \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 tab complete \xB7 enter run \xB7 esc close" : running ? checkpointResolveRef.current ? `/continue \xB7 /modify <instruction> \xB7 /cancel` : interactions.length > 0 ? layout.interactionRows === 0 ? (
+  const keys = helpOpen ? "esc close" : historyOpen ? "\u2191\u2193 select \xB7 enter open \xB7 esc close" : sessionsOpen ? "\u2191\u2193 select \xB7 enter open \xB7 d delete \xB7 esc close" : argOpen ? `\u2191\u2193 select \xB7 tab complete \xB7 enter ${arg?.command.name} \xB7 esc close` : menuOpen ? "\u2191\u2193 select \xB7 tab complete \xB7 enter run \xB7 esc close" : running ? checkpointResolveRef.current ? `/continue \xB7 /modify <instruction> \xB7 /cancel` : interactions.length > 0 ? layout.interactionRows === 0 ? (
     // Too short to dock the bar, so the commands are the only way in.
     "decide with /approve 1 \xB7 /deny \xB7 /respond"
   ) : interactions[0].kind === "question" ? "tab field \xB7 \u2191\u2193 pick \xB7 enter next \xB7 /dismiss" : menu.released ? "/approve 1 and /deny still reach it" : "\u2191\u2193 or 1-9 choose \xB7 enter confirm \xB7 esc to type" : "enter queues \xB7 ctrl+c cancel" : state.view ? "esc live \xB7 tab agent \xB7 ? help" : state.reply ? "enter sends \xB7 / commands \xB7 ? help" : "tab switch \xB7 / commands \xB7 ? help";
@@ -3428,6 +3781,16 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
             width: layout.columns,
             maxRows: layout.bodyHeight
           }
+        ) : sessionsOpen ? /* @__PURE__ */ jsx6(
+          SessionsOverlay,
+          {
+            sessions: sessionList,
+            selected: Math.min(sessionCursor, Math.max(0, sessionList.length - 1)),
+            currentId: sessionIdRef.current ?? void 0,
+            width: layout.columns,
+            maxRows: layout.bodyHeight,
+            now
+          }
         ) : layout.welcome ? /* @__PURE__ */ jsx6(WelcomePanel, { turn: state, width: layout.columns }) : error ? (
           // The error wins over a reply: a run that stopped with an error is the
           // most urgent thing on screen, and a stale answer underneath it would
@@ -3537,9 +3900,16 @@ async function startTui(options) {
     cleanup = callback;
   };
   try {
-    const app = render(createElement(App, { ...options, sessions, onCleanupReady }), {
-      exitOnCtrlC: false
-    });
+    const app = render(
+      createElement(App, {
+        config: options.config,
+        onTurnStart: options.onTurnStart,
+        initialSession: options.initialSession,
+        sessions,
+        onCleanupReady
+      }),
+      { exitOnCtrlC: false }
+    );
     await app.waitUntilExit();
   } finally {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiclawcli/dashboard",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "exports": {
     "./tui": {
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@multiclawcli/core": "0.9.0",
+    "@multiclawcli/core": "0.10.0",
     "ink": "^8.0.0",
     "react": "^19.3.1",
     "string-width": "^8.3.0"