@multiclawcli/dashboard 0.8.2 → 0.10.0

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"
   },
   {
@@ -123,7 +144,17 @@ var COMMANDS = [
     description: "Pause queued turns, not the active agent",
     availability: "always"
   },
-  { name: "continue", description: "Resume queued turns after a checkpoint", availability: "idle" },
+  {
+    name: "continue",
+    description: "Resume queued turns or pass a checkpoint",
+    availability: "always"
+  },
+  {
+    name: "modify",
+    args: "<instruction>",
+    description: "Provide feedback at a checkpoint and continue",
+    availability: "running"
+  },
   {
     name: "respond",
     args: "<question id> <JSON object>",
@@ -316,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})`;
@@ -1035,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");
@@ -1487,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";
@@ -1906,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;
@@ -1942,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}`, ""];
@@ -2002,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;
@@ -2030,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 } : {}
     };
@@ -2046,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) {
@@ -2104,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));
@@ -2128,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",
@@ -2225,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,
@@ -2247,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
@@ -2264,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);
@@ -2273,6 +2519,8 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   const pending = useRef([]);
   const permissionSerialRef = useRef(0);
   const questionSerialRef = useRef(0);
+  const checkpointResolveRef = useRef(null);
+  const checkpointLabelRef = useRef("");
   const mountedRef = useRef(true);
   const interactionsRef = useRef([]);
   const [interactions, setInteractions] = useState([]);
@@ -2325,6 +2573,22 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       if (mountedRef.current) setInteractions([...interactionsRef.current]);
     });
   }, []);
+  const handleCheckpoint = useCallback((info, signal) => {
+    if (closingRef.current || signal.aborted) return Promise.resolve({ action: "cancel" });
+    return new Promise((resolve2) => {
+      checkpointResolveRef.current = resolve2;
+      checkpointLabelRef.current = info.label;
+      const names = info.completedAgents.map((a) => a.name).join(", ");
+      setNotice(
+        `checkpoint: ${info.label} \u2014 ${names} done \xB7 /continue /modify <instruction> /cancel`
+      );
+      const onAbort = () => {
+        checkpointResolveRef.current = null;
+        resolve2({ action: "cancel" });
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }, []);
   const clearInteractions = useCallback(() => {
     for (const entry of [...interactionsRef.current]) entry.settle();
   }, []);
@@ -2347,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;
@@ -2366,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]);
@@ -2396,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) {
@@ -2407,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);
@@ -2425,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,
@@ -2438,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 },
@@ -2448,6 +2721,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
         logDir,
         permissions: !config.permissions || config.permissions.mode === "ask" ? { mode: "ask", onRequest: requestPermission } : config.permissions,
         questions: config.questions?.onRequest ? config.questions : { onRequest: requestQuestion },
+        onCheckpoint: config.onCheckpoint ?? handleCheckpoint,
         // A retry names the agents to redo; a continued conversation carries only
         // sessions and still lets the leader route. Both arrive here.
         ...resume ? { resume } : {}
@@ -2503,7 +2777,15 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
         activeTurnRef.current = null;
       }
     },
-    [config, flush, onTurnStart, requestPermission, requestQuestion, clearInteractions]
+    [
+      config,
+      flush,
+      onTurnStart,
+      requestPermission,
+      requestQuestion,
+      handleCheckpoint,
+      clearInteractions
+    ]
   );
   useEffect(() => {
     if (running || busyRef.current || closingRef.current || queuePaused || awaitingAnswer || queue.length === 0)
@@ -2512,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(() => {
@@ -2533,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;
@@ -2545,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}`);
@@ -2580,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 };
@@ -2602,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)),
@@ -2637,6 +2972,12 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
   const runCommand = useCallback(
     (name, args, rawText) => {
       setLine(EMPTY_LINE);
+      if (checkpointResolveRef.current && name !== "continue" && name !== "modify" && name !== "cancel") {
+        setNotice(
+          `checkpoint: ${checkpointLabelRef.current} \xB7 /continue /modify <instruction> /cancel`
+        );
+        return;
+      }
       if (!canRun(name, running)) {
         setNotice(unavailableReason(name, running));
         return;
@@ -2742,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": {
@@ -2777,7 +3118,15 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           setQueuePaused(true);
           setNotice("queue paused \u2014 the active turn continues");
           return;
-        case "continue":
+        case "continue": {
+          if (checkpointResolveRef.current) {
+            const resolve2 = checkpointResolveRef.current;
+            checkpointResolveRef.current = null;
+            checkpointLabelRef.current = "";
+            resolve2({ action: "continue" });
+            setNotice("continuing\u2026");
+            return;
+          }
           if (awaitingAnswerRef.current) {
             setNotice("answer the leader first; queued input is not an answer");
             return;
@@ -2786,6 +3135,24 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           setQueuePaused(false);
           setNotice("queue resumed");
           return;
+        }
+        case "modify": {
+          const instruction = args.join(" ");
+          if (!instruction) {
+            setNotice("usage: /modify <instruction> \u2014 only at a checkpoint");
+            return;
+          }
+          if (!checkpointResolveRef.current) {
+            setNotice("no checkpoint is waiting");
+            return;
+          }
+          const resolve2 = checkpointResolveRef.current;
+          checkpointResolveRef.current = null;
+          checkpointLabelRef.current = "";
+          resolve2({ action: "modify", instruction });
+          setNotice("modifying and continuing\u2026");
+          return;
+        }
         case "agents":
           setNotice(
             `team: ${plannedAgents(config).map((agent) => agent.id).join(", ")}`
@@ -2823,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");
@@ -2900,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;
         }
@@ -2924,6 +3300,14 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           setNotice("showing latest output");
           return;
         case "cancel": {
+          if (checkpointResolveRef.current) {
+            const resolve2 = checkpointResolveRef.current;
+            checkpointResolveRef.current = null;
+            checkpointLabelRef.current = "";
+            resolve2({ action: "cancel" });
+            setNotice("checkpoint cancelled");
+            return;
+          }
           if (!abortRef.current) {
             setNotice("nothing to cancel");
             return;
@@ -2968,6 +3352,10 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
       runCommand(command.name, command.args, text);
       return;
     }
+    if (checkpointResolveRef.current) {
+      runCommand("modify", [text], text);
+      return;
+    }
     setLine(EMPTY_LINE);
     setNotice(void 0);
     if (running || busyRef.current) {
@@ -3009,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();
@@ -3054,6 +3444,7 @@ function App({ config, onTurnStart, sessions: providedSessions, onCleanupReady }
           return;
         }
         continuationRef.current = { turn: target.turn, sessions };
+        dispatch({ type: "view:open", turn: target.turn });
         setHistoryOpen(false);
         setNotice(
           `continuing turn ${target.turn} \u2014 ${count} ${count === 1 ? "session" : "sessions"} \xB7 type your next instruction`
@@ -3062,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;
@@ -3308,11 +3743,11 @@ 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 ? 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";
-  const placeholder = frontQuestion !== void 0 ? formField === void 0 ? "enter to answer" : editingField !== void 0 ? `${editingField.title}${editingField.required ? " *" : ""} \u2014 enter for the next field` : `${formField.title} \u2014 \u2191\u2193 to pick \xB7 enter for the next field` : front?.kind === "permission" && !menu.released ? "choose above \xB7 esc to type here instead" : running ? RUNNING_PLACEHOLDER : awaitingAnswer ? "answer the leader\u2026 \xB7 /task starts a new task" : INPUT_PLACEHOLDER;
+  const placeholder = frontQuestion !== void 0 ? formField === void 0 ? "enter to answer" : editingField !== void 0 ? `${editingField.title}${editingField.required ? " *" : ""} \u2014 enter for the next field` : `${formField.title} \u2014 \u2191\u2193 to pick \xB7 enter for the next field` : front?.kind === "permission" && !menu.released ? "choose above \xB7 esc to type here instead" : checkpointResolveRef.current ? `checkpoint: ${checkpointLabelRef.current} \u2014 type feedback or /continue` : running ? RUNNING_PLACEHOLDER : awaitingAnswer ? "answer the leader\u2026 \xB7 /task starts a new task" : INPUT_PLACEHOLDER;
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: layout.rows, children: [
     /* @__PURE__ */ jsx6(
       Header,
@@ -3346,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
@@ -3455,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 {