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

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

@@ -13,9 +13,10 @@ import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
+import { requestBesidePlan } from "../state/backlog.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
-import { qaStillDue } from "../workflow/track.ts";
+import { qaStillDue, rosterWords } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
 import { budgetLine, budgetState, clockTask, pauseClocks, readBudget, resumeClocks, startClock, stopClocks, turnStarted } from "../state/budget.ts";
 
@@ -47,12 +48,12 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
   const open = pendingComments(comments);
   return [
     `Task ${task.id}: ${task.title}`,
-    `Request: ${truncate(taskRequest(task), 2000)}`,
+    `Request: ${truncate(task.approvedPlan && task.plan ? requestBesidePlan(taskRequest(task)) : taskRequest(task), 2000)}`,
     task.proposal ? `Current proposal:\n${truncate(task.proposal, 2000)}` : "",
     task.plan ? `Approved plan:\n${truncate(task.plan, 3000)}` : "",
     task.amendments.length > 0 ? `User amendments:\n${task.amendments.map((entry) => `- ${entry}`).join("\n")}` : "",
     open.length > 0 ? `Open plan comments (from the lobby):\n${open.map((comment) => `- ${truncate(comment.text, 600)}`).join("\n")}` : "",
-    task.approvedPlan ? `The user agreed this task's plan in the planning panel (${task.approvedPlan}): follow it, do not ask them to approve a proposal (propose is approved automatically), and answer open questions from the plan.` : "",
+    task.approvedPlan ? `The user agreed this task's plan in the planning panel (${task.approvedPlan}), and it is the task's plan: delegate its steps without clarifying, scouting or proposing, and answer open questions from the plan.${task.track?.satOut?.length ? ` ${rosterWords(task.track.satOut)} sat out the panel: do not give ${task.track.satOut.length === 1 ? "it" : "them"} work${task.track.satOut.includes("qa") ? ", and there is no QA gate (complete once every step is done)" : ""}.` : ""}` : "",
     auto ? "AUTO MODE is on: drive this task to completion without the user. Do not ask them anything (clarify and ask_user_question are not answered); decide yourself, record each decision, and keep calling the orchestrate tool until the task is complete or truly blocked." : "",
   ]
     .filter((line) => line.length > 0)
@@ -67,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/start-task.ts

@@ -7,7 +7,8 @@ import { existsSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createTask, taskRequest, type Task, type TaskTrack, type TaskTriage, type TrackPath } from "../schemas/task.ts";
 import type { Domain } from "../schemas/agent.ts";
-import { chooseTrack, trackLine, trackSummary } from "../workflow/track.ts";
+import { chooseTrack, qaRequired, rosterWords, trackLine, trackSummary } from "../workflow/track.ts";
+import { startFromAgreedPlan } from "../workflow/workflow.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import { createTaskDir, ensureProjectStructure, loadTask, nextTaskId, ownedTask, saveTask, taskDirFor } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
@@ -43,7 +44,7 @@ function fastSteps(track: TaskTrack): string[] {
   const steps = [
     ...(track.roster.includes("researcher") ? ["First summon the researcher for the outside facts it needs: orchestrate action=research with a domain and the question."] : []),
     `Delegate now with orchestrate action=implement: ${builders}; open each task with "Step 1:" (the engine keeps the plan).`,
-    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part (tests): once the change is in, give qa the tests as the last step (action=implement domain=qa), or run action=qa."] : []),
+    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part: once the change is in, run orchestrate action=qa. Jev reads the change and sizes QA to its risk; one with nothing that runs passes on the engine's checks."] : []),
     "Check `git diff --stat` and the report, then orchestrate action=complete with a one-line summary.",
   ];
   return [
@@ -54,6 +55,25 @@ function fastSteps(track: TaskTrack): string[] {
   ].filter(Boolean);
 }
 
+/** A task from an agreed plan: straight to building its steps; QA only when it took part in the panel. */
+function plannedSteps(task: Task): string[] {
+  const qa = qaRequired(task);
+  const steps = [
+    'Delegate the plan\'s steps now with orchestrate action=implement, opening each task with "Step N:" and briefing it in full from the plan. Give one domain its consecutive steps in one call, and run independent domains together with assignments.',
+    "After each report, check `git diff --stat` and the report, then delegate the next step.",
+    qa
+      ? "Once every step is done, run orchestrate action=qa (Jev sizes it to the change), then action=complete with a one-line summary."
+      : "Once every step is done, call orchestrate action=complete with a one-line summary. QA sat out the planning panel, so there is no QA gate.",
+  ];
+  const out = task.track?.satOut ?? [];
+  return [
+    `Planned task: the user agreed this plan in the planning panel (${task.approvedPlan}), and it is already the task's plan. The panel asked the questions and read the code, so there is no clarifying, scouting, proposal or plan to write: start building.`,
+    out.length > 0 ? `Only the members who sat on the panel work on it (${rosterWords(task.track?.roster ?? [])}). ${rosterWords(out)} sat out, so give ${out.length === 1 ? "it" : "them"} nothing; if a step truly needs one, ask the user with orchestrate action=track (the roster with it, and why).` : "",
+    ...steps.map((step, index) => `${index + 1}. ${step}`),
+    "If the code contradicts the plan, amend it with action=plan (the plan with the change made) and tell the user in one line, rather than starting over.",
+  ].filter(Boolean);
+}
+
 export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
   const track = task.track;
   const head = [
@@ -68,6 +88,7 @@ export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: bo
     "",
   ];
   if (track?.path === "fast") return [...head, ...fastSteps(track)].join("\n");
+  if (task.approvedPlan && task.plan && task.state === "planning") return [...head, ...plannedSteps(task)].join("\n");
   const fastAllowed = Boolean(track) && options.fastTrack !== false && track?.userChoice !== "full" && track?.source !== "plan";
   return [
     ...head,
@@ -105,6 +126,10 @@ async function giveWorkspace(ctx: ExtensionContext, root: string, configDir: str
 export interface StartOptions {
   /** The planned task (PLAN-…) this task starts from: the user agreed its plan, so its proposal needs no approval. */
   approvedPlan?: string;
+  /** That plan: it becomes the task's plan, and the task starts at delegating its steps. */
+  plan?: string;
+  /** The panel seats that took part in that plan; one that sat it out (QA) is not part of the task. */
+  panel?: readonly string[];
   /** Start in auto mode: the oracle drives it to completion without asking. */
   auto?: boolean;
   /** The task's short title (a planned task's own title); derived from the request otherwise. */
@@ -140,8 +165,10 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   if (triage) task.triage = triage;
   // How serious the request reads: who takes part, and whether it takes the fast track or the full workflow.
   const config = loadConfig();
-  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}) });
+  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}), ...(options.panel ? { planPanel: options.panel } : {}) });
   lobbyFeed.log("LOBBY", trackLine(task.track), "info");
+  // An agreed plan is the task's plan: it goes straight to delegating its steps.
+  if (options.approvedPlan && options.plan) startFromAgreedPlan(task, options.plan, taskDirFor(root, configDir, task.id));
   await giveWorkspace(ctx, root, configDir, task, options.isolation ?? config.workflow.gitIsolation);
   saveTask(root, configDir, task);
   const budgetMinutes = options.budget ?? config.workflow.taskBudgetMinutes;
@@ -192,7 +219,7 @@ export async function startPlannedTask(pi: ExtensionAPI, ctx: ExtensionContext,
   if (!plan) return `no planned task ${planId}`;
   if (plan.status !== "pending") return `${planId} was already started${plan.startedTaskId ? ` as ${plan.startedTaskId}` : ""}`;
   const waiting = unfinishedBefore(root, configDir, plan);
-  const task = await startTask(pi, ctx, configDir, plannedTaskRequest(plan), { approvedPlan: plan.id, title: plan.title, ...(options.auto ? { auto: true } : {}) });
+  const task = await startTask(pi, ctx, configDir, plannedTaskRequest(plan), { approvedPlan: plan.id, plan: plan.brief, ...(plan.panel ? { panel: plan.panel } : {}), title: plan.title, ...(options.auto ? { auto: true } : {}) });
   if (!task) return `this session already drives a task; finish or cancel it first`;
   markPlannedTaskStarted(root, configDir, plan.id, task.id);
   if (waiting.length > 0) {

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/tools.ts

@@ -16,6 +16,7 @@ import { isQuiet } from "./quiet.ts";
 import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
 import { lintFeed } from "../workflow/lint.ts";
+import { qaRiskLine } from "../classifier/qa-risk.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import {
   ORCHESTRATE_ACTIONS,
@@ -140,6 +141,8 @@ export function workflowDeps(
       const line = lintFeed(taskId, report);
       lobbyFeed.log("LINT", line.text, line.kind);
     },
+    // Jev's QA risk read of each task's change, as the QA gate starts.
+    onQaRisk: (taskId, assessment) => lobbyFeed.log("CLASSIFIER", `${taskId} ${qaRiskLine(assessment)}`, "info"),
   };
 }
 

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/schemas/configuration.ts

@@ -170,7 +170,7 @@ export interface LobbyConfig {
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "qa"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -291,7 +291,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, qa: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,

package/src/schemas/task.ts

@@ -55,6 +55,8 @@ export interface ReviewRecord {
   findings: { severity: Severity; text: string }[];
   requiredChanges: string[];
   createdAt: string;
+  /** The engine's deterministic checks decided the round: no QA agent ran (a change with nothing that runs). */
+  checksOnly?: boolean;
 }
 /**
  * One finished worker delegation, kept on the task so the plan checklist can be
@@ -118,6 +120,32 @@ export interface TaskTriage {
   at: string;
 }
 
+/** How much verification a finished change warrants, lowest first. */
+export const QA_RISKS = ["none", "low", "medium", "high"] as const;
+export type QaRisk = (typeof QA_RISKS)[number];
+
+/**
+ * What the change a task built warrants of QA, read from its diff once the
+ * implementation is done: the QA gate's verification budget. The test budget
+ * is a ceiling, never a quota.
+ */
+export interface QaRiskAssessment {
+  risk: QaRisk;
+  /** Whether an LLM QA pass is needed at all: without one, the engine's deterministic checks decide. */
+  qaRequired: boolean;
+  /** New behavioural tests that may be worth writing, at most `max`. */
+  testBudget: { min: number; max: number };
+  /** What QA should verify first, as words. */
+  focusAreas: string[];
+  /** The evidence behind the level: what the diff touches, with paths. */
+  riskFactors: string[];
+  existingTestsLikelySufficient: boolean;
+  reasoning: string;
+  /** Jev's read of the diff, or the engine's rules alone when Jev is off, failed or had nothing to read. */
+  source: "classifier" | "rules";
+  at: string;
+}
+
 /** How much process a task gets: the fast track for a small, clear, low-risk change, the full workflow for the rest. */
 export type TrackPath = "fast" | "full";
 
@@ -142,6 +170,8 @@ export interface TaskTrack {
   userChoice?: TrackPath;
   /** The engine keeps the plan (fast track): each delegation adds its step. */
   autoPlan?: boolean;
+  /** Members who sat out the planning panel that agreed the plan: they do not work on the task (no QA gate without QA) unless the user lets one join. */
+  satOut?: TrackMember[];
   at: string;
 }
 
@@ -227,6 +257,8 @@ export interface Task {
   git?: TaskGit;
   /** The lint gate's last report on the files this task's agents touched. */
   lint?: LintReport;
+  /** The last read of what the built change warrants of QA, taken as the QA gate starts. */
+  qaRisk?: QaRiskAssessment;
   /** Set only by the user: the work is accepted with the lint errors it has, so the task may complete. */
   lintWaiver?: { at: string };
 }

package/src/state/backlog.ts

@@ -11,6 +11,7 @@ import { writeFileEnsured } from "../knowledge/store.ts";
 import { forgetCachedUnder, readJsonCached } from "./file-cache.ts";
 import { dataRoot } from "./project.ts";
 import { taskSlug } from "./persistence.ts";
+import type { PanelMember } from "../schemas/configuration.ts";
 
 export interface IssueRef {
   number: number;
@@ -44,6 +45,8 @@ export interface PlannedTask {
   startedTaskId?: string;
   /** Set when the plan was split into several tasks and this is one of them. */
   split?: SplitInfo;
+  /** The panel seats that took part in planning it (sat a round and were not unseated); absent on plans saved before this was kept. */
+  panel?: PanelMember[];
 }
 
 export function backlogDir(root: string, configDir: string): string {
@@ -63,7 +66,7 @@ function isPlannedTask(value: unknown): value is PlannedTask {
 export function savePlannedTask(
   root: string,
   configDir: string,
-  input: { title: string; brief: string; issue?: IssueRef; split?: SplitInfo },
+  input: { title: string; brief: string; issue?: IssueRef; split?: SplitInfo; panel?: readonly PanelMember[] },
   now = new Date(),
 ): PlannedTask {
   const title = input.title.trim() || "planned task";
@@ -73,7 +76,7 @@ export function savePlannedTask(
   let id = base;
   for (let n = 2; existsSync(entryPath(root, configDir, id)); n++) id = `${base}-${n}`;
   const at = now.toISOString();
-  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}), ...(input.split ? { split: input.split } : {}) };
+  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}), ...(input.split ? { split: input.split } : {}), ...(input.panel ? { panel: [...input.panel] } : {}) };
   writeFileEnsured(entryPath(root, configDir, id), JSON.stringify(entry, null, 2));
   return entry;
 }
@@ -131,9 +134,22 @@ export function splitLine(split: SplitInfo): string {
   return `This is part ${split.part} of ${split.of} of one plan that was split into separate tasks: ${others}.${before} Do only this part; the others are their own tasks.`;
 }
 
+/** Where a planned task's request moves on from what it is to the plan itself. */
+const AGREED_PLAN = "\n\nAgreed plan (from the planning session):\n";
+
 /** The request a started task carries: the agreed plan, plus the issue it came from, plus where it sits in a split plan. */
 export function plannedTaskRequest(entry: PlannedTask): string {
   const source = entry.issue ? `\n\nFrom GitHub issue #${entry.issue.number}: ${entry.issue.title}${entry.issue.url ? ` (${entry.issue.url})` : ""}` : "";
   const part = entry.split ? `\n\n${splitLine(entry.split)}` : "";
-  return `${entry.title}${part}\n\nAgreed plan (from the planning session):\n${entry.brief}${source}`;
+  return `${entry.title}${part}${AGREED_PLAN}${entry.brief}${source}`;
+}
+
+/**
+ * A planned task's request without the plan in it (its title, and where it
+ * sits in a split plan), for prompts that carry the plan on its own: the plan
+ * is not sent twice. Any other request is returned whole.
+ */
+export function requestBesidePlan(request: string): string {
+  const at = request.indexOf(AGREED_PLAN);
+  return at < 0 ? request : `${request.slice(0, at)}\n\n(The agreed plan is the task's plan.)`;
 }

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 });
+}