@a-t-h-i/bot-lobby 0.6.27 → 0.6.28

package/src/lobby/service.ts

@@ -24,7 +24,7 @@ import { livePresence } from "../state/presence.ts";
 import { archiveTask as archiveTaskOnDisk, deleteTask as deleteTaskOnDisk, listArchivedTasks, restoreTask as restoreTaskOnDisk } from "../state/archive.ts";
 import { discardPlannedTask, listPlannedTasks, type PlannedTask } from "../state/backlog.ts";
 import { readClassifierMetrics, readMetrics } from "../state/metrics.ts";
-import { currentZenTask, taskSnapshot } from "../pi/ui.ts";
+import { applyStatus, currentZenTask, taskSnapshot } from "../pi/ui.ts";
 import { taskName } from "../text.ts";
 import { describeWorkspace } from "../execution/workspace.ts";
 import { stripStartFlags } from "../pi/start-flags.ts";
@@ -40,7 +40,10 @@ import { SessionChats } from "./session-files.ts";
 import { answerMessage, questionnaires, settledQuestions } from "./ask.ts";
 import { askUser } from "../ask/web.ts";
 import type { Asker } from "../ask/types.ts";
-import { PlanningSession, type PlannerSeed } from "./planner.ts";
+import { PlanningSession, type PlannerDeps, type PlannerSeed } from "./planner.ts";
+import { settleInterrupted, type Relaunch } from "./recovery.ts";
+import { carryOnMessage, resumeRoute, RESUMED_DECISION, type Drivers } from "./resume.ts";
+import { archivePlan as archivePlanOnDisk, deletePlan as deletePlanOnDisk, isPlanId, previousPlans, readPlan, type PlanRecord, type PlanSummary } from "../state/plan-history.ts";
 import { applyMasterModel } from "../pi/model-settings.ts";
 import { lobbyTopics } from "./topics.ts";
 import { checkSession } from "../excalidraw/check.ts";
@@ -93,7 +96,13 @@ export function setServiceState(state: Runtime | undefined): void {
 export function lobbyNotify(state: Runtime, message: string, level: "info" | "warning" | "error" = "info"): void {
   lobbyTopics.bump("notices");
   pushNotice(message, level as NoticeLevel);
-  if (level !== "info") state.ctx.ui.notify(message, level);
+  // Work the lobby started may finish after pi replaced the session: its terminal is the new session's then.
+  if (level === "info" || state !== serviceState) return;
+  try {
+    state.ctx.ui.notify(message, level);
+  } catch {
+    // A replaced session's terminal: the page has the notice.
+  }
 }
 
 function sessionModel(ctx: ExtensionContext): string | undefined {
@@ -235,6 +244,7 @@ export function backgroundSessions(): readonly BackgroundSession[] {
 function sessionsChanged(): void {
   lobbyTopics.bump("sessions");
   const state = serviceState;
+  state?.keeper?.window.schedule();
   for (const session of registry?.sessions ?? []) {
     if (session.sessionId && session.sessionFile) chats.remember(session.sessionId, session.sessionFile);
     const seen = announced.get(session.key) ?? 0;
@@ -284,6 +294,117 @@ function startSession(state: Runtime, start: { request?: string; plan?: PlannedT
   }
 }
 
+/** Start again, in the background, a session a stopped window drove; the session, or why not. */
+export function resumeSession(state: Runtime, start: Relaunch): BackgroundSession | string {
+  try {
+    const session = sessionRegistry().start(state.ctx.cwd, {
+      name: start.name,
+      projectRoot: state.root,
+      onDialog: dialogTracker(state),
+      sessionFile: start.sessionFile,
+      ...(start.message ? { message: start.message } : {}),
+    });
+    lobbyFeed.log("LOBBY", `carried "${start.name}" (${start.taskId}) on in the background`, "success");
+    return session;
+  } catch (error) {
+    return `could not carry ${start.taskId} on — ${(error as Error).message}`;
+  }
+}
+
+/** The sessions that could drive a task, as this window sees them. */
+function taskDrivers(state: Runtime): Drivers {
+  const mine = backgroundSessions().filter((session) => session.alive && session.projectRoot === state.root);
+  return {
+    me: state.ctx.sessionManager.getSessionId(),
+    background: new Set(mine.flatMap((session) => (session.sessionId ? [session.sessionId] : []))),
+    carrying: new Set(mine.flatMap((session) => (session.taskId ? [session.taskId] : []))),
+    live: new Set(liveSessions(state).map((session) => session.sessionId)),
+  };
+}
+
+/** Tasks between a Resume click and their background session starting, so a second click starts nothing. */
+const resuming = new Set<string>();
+
+function unpause(state: Runtime, taskId: string): void {
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task?.paused) return;
+  task.paused = false;
+  task.updatedAt = new Date().toISOString();
+  saveTask(state.root, state.configDir, task);
+}
+
+/**
+ * Resume a task from the Tasks screen, leaving this window where it is. A
+ * paused task is unpaused where it runs and its oracle told to carry on; one
+ * no running session drives carries on in a background session: its own
+ * session started again from its file when there is one, else a fresh one
+ * that takes it over.
+ */
+async function resumeTask(state: Runtime, taskId: string): Promise<{ notice: string; key?: string }> {
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) return { notice: `no task ${taskId}` };
+  if (resuming.has(taskId)) return { notice: `${taskId} is already being resumed` };
+  const route = resumeRoute(task, taskDrivers(state));
+  const background = () => backgroundSessions().find((session) => session.alive && session.projectRoot === state.root && ((task.ownerSessionId && session.sessionId === task.ownerSessionId) || session.taskId === taskId));
+  switch (route.kind) {
+    case "finished":
+      return { notice: `${taskId} is ${task.state}; there is nothing to resume` };
+    case "running": {
+      const session = route.where === "background" ? background() : undefined;
+      const where = route.where === "here" ? "in this window" : session ? `in ${session.name}` : "in another terminal";
+      return { notice: `${taskId} is already under way ${where}`, ...(session ? { key: session.key } : {}) };
+    }
+    case "paused": {
+      unpause(state, taskId);
+      lobbyTopics.bump("tasks");
+      const message = carryOnMessage(task, "paused");
+      if (route.where === "here") {
+        state.pi.sendUserMessage(message, state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+        try { applyStatus(state.ctx, state.root, state.configDir); } catch {}
+        lobbyFeed.log("LOBBY", `resumed ${taskId}`, "success");
+        return { notice: `resumed ${taskId} in this window` };
+      }
+      const session = route.where === "background" ? background() : undefined;
+      if (session) {
+        session.send(message);
+        lobbyFeed.log("LOBBY", `resumed ${taskId} in ${session.name}`, "success");
+        return { notice: `resumed ${taskId} in ${session.name}`, key: session.key };
+      }
+      try {
+        sendToInbox(state.root, state.configDir, taskId, message, state.ctx.sessionManager.getSessionId());
+      } catch (error) {
+        return { notice: `unpaused ${taskId}, but could not tell its oracle — ${(error as Error).message}` };
+      }
+      lobbyFeed.log("LOBBY", `resumed ${taskId} in another terminal`, "success");
+      return { notice: `resumed ${taskId} — the session driving it in another terminal carries on` };
+    }
+    case "stopped":
+      break;
+  }
+  resuming.add(taskId);
+  try {
+    const file = task.ownerSessionId ? await chats.locate(task.ownerSessionId) : undefined;
+    settleInterrupted(state.root, state.configDir, taskId, new Date(), RESUMED_DECISION);
+    // `/bot-lobby carry-on` unpauses it too; done here as well, the Tasks screen shows it at once.
+    unpause(state, taskId);
+    const session = sessionRegistry().start(state.ctx.cwd, {
+      name: task.title,
+      projectRoot: state.root,
+      onDialog: dialogTracker(state),
+      taskId,
+      ...(file ? { sessionFile: file } : {}),
+      message: `/bot-lobby carry-on ${taskId}`,
+    }, file ? undefined : sessionModel(state.ctx));
+    lobbyFeed.log("LOBBY", `resumed "${task.title}" (${taskId}) in the background`, "success");
+    lobbyTopics.bump("tasks");
+    return { notice: `resumed ${taskId} in a background session`, key: session.key };
+  } catch (error) {
+    return { notice: `could not resume ${taskId} — ${(error as Error).message}` };
+  } finally {
+    resuming.delete(taskId);
+  }
+}
+
 /** Leave a message for a task another terminal's session drives; its owner passes it to the oracle. */
 function sendToTask(state: Runtime, taskId: string, text: string): string {
   const task = loadTask(state.root, state.configDir, taskId);
@@ -452,16 +573,74 @@ export function seatProfile(state: Runtime, member: PanelMember) {
 }
 
 function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMember[]): PlanningSession {
+  // The session left behind stays among the project's previous plans, as it stood.
+  state.keeper?.planner.flush();
+  state.planner?.cancel();
+  state.planner = new PlanningSession(plannerDeps(state, seats ?? loadConfig().lobby.planningPanel), seed);
+  state.keeper?.planner.schedule();
+  return state.planner;
+}
+
+/** Previous plans: the project's planning sessions never saved as a task, other than the one on screen. */
+function plansBefore(state: Runtime, archived: boolean): PlanSummary[] {
+  return previousPlans(state.root, state.configDir, { archived, except: state.planner?.id });
+}
+
+/** A previous plan to read: never the one on screen, and never one saved as a task. */
+function previousPlan(state: Runtime, id: string): PlanRecord {
+  const record = isPlanId(id) ? readPlan(state.root, state.configDir, id) : undefined;
+  if (!record) throw new Error(`no plan ${id}`);
+  if (record.savedAs?.length) throw new Error(`${id} was saved as ${record.savedAs.join(", ")}`);
+  return record;
+}
+
+function onScreen(state: Runtime, id: string): void {
+  if (state.planner?.id === id) throw new Error("that is the plan on screen — start a new plan first");
+}
+
+function archivePrevious(state: Runtime, id: string, archived: boolean): string {
+  onScreen(state, id);
+  const record = archivePlanOnDisk(state.root, state.configDir, id, archived);
+  lobbyTopics.bump("planner");
+  return archived ? `archived "${record.title}" — show archived plans to bring it back` : `"${record.title}" is back among the previous plans`;
+}
+
+function deletePrevious(state: Runtime, id: string): string {
+  onScreen(state, id);
+  const record = previousPlan(state, id);
+  deletePlanOnDisk(state.root, state.configDir, id);
+  lobbyTopics.bump("planner");
+  return `deleted "${record.title}" for good`;
+}
+
+/** Carry a previous plan on: it becomes the plan on screen, and the one there joins the previous plans. */
+function reopenPlan(state: Runtime, id: string): string {
+  if (state.planner?.busy) return "the panel is still thinking — wait for the round to finish";
+  onScreen(state, id);
+  const record = previousPlan(state, id);
+  state.keeper?.planner.flush();
   state.planner?.cancel();
-  const config = loadConfig();
-  const workflow = config.workflow;
-  state.planner = new PlanningSession({
+  state.planner = PlanningSession.restore(plannerDeps(state, record.snapshot.seats), { ...record.snapshot, id: record.id, running: false });
+  if (record.archivedAt) archivePlanOnDisk(state.root, state.configDir, id, false);
+  state.keeper?.planner.schedule();
+  lobbyTopics.bump("planner");
+  return `carrying on "${record.title}"`;
+}
+
+/** What a planning session in this window runs with; every change is kept on disk, so it carries on after a crash. */
+export function plannerDeps(state: Runtime, seats: readonly PanelMember[]): PlannerDeps {
+  const workflow = loadConfig().workflow;
+  const changed = () => {
+    lobbyTopics.bump("planner");
+    state.keeper?.planner.schedule();
+  };
+  return {
     cwd: state.ctx.cwd,
     root: state.root,
     configDir: state.configDir,
     profile: () => lobbyProfile(state, "planner"),
     memberProfile: (member) => seatProfile(state, member),
-    panel: seats ?? config.lobby.planningPanel,
+    panel: seats,
     maxRounds: () => loadConfig().lobby.maxPlanningRounds,
     classifier: classifier(),
     hints: hintsFor({ cwd: state.ctx.cwd, root: state.root, configDir: state.configDir }),
@@ -469,10 +648,9 @@ function newPlanner(state: Runtime, seed?: PlannerSeed, seats?: readonly PanelMe
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
-    onChange: () => lobbyTopics.bump("planner"),
-    onRound: () => lobbyTopics.bump("planner"),
-  }, seed);
-  return state.planner;
+    onChange: changed,
+    onRound: changed,
+  };
 }
 
 /** The questionnaire in the page; tests swap it. */
@@ -610,6 +788,11 @@ export function createLobbyService(state: Runtime): LobbyService {
     quickfix: state.quickfix,
     planner: () => state.planner,
     newPlanner: (seed, seats) => newPlanner(state, seed, seats),
+    previousPlans: (archived) => plansBefore(state, archived),
+    previousPlan: (id) => previousPlan(state, id),
+    archivePlan: (id, archived) => archivePrevious(state, id, archived),
+    deletePlan: (id) => deletePrevious(state, id),
+    reopenPlan: (id) => reopenPlan(state, id),
     answerPanel: () => answerPanel(state),
     savePlan: () => savePlan(state),
     defaultPanel: () => loadConfig().lobby.planningPanel,
@@ -638,6 +821,7 @@ export function createLobbyService(state: Runtime): LobbyService {
       }
     },
     issuesEnabled: () => loadConfig().lobby.issues,
+    recovered: () => state.recovered,
     seatLabel: (member) => {
       const profile = seatProfile(state, member);
       return `${profile.model ?? "session model"} · ${profile.thinking}`;
@@ -663,6 +847,7 @@ export function createLobbyService(state: Runtime): LobbyService {
     isAuto: (taskId) => autoFor(state, taskId),
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
+    resumeTask: (taskId) => resumeTask(state, taskId),
     sendToSession: (sessionId, text) => sendToSession(state, sessionId, text),
     liveSessions: () => liveSessions(state),
     switchTo: (target) => switchTo(state, target),

package/src/lobby/sessions.ts

@@ -48,6 +48,12 @@ export interface SessionStart {
   request?: string;
   planId?: string;
   auto?: boolean;
+  /** Carry on this saved session instead of starting a new one (after the window that drove it stopped). */
+  sessionFile?: string;
+  /** Sent once it is up, as the user's message (the nudge that picks an interrupted turn back up). */
+  message?: string;
+  /** The task it was started to carry on (resumed from the Tasks screen). */
+  taskId?: string;
 }
 
 let counter = 0;
@@ -61,6 +67,8 @@ export class BackgroundSession {
   readonly name: string;
   /** The planned task it was started from. */
   readonly planId?: string;
+  /** The task it was started to carry on. */
+  readonly taskId?: string;
   readonly feed = new LobbyFeed();
   readonly startedAt = Date.now();
   status: SessionStatus = "starting";
@@ -86,6 +94,7 @@ export class BackgroundSession {
     this.name = start.name;
     this.projectRoot = start.projectRoot;
     if (start.planId) this.planId = start.planId;
+    if (start.taskId) this.taskId = start.taskId;
     this.onDialog = start.onDialog ?? (() => {});
     this.proc = proc;
     this.onChange = onChange;
@@ -103,6 +112,7 @@ export class BackgroundSession {
     this.write({ type: "get_state" });
     if (start.planId) this.prompt(`/bot-lobby start-plan ${start.planId}${start.auto ? " auto" : ""}`);
     else if (start.request) this.prompt(`/bot-lobby --task ${start.auto ? "--auto " : ""}${start.request}`);
+    else if (start.message) this.prompt(start.message);
   }
 
   private ended(code: number | null, reason: string): void {
@@ -277,8 +287,8 @@ export function extensionArgs(argv: readonly string[] = process.argv): string[]
   return forwarded;
 }
 
-export function sessionArgs(name: string, model?: string, argv: readonly string[] = process.argv): string[] {
-  return ["--mode", "rpc", "--name", name, ...(model ? ["--model", model] : []), ...extensionArgs(argv)];
+export function sessionArgs(name: string, model?: string, argv: readonly string[] = process.argv, sessionFile?: string): string[] {
+  return ["--mode", "rpc", ...(sessionFile ? ["--session", sessionFile] : []), "--name", name, ...(model ? ["--model", model] : []), ...extensionArgs(argv)];
 }
 
 const POSIX = process.platform !== "win32";
@@ -307,7 +317,7 @@ export class SessionRegistry {
   }
 
   start(cwd: string, start: SessionStart, model?: string): BackgroundSession {
-    const proc = this.launcher(sessionArgs(start.name, model), cwd);
+    const proc = this.launcher(sessionArgs(start.name, model, process.argv, start.sessionFile), cwd);
     const session = new BackgroundSession(proc, start, this.onChange);
     this.sessions.push(session);
     this.prune();

package/src/lobby/task-rows.ts

@@ -32,4 +32,6 @@ export interface TaskRow {
   issue?: number;
   /** Auto mode is on: the oracle drives it without asking. */
   auto?: boolean;
+  /** Resume can carry it on from the Tasks screen: it is paused, or no running session drives it. */
+  resumable?: boolean;
 }

package/src/pi/commands.ts

@@ -7,6 +7,7 @@ import { hasScoutThinking, SCOUT_THINKING } from "../schemas/configuration.ts";
 import {
   activeTask,
   claimTask,
+  loadTask,
   ownedTask,
   ownerlessTask,
   saveTask,
@@ -33,6 +34,8 @@ import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startCloc
 import { qaStillDue } from "../workflow/track.ts";
 import type { GitIsolation } from "../schemas/configuration.ts";
 import { START_FLAG } from "./start-flags.ts";
+import { livePresence } from "../state/presence.ts";
+import { carryOnMessage } from "../lobby/resume.ts";
 
 const HELP = [
   "/bot-lobby                  Open the web lobby in your browser: tasks, plan, quick fix, metrics",
@@ -54,6 +57,7 @@ const HELP = [
   "/bot-lobby config           Show effective configuration",
   "/bot-lobby on|off           Turn bot-lobby on or off for this session (ctrl+shift+m); a new session starts off",
   "/bot-lobby claim <taskId>    Take ownership of an orphaned task",
+  "/bot-lobby carry-on <taskId>   Take over a task no running session drives, unpause it and have the oracle carry it on (the Tasks screen's Resume)",
   "/bot-lobby auto [on|off]    Auto mode: the oracle drives this session's task without asking (alt+g)",
   "/bot-lobby start-plan PLAN-… [auto]   Start a planned task here; its agreed plan needs no approval",
   "/bot-lobby switch <session.jsonl>   Run a saved session in this window (the web lobby's session browser uses it)",
@@ -62,10 +66,10 @@ const HELP = [
 ].join("\n");
 
 /** Subcommands only win when no free-form text follows (so tasks still start). */
-const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "on", "off", "minimize", "restore", "claim", "auto", "start-plan", "switch", "web"]);
+const SUBCOMMANDS = new Set(["lobby", "help", "status", "runs", "tasks", "pause", "resume", "cancel", "approve", "amend", "decline", "accept", "budget", "knowledge", "config", "settings", "on", "off", "minimize", "restore", "claim", "carry-on", "auto", "start-plan", "switch", "web"]);
 
 /** Subcommands that act on a task or open the lobby turn bot-lobby on first; the rest work while it is off. */
-const TURNS_ON = new Set(["lobby", "settings", "resume", "approve", "amend", "decline", "accept", "claim", "auto", "start-plan", "switch", "web"]);
+const TURNS_ON = new Set(["lobby", "settings", "resume", "approve", "amend", "decline", "accept", "claim", "carry-on", "auto", "start-plan", "switch", "web"]);
 
 /** `Task-Change-Table-Font-27-09-2026`, or an older `TASK-add-login` id. */
 function isTaskId(value: string | undefined): boolean {
@@ -209,6 +213,36 @@ function claimTaskCommand(ctx: ExtensionCommandContext, configDir: string, taskI
   applyStatus(ctx, root, configDir);
   ctx.ui.notify(`bot-lobby now owns ${claimed.id}.`, "info");
 }
+/**
+ * `/bot-lobby carry-on <taskId>`: take over a task no running session drives
+ * (or this session's own, when it is started again from its file), unpause it
+ * and have the oracle carry it on. A background session resumed from the
+ * Tasks screen runs it as its first message.
+ */
+function carryOnCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext, configDir: string, taskId?: string): void {
+  if (!isTaskId(taskId)) return ctx.ui.notify("Usage: /bot-lobby carry-on <taskId>", "warning");
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const sessionId = ctx.sessionManager.getSessionId();
+  const current = ownedTask(root, configDir, sessionId);
+  if (current && current.id !== taskId && !TERMINAL_STATES.includes(current.state)) {
+    return ctx.ui.notify(`bot-lobby ${current.id} is already active in this session; cancel it before carrying ${taskId} on.`, "warning");
+  }
+  const task = loadTask(root, configDir, taskId!);
+  if (!task) return ctx.ui.notify(`No task ${taskId}.`, "warning");
+  if (TERMINAL_STATES.includes(task.state)) return ctx.ui.notify(`${task.id} is already ${task.state}.`, "warning");
+  const owner = task.ownerSessionId;
+  if (owner && owner !== sessionId && livePresence(root, configDir).some((presence) => presence.sessionId === owner)) {
+    return ctx.ui.notify(`${task.id} is driven by a session that is still running; carry it on there.`, "warning");
+  }
+  task.ownerSessionId = sessionId;
+  task.paused = false;
+  task.updatedAt = new Date().toISOString();
+  saveTask(root, configDir, task);
+  applyStatus(ctx, root, configDir);
+  ctx.ui.notify(`bot-lobby carries ${task.id} on in this session.`, "info");
+  pi.sendUserMessage(carryOnMessage(task, "stopped"), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
+}
+
 function answerProposal(
   ctx: ExtensionCommandContext,
   configDir: string,
@@ -391,6 +425,8 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
           return turnOn(pi, ctx, configDir);
         case "claim":
           return claimTaskCommand(ctx, configDir, rest[0]);
+        case "carry-on":
+          return carryOnCommand(pi, ctx, configDir, rest[0]);
         case "auto":
           return autoCommand(ctx, configDir, rest[0]);
         case "switch":

package/src/pi/events.ts

@@ -68,12 +68,15 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
 export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   // Web tools the oracle put away for the task in hand, given back when it ends.
   let hiddenWeb: string[] = [];
-  pi.on("session_start", (_event, ctx) => {
+  pi.on("session_start", (event, ctx) => {
     // Master-only: subagents keep their own --tools allowlist (see quiet.ts).
     if (!isSubagentProcess()) registerQuietTools(pi);
     const root = detectProjectRoot(ctx.cwd, configDir);
-    // A new session starts with bot-lobby off unless settings or its own task say otherwise (switch.ts).
-    setMinimized(!isSubagentProcess() && !startsOn(ctx, configDir));
+    // pi starting decides afresh: off unless settings or the session's own task say otherwise (switch.ts).
+    // A session replaced in this window (switched to, new, forked, reloaded) keeps bot-lobby as it was,
+    // so switching sessions from the lobby never leaves the page behind; it turns on for a task under way.
+    const fresh = !event?.reason || event.reason === "startup";
+    setMinimized(!isSubagentProcess() && (fresh || isMinimized()) && !startsOn(ctx, configDir));
     applyStatus(ctx, root, configDir);
   });
 

package/src/pi/switch.ts

@@ -12,6 +12,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Key } from "@earendil-works/pi-tui";
 import { currentLobbyService, lobbyWorkRunning, servesPage, startLobbyService, stopLobbyService } from "../lobby/runtime.ts";
 import { activeTask } from "../state/persistence.ts";
+import { workToCarryOn } from "../lobby/recovery.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { stopWebServer, webSessionStarted } from "../webui/command.ts";
 import { isSubagentProcess } from "./quiet.ts";
@@ -23,11 +24,15 @@ export function isOn(): boolean {
   return !isMinimized();
 }
 
-/** Whether a new session starts on: when settings say so, or it owns a task still under way. */
+/**
+ * Whether a new session starts on: when settings say so, when it owns a task
+ * still under way, or when a window in the project stopped unexpectedly and
+ * its work is waiting to carry on.
+ */
 export function startsOn(ctx: ExtensionContext, configDir: string): boolean {
   if (loadConfig().lobby.startOn) return true;
   const root = detectProjectRoot(ctx.cwd, configDir);
-  return Boolean(activeTask(root, configDir, ctx.sessionManager.getSessionId()));
+  return Boolean(activeTask(root, configDir, ctx.sessionManager.getSessionId())) || (servesPage(ctx) && workToCarryOn(root, configDir));
 }
 
 /** Turn bot-lobby on: the oracle's prompt comes back and the web lobby starts (opening the browser if settings say so). */

package/src/pi/ui.ts

@@ -72,8 +72,14 @@ function setZenState(task: Task | undefined, live: AgentRun[]): void {
   zenState = { task, live, runs: mergeRuns(persistedRuns(task), live) };
 }
 
-/** Bot-lobby off for this session (plain pi): the Master prompt is hidden but ownership stays (see switch.ts). */
-let minimized = false;
+/**
+ * Bot-lobby off for this session (plain pi): the Master prompt is hidden but
+ * ownership stays (see switch.ts). Kept on the process, not the module: a
+ * reload imports the extension afresh, and on or off must outlive it.
+ */
+const SWITCH = Symbol.for("bot-lobby.minimized");
+const processState = globalThis as { [SWITCH]?: boolean };
+let minimized = processState[SWITCH] ?? false;
 
 export function isMinimized(): boolean {
   return minimized;
@@ -81,6 +87,7 @@ export function isMinimized(): boolean {
 
 export function setMinimized(value: boolean): void {
   minimized = value;
+  processState[SWITCH] = value;
 }
 
 /**

package/src/state/plan-history.ts

@@ -0,0 +1,142 @@
+/**
+ * Every planning session in a project, kept as it goes (one file each under
+ * `planning/`): the conversation, the draft and the panel, so a plan the user
+ * walked away from (a new plan, a closed window) can be read again, carried
+ * on, archived or deleted. A session saved as a pending task is flagged with
+ * the tasks it became and leaves the previous plans; its record stays.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataRoot } from "./project.ts";
+import type { PlanningSnapshot } from "../lobby/planner.ts";
+
+export interface PlanRecord {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  /** Put aside by the user: listed only with the archived plans. */
+  archivedAt?: string;
+  /** The pending tasks it was saved as: such a plan is no longer a previous plan. */
+  savedAs?: string[];
+  snapshot: PlanningSnapshot;
+}
+
+/** What a list of previous plans shows of each. */
+export interface PlanSummary {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  archivedAt?: string;
+  /** Messages in its conversation. */
+  messages: number;
+  rounds: number;
+  hasDraft: boolean;
+}
+
+const PLAN_ID = /^PS-[a-z0-9]{4,32}$/;
+
+export function isPlanId(id: string): boolean {
+  return PLAN_ID.test(id);
+}
+
+export function planningDir(root: string, configDir: string): string {
+  return join(dataRoot(root, configDir), "planning");
+}
+
+function recordPath(root: string, configDir: string, id: string): string {
+  if (!isPlanId(id)) throw new Error(`no plan ${id}`);
+  return join(planningDir(root, configDir), `${id}.json`);
+}
+
+/** A title for a session: the oracle's, else the start of the idea. */
+export function planTitle(snapshot: PlanningSnapshot): string {
+  const words = snapshot.reply?.title ?? snapshot.seed?.issue.title ?? snapshot.messages.find((message) => message.role === "you")?.text ?? "";
+  const line = words.split("\n")[0]!.replace(/\s+/g, " ").trim();
+  return (line.length > 80 ? `${line.slice(0, 79)}…` : line) || "Untitled plan";
+}
+
+export function readPlan(root: string, configDir: string, id: string): PlanRecord | undefined {
+  try {
+    const record = JSON.parse(readFileSync(recordPath(root, configDir, id), "utf8")) as PlanRecord;
+    return record && record.id === id && record.snapshot && Array.isArray(record.snapshot.messages) ? record : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function write(root: string, configDir: string, record: PlanRecord): void {
+  const path = recordPath(root, configDir, record.id);
+  mkdirSync(planningDir(root, configDir), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(record), "utf8");
+  renameSync(tmp, path);
+}
+
+/**
+ * Keep a session as it stands. One that has not started (no idea, no issue)
+ * is not kept; saving it as a task flags it, for good.
+ */
+export function keepPlan(root: string, configDir: string, id: string, createdAt: number, snapshot: PlanningSnapshot, now = new Date()): void {
+  if (!isPlanId(id) || (snapshot.messages.length === 0 && !snapshot.seed)) return;
+  const previous = readPlan(root, configDir, id);
+  const saved = [...new Set([...(previous?.savedAs ?? []), ...(snapshot.saved ? [snapshot.saved.id] : []), ...snapshot.savedParts.map((part) => part.id)])];
+  write(root, configDir, {
+    id,
+    title: planTitle(snapshot),
+    createdAt: previous?.createdAt ?? new Date(createdAt).toISOString(),
+    updatedAt: now.toISOString(),
+    ...(previous?.archivedAt ? { archivedAt: previous.archivedAt } : {}),
+    ...(saved.length > 0 ? { savedAs: saved } : {}),
+    snapshot: { ...snapshot, running: false },
+  });
+}
+
+function summary(record: PlanRecord): PlanSummary {
+  return {
+    id: record.id,
+    title: record.title,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    ...(record.archivedAt ? { archivedAt: record.archivedAt } : {}),
+    messages: record.snapshot.messages.length,
+    rounds: record.snapshot.turns,
+    hasDraft: Boolean(record.snapshot.reply?.plan),
+  };
+}
+
+/**
+ * The previous plans: never saved as a task, newest first; the archived ones
+ * only when asked for, and the session on screen (`except`) never.
+ */
+export function previousPlans(root: string, configDir: string, options: { archived?: boolean; except?: string } = {}): PlanSummary[] {
+  const dir = planningDir(root, configDir);
+  if (!existsSync(dir)) return [];
+  const found: PlanSummary[] = [];
+  for (const file of readdirSync(dir)) {
+    const id = file.replace(/\.json$/, "");
+    if (!file.endsWith(".json") || !isPlanId(id) || id === options.except) continue;
+    const record = readPlan(root, configDir, id);
+    if (!record || record.savedAs?.length) continue;
+    if (Boolean(record.archivedAt) !== Boolean(options.archived)) continue;
+    found.push(summary(record));
+  }
+  return found.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+/** Put a previous plan aside, or bring it back. */
+export function archivePlan(root: string, configDir: string, id: string, archived: boolean, now = new Date()): PlanRecord {
+  const record = readPlan(root, configDir, id);
+  if (!record) throw new Error(`no plan ${id}`);
+  if (record.savedAs?.length) throw new Error(`${id} was saved as a task`);
+  const { archivedAt: _was, ...rest } = record;
+  const next: PlanRecord = archived ? { ...rest, archivedAt: now.toISOString() } : rest;
+  write(root, configDir, next);
+  return next;
+}
+
+export function deletePlan(root: string, configDir: string, id: string): void {
+  if (!readPlan(root, configDir, id)) throw new Error(`no plan ${id}`);
+  rmSync(recordPath(root, configDir, id), { force: true });
+}