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

package/src/lobby/resume.ts

@@ -0,0 +1,66 @@
+/**
+ * Resuming a task from the Tasks screen, without moving this window. A paused
+ * task is unpaused where it runs (this window, a background session, another
+ * terminal) and its oracle told to carry on. A task no running session drives
+ * carries on in a new background session: its old session started again from
+ * its file when there is one (the oracle keeps its conversation), else a fresh
+ * session that takes the task over (`/bot-lobby carry-on`).
+ */
+import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+
+/** The sessions that could be driving a task, as this window sees them. */
+export interface Drivers {
+  /** This window's session. */
+  me?: string;
+  /** Sessions this window runs in the background, alive. */
+  background: ReadonlySet<string>;
+  /** Tasks a background session of this window was started to carry on (it may not have its id yet). */
+  carrying: ReadonlySet<string>;
+  /** Sessions running in other terminals. */
+  live: ReadonlySet<string>;
+}
+
+export type Where = "here" | "background" | "elsewhere";
+
+export type ResumeRoute =
+  | { kind: "finished" }
+  /** Under way and not paused: nothing to resume. */
+  | { kind: "running"; where: Where }
+  | { kind: "paused"; where: Where }
+  /** No running session drives it. */
+  | { kind: "stopped" };
+
+function drivenFrom(task: Task, drivers: Drivers): Where | undefined {
+  const owner = task.ownerSessionId;
+  if (owner && owner === drivers.me) return "here";
+  if ((owner && drivers.background.has(owner)) || drivers.carrying.has(task.id)) return "background";
+  if (owner && drivers.live.has(owner)) return "elsewhere";
+  return undefined;
+}
+
+export function resumeRoute(task: Task, drivers: Drivers): ResumeRoute {
+  if (TERMINAL_STATES.includes(task.state)) return { kind: "finished" };
+  const where = drivenFrom(task, drivers);
+  if (!where) return { kind: "stopped" };
+  return { kind: task.paused ? "paused" : "running", where };
+}
+
+/** Whether the Tasks screen offers Resume: the task is paused, or nothing runs it. */
+export function resumable(task: Task, drivers: Drivers): boolean {
+  const { kind } = resumeRoute(task, drivers);
+  return kind === "paused" || kind === "stopped";
+}
+
+/** The decision a task records when it carries on in a new session. */
+export const RESUMED_DECISION = "resumed from the Tasks screen in a background session; the session that drove it had stopped (steps that were running stopped with it)";
+
+/** What the oracle is told when its task is resumed. */
+export function carryOnMessage(task: Pick<Task, "id" | "state">, after: "paused" | "stopped"): string {
+  if (after === "paused") {
+    return `bot-lobby: the user resumed ${task.id} (${task.state}) from the Tasks screen. Carry on: read where it stands with the orchestrate tool (action=status) and go on from there.`;
+  }
+  return [
+    `bot-lobby: the user resumed ${task.id} (${task.state}) from the Tasks screen; the session that drove it had stopped.`,
+    "Pick up where it left off: read where the task stands with the orchestrate tool (action=status), run again any step that was cut off (its agent stopped with that session, and its edits may be half done), ask again any question that was not answered, and carry on.",
+  ].join(" ");
+}

package/src/lobby/runtime.ts

@@ -22,18 +22,19 @@ import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
 import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
-import type { PlanningSession } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";
 import { PullsState } from "./pulls.ts";
 import { PullReviews } from "./pr-review.ts";
 import { KnowledgeBook } from "./knowledge.ts";
 import { ExcalidrawBook } from "../excalidraw/sessions.ts";
 import type { LobbyService } from "./host.ts";
-import { createLobbyService, lobbyNotify, lobbyProfile, reviewProfile, seatProfile, setServiceState, savePlan as serviceSavePlan, answerPanel as serviceAnswerPanel } from "./service.ts";
+import { backgroundSessions, createLobbyService, lobbyNotify, lobbyProfile, plannerDeps, resumeSession, reviewProfile, seatProfile, setServiceState, savePlan as serviceSavePlan, answerPanel as serviceAnswerPanel } from "./service.ts";
 import { lobbyTopics } from "./topics.ts";
 export { backgroundSessions, setSessionLauncher } from "./service.ts";
 import { deliverComments, onOwnerEvent } from "../pi/owner.ts";
 import { pushNotice } from "../webui/notices.ts";
+import { listenForSignals, NUDGE_DELAY_MS, recover, stoppingOnSignal, WindowKeeper } from "./recovery.ts";
+import { PlanningSession, type PlanningSnapshot } from "./planner.ts";
 
 export { deliverComments };
 
@@ -57,6 +58,10 @@ export interface Runtime {
   /** The repository (or folder) and branch the page's title shows, and whether git is being asked now. */
   workspace: WorkspaceInfo;
   readingWorkspace: boolean;
+  /** Keeps what this window does on disk, so the next window carries it on after a crash. */
+  keeper?: WindowKeeper;
+  /** What this window carried on from one that stopped, as the page announces it once. */
+  recovered?: { at: number; text: string };
 }
 
 let runtime: Runtime | undefined;
@@ -89,12 +94,18 @@ export function lobbyWorkRunning(): string | undefined {
 
 /** Stop the lobby's backend (bot-lobby turned off, or the session ended). */
 export function stopLobbyService(): void {
-  shutdown();
+  shutdown(false);
 }
 
-function shutdown(): void {
+/**
+ * Stop the lobby. `carryOn` (pi is stopping on a signal) keeps what it was
+ * doing on disk for the next window; any other stop records it as stopped.
+ */
+function shutdown(carryOn: boolean): void {
   const state = runtime;
   if (!state) return;
+  // Before anything is cancelled, so what is kept is what was running.
+  state.keeper?.stop(carryOn);
   runtime = undefined;
   lobbyService = undefined;
   setServiceState(undefined);
@@ -129,7 +140,7 @@ function handToQuickFix(state: Runtime, request: string, builder: Domain | undef
  * every interactive master session, not a subagent.
  */
 export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string): Runtime | undefined {
-  shutdown();
+  shutdown(false);
   if (isSubagentProcess() || !servesPage(ctx)) return undefined;
   const root = detectProjectRoot(ctx.cwd, configDir);
   const workflow = loadConfig().workflow;
@@ -175,7 +186,10 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
     stallTimeoutMs: workflow.stallTimeoutMs,
     toolStallTimeoutMs: workflow.toolStallTimeoutMs,
     feed: lobbyFeed,
-    onChange: () => lobbyTopics.bump("quickfix"),
+    onChange: () => {
+      lobbyTopics.bump("quickfix");
+      state.keeper?.quickfix.schedule();
+    },
     notify: (message, level) => lobbyNotify(state, message, level),
     hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
     classifier: classifier(),
@@ -196,6 +210,7 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
   // Only the newest messages are kept; the feed learns whether earlier ones exist, and loads them when scrolled to.
   lobbyFeed.seedChat(chatFromEntries(ctx.sessionManager.getBranch(), Number.POSITIVE_INFINITY));
   state.unsubscribeFeed = lobbyFeed.onChange(() => lobbyTopics.bump("lobby"));
+  carryOn(state);
   onRunUpdates((runs) => {
     lobbyFeed.runs(runs);
     lobbyTopics.bump("tasks");
@@ -212,6 +227,61 @@ export function startLobbyService(pi: ExtensionAPI, ctx: ExtensionContext, confi
   return state;
 }
 
+/**
+ * Keep this window's work on disk from now on, and carry on what a window
+ * that stopped unexpectedly was doing (src/lobby/recovery.ts).
+ */
+function carryOn(state: Runtime): void {
+  listenForSignals();
+  const { root, configDir, ctx } = state;
+  state.keeper = new WindowKeeper({
+    root,
+    configDir,
+    sessionId: () => state.ctx.sessionManager.getSessionId(),
+    sessionFile: () => state.ctx.sessionManager.getSessionFile?.(),
+    working: () => !state.ctx.isIdle(),
+    planner: () => state.planner,
+    quickfix: () => state.quickfix.snapshot(),
+    background: () => backgroundSessions(),
+  });
+  let summary: string | undefined;
+  try {
+    summary = recover({
+      root,
+      configDir,
+      sessionId: ctx.sessionManager.getSessionId(),
+      relaunch: (start) => resumeSession(state, start),
+      restorePlanner: (snapshot) => restorePlanner(state, snapshot),
+      restoreQuickFixes: (jobs) => state.quickfix.restore(jobs).length,
+      nudge: (message) => nudgeWhenIdle(state, message),
+    });
+  } catch (error) {
+    lobbyFeed.log("LOBBY", `could not carry on what the stopped session was doing: ${(error as Error).message}`, "warning");
+  }
+  state.keeper.window.flush();
+  if (!summary) return;
+  state.recovered = { at: Date.now(), text: summary };
+  lobbyFeed.log("LOBBY", summary, "success");
+  state.ctx.ui.notify(`bot-lobby: ${summary}`, "info");
+  lobbyTopics.bump("status");
+}
+
+/** The planning panel as a kept snapshot left it; a round pi cut off runs again. */
+function restorePlanner(state: Runtime, snapshot: PlanningSnapshot): void {
+  state.planner = PlanningSession.restore(plannerDeps(state, snapshot.seats), snapshot);
+  lobbyTopics.bump("planner");
+  void state.planner.resume().catch(() => {});
+}
+
+/** Pick this window's interrupted turn back up once pi has settled, unless the user has already started one. */
+function nudgeWhenIdle(state: Runtime, message: string): void {
+  const timer = setTimeout(() => {
+    if (runtime !== state || !state.ctx.isIdle()) return;
+    state.pi.sendUserMessage(message);
+  }, NUDGE_DELAY_MS);
+  timer.unref?.();
+}
+
 /**
  * Whether this pi process serves the web page: an interactive session. A
  * one-shot run has nobody to answer, and the background sessions the lobby
@@ -252,7 +322,8 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
     // Off (the default for a new session) runs no lobby until bot-lobby is turned on (see pi/switch.ts).
     if (!isMinimized()) startLobbyService(pi, ctx, configDir);
   });
-  pi.on("session_shutdown", () => shutdown());
+  // A quit on a signal (a closed terminal, a kill) is not one the user asked for: its work carries on in the next window.
+  pi.on("session_shutdown", (event) => shutdown(event.reason === "quit" && stoppingOnSignal()));
   pi.on("ui_prompt_start", () => {
     lobbyTopics.bump("status");
   });
@@ -261,6 +332,7 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
   });
   pi.on("agent_start", (_event, ctx) => {
     track(ctx);
+    runtime?.keeper?.window.schedule();
     lobbyTopics.bump("status");
     const taskId = currentZenTask()?.id;
     turn = { startedAt: Date.now(), ...(taskId ? { taskId } : {}), ...(ctx.model ? { model: modelRef(ctx.model) } : {}), thinking: pi.getThinkingLevel(), tools: 0, turns: 0, input: 0, output: 0, cost: 0 };
@@ -284,6 +356,7 @@ export function registerLobbyEvents(pi: ExtensionAPI, configDir: string): void {
   });
   pi.on("agent_end", (event, ctx) => {
     track(ctx);
+    runtime?.keeper?.window.schedule();
     const finished = turn;
     turn = undefined;
     lobbyFeed.replyEnd();

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/master/decisions.ts

@@ -7,14 +7,17 @@ import { builtSomething, onFastTrack, qaRequired, qaTookPart } from "../workflow
 /**
  * §19: everything the engine requires before completion may be declared. The
  * fast track asks for a finished worker step instead of a QA pass, and for
- * QA's part only when the change needs tests.
+ * QA's part only when the change needs tests; so does a planned task whose
+ * QA sat out the planning panel.
  */
 export function completionBlockers(task: Task, pendingCount: number): string[] {
   const blockers: string[] = [];
   if (!task.plan) blockers.push("no approved plan is recorded");
   if (onFastTrack(task)) {
     if (!builtSomething(task)) blockers.push("no worker step has finished yet");
-    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (give qa the tests as the last step, or run the QA gate)");
+    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (run the QA gate: action=qa)");
+  } else if (!qaRequired(task)) {
+    if (!builtSomething(task)) blockers.push("no worker step has finished yet");
   } else if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
   if (pendingCount > 0) blockers.push(`${pendingCount} unresolved approval request(s)`);
   if (task.blockers.length > 0) blockers.push(`${task.blockers.length} unresolved blocker(s)`);

package/src/master/master.ts

@@ -238,6 +238,8 @@ export interface WorkerRequest {
   time?: AgentTime;
   /** The worker may ask the user (the designer): its questions are relayed, and its images saved in `previews`. */
   ask?: { onAsk: RelayAsk; previews: string };
+  /** A QA step's verification budget: Jev's QA risk read of the change so far. */
+  risk?: string;
 }
 
 /** What a worker that may ask the user is told about it. */
@@ -264,6 +266,7 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
       ? `Scout findings for your domain:\n${summarizeOutcomes(own, 1500)}`
       : "No scout findings were collected for your domain; verify the repository yourself.",
     likely,
+    request.risk ?? "",
     request.time?.note ?? "",
     request.ask ? askGuidance(request.ask.previews) : "",
   ].filter(Boolean).join("\n\n");
@@ -344,6 +347,8 @@ export interface ReviewerRequest {
   previousRound?: string;
   /** The engine's lint result on the touched files and the suppressions the task added. */
   lint?: string;
+  /** Jev's QA risk read of the change: the gate's depth, test budget and focus. */
+  risk?: string;
   /** Under a task time budget: the gate's time. */
   time?: AgentTime;
   instruction?: string;
@@ -365,6 +370,7 @@ function reviewerContext(request: ReviewerRequest): string {
   return [
     `Task state: reviewing. Domain: ${request.domain}.`,
     "You may not modify implementation. Report required changes instead.",
+    request.risk ?? "",
     request.previousRound ?? "",
     request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
     owns.length > 0 ? `Scout findings:\n${summarizeOutcomes(owns, 1200)}` : "",