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

package/src/webui/dev/fake-service.ts

@@ -12,6 +12,7 @@ import type { BackgroundSession, DialogAnswer, SessionDialog } from "../../lobby
 import type { PlanComment } from "../../state/comments.ts";
 import type { LobbyService } from "../../lobby/host.ts";
 import { loadScenario, type ScenarioFixture } from "./fixtures.ts";
+import type { PlanRecord, PlanSummary } from "../../state/plan-history.ts";
 
 interface StreamState {
   step?: ReturnType<typeof setTimeout>;
@@ -264,6 +265,7 @@ function fakeBackground(entry: NonNullable<ScenarioFixture["backgroundSessions"]
     },
     ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
     ...(entry.planId ? { planId: entry.planId } : {}),
+    ...(entry.taskId ? { taskId: entry.taskId } : {}),
     feed,
     dialogs,
     get alive() {
@@ -528,6 +530,24 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     },
     sendToTask: (taskId: string, _text: string) => (tasks.some((task) => (task as { id: string }).id === taskId) ? `sent — the session driving ${taskId} passes it to its oracle` : `no task ${taskId}`),
     sendToSession: (_sessionId: string, _text: string) => "sent — that session passes it to its oracle within a few seconds",
+    resumeTask: async (taskId: string) => {
+      const task = tasks.find((entry) => (entry as { id: string }).id === taskId) as { id: string; title: string; paused?: boolean; ownerSessionId?: string } | undefined;
+      if (!task) return { notice: `no task ${taskId}` };
+      const owner = task.ownerSessionId;
+      const background = backgrounds.find((session) => session.alive && ((owner && session.sessionId === owner) || session.taskId === taskId));
+      const elsewhere = Boolean(owner && (fixture.liveSessions ?? []).some((session) => session.sessionId === owner));
+      lobbyTopics.bump("tasks");
+      if (owner === fixture.status.sessionId || background || elsewhere) {
+        task.paused = false;
+        const where = background ? `in ${background.name}` : elsewhere ? "— the session driving it in another terminal carries on" : "in this window";
+        return { notice: `resumed ${taskId} ${where}`, ...(background ? { key: background.key } : {}) };
+      }
+      task.paused = false;
+      const session = fakeBackground({ key: `S${backgrounds.length + 1}`, name: task.title, status: "starting", taskId });
+      backgrounds.push(session);
+      lobbyTopics.bump("sessions");
+      return { notice: `resumed ${taskId} in a background session`, key: session.key };
+    },
     sessions: () => [...backgrounds],
     startSession: (start: { request?: string; plan?: { id: string; title: string }; auto?: boolean }) => {
       const key = `S${backgrounds.length + 1}`;
@@ -537,6 +557,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     },
     liveSessions: () => [...(fixture.liveSessions ?? [])],
     planner: () => planning,
+    ...previousPlansFake(fixture.mockPreviousPlans ?? []),
     newPlanner: (seed?: { issue: { number: number; title: string; url?: string }; body: string }, seats?: string[]) => {
       planning = fakePlanner({ ...defaultPlanner(), ...(seed ? { messages: [{ role: "you", text: seed.body, at: Date.now() }] } : {}), ...(seats ? { seats } : {}) });
       return planning;
@@ -571,3 +592,42 @@ export function disposeFixtureService(service: LobbyService): void {
   for (const id of opened.get(service) ?? []) promptHub.dismiss(id);
   opened.delete(service);
 }
+
+/** Previous plans held in memory: listed, read, archived, deleted and carried on as the page asks. */
+function previousPlansFake(seed: NonNullable<ScenarioFixture["mockPreviousPlans"]>) {
+  const records = seed.map((plan) => ({ ...plan }))
+  const find = (id: string) => {
+    const record = records.find((entry) => entry.id === id && !entry.savedAs?.length)
+    if (!record) throw new Error(`no plan ${id}`)
+    return record
+  }
+  const asRecord = (plan: (typeof records)[number]) => ({
+    id: plan.id,
+    title: plan.title,
+    createdAt: plan.createdAt,
+    updatedAt: plan.updatedAt,
+    ...(plan.archivedAt ? { archivedAt: plan.archivedAt } : {}),
+    snapshot: { version: 1, messages: plan.messages, ...(plan.draft ? { reply: { status: "grilling", questions: [], plan: plan.draft } } : {}), questions: [], notes: plan.notes ?? [], members: [], seats: ["backend", "designer", "qa", "researcher"], pins: [], satOut: [], lastStatus: [], sat: [], memberNotes: [], turns: plan.rounds ?? 1, mode: "normal", answered: [], lineComments: [], savedParts: [], autoContinued: false, attempts: 1, running: false },
+  }) as unknown as PlanRecord
+  return {
+    previousPlans: (archived: boolean): PlanSummary[] => records
+      .filter((plan) => !plan.savedAs?.length && Boolean(plan.archivedAt) === archived)
+      .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+      .map((plan) => ({ id: plan.id, title: plan.title, createdAt: plan.createdAt, updatedAt: plan.updatedAt, ...(plan.archivedAt ? { archivedAt: plan.archivedAt } : {}), messages: plan.messages.length, rounds: plan.rounds ?? 1, hasDraft: Boolean(plan.draft) })),
+    previousPlan: (id: string) => asRecord(find(id)),
+    archivePlan: (id: string, archived: boolean) => {
+      const plan = find(id)
+      if (archived) plan.archivedAt = new Date().toISOString()
+      else delete plan.archivedAt
+      lobbyTopics.bump("planner")
+      return archived ? `archived "${plan.title}" — show archived plans to bring it back` : `"${plan.title}" is back among the previous plans`
+    },
+    deletePlan: (id: string) => {
+      const plan = find(id)
+      records.splice(records.indexOf(plan), 1)
+      lobbyTopics.bump("planner")
+      return `deleted "${plan.title}" for good`
+    },
+    reopenPlan: (id: string) => `carrying on "${find(id).title}"`,
+  }
+}

package/src/webui/dev/fixtures.ts

@@ -75,9 +75,11 @@ export interface ScenarioFixture {
   /** Comments by task id for `tasks.comments`. */
   taskComments?: Record<string, Array<Record<string, unknown>>>;
   /** Background sessions for `sessions.list` (plain data, made live below). */
-  backgroundSessions?: Array<{ key: string; name: string; status: string; sessionId?: string; planId?: string; dialogs?: Array<Record<string, unknown>> }>;
+  backgroundSessions?: Array<{ key: string; name: string; status: string; sessionId?: string; planId?: string; taskId?: string; dialogs?: Array<Record<string, unknown>> }>;
   /** Live sessions in other terminals for `sessions.list`. */
   liveSessions?: Array<{ sessionId: string; pid: number; name?: string; taskId?: string; mode: string }>;
+  /** Previous plans (planning sessions never saved as a task) for `planner.previous*`. */
+  mockPreviousPlans?: Array<{ id: string; title: string; createdAt: string; updatedAt: string; archivedAt?: string; savedAs?: string[]; draft?: string; rounds?: number; messages: Array<Record<string, unknown>>; notes?: Array<Record<string, unknown>> }>;
   /** The planning session for the `planner.*` calls (absent means none started). */
   mockPlanner?: {
     seats: string[];
@@ -164,6 +166,7 @@ export function loadScenario(name: string | undefined): ScenarioFixture {
     autoTasks: Array.isArray(parsed.autoTasks) ? (parsed.autoTasks as string[]) : [],
     backgroundSessions: Array.isArray(parsed.backgroundSessions) ? (parsed.backgroundSessions as ScenarioFixture["backgroundSessions"]) : [],
     liveSessions: Array.isArray(parsed.liveSessions) ? (parsed.liveSessions as ScenarioFixture["liveSessions"]) : [],
+    mockPreviousPlans: Array.isArray(parsed.mockPreviousPlans) ? (parsed.mockPreviousPlans as ScenarioFixture["mockPreviousPlans"]) : [],
     mockPlanner: isRecord(parsed.mockPlanner) ? (parsed.mockPlanner as unknown as ScenarioFixture["mockPlanner"]) : undefined,
     mockQuickfix: Array.isArray(parsed.mockQuickfix) ? (parsed.mockQuickfix as ScenarioFixture["mockQuickfix"]) : [],
     mockMetrics: Array.isArray(parsed.mockMetrics) ? (parsed.mockMetrics as ScenarioFixture["mockMetrics"]) : [],

package/src/webui/palette-core.ts

@@ -0,0 +1,260 @@
+/**
+ * Colour themes, as plain data and pure functions (no DOM, so they can be
+ * unit-tested). A theme is two maps of shadcn variables, one for light and one
+ * for dark: exactly what tweakcn exports. A few themes come with the page; the
+ * user can paste or upload another from tweakcn (its `:root { … } .dark { … }`
+ * CSS, or its registry JSON).
+ *
+ * An imported file is never injected as it is. Only variables from an allow
+ * list are kept, and a value is kept only when it is made of colour, length
+ * and font-name characters (no `url()`, no `;`, no braces), so a theme can
+ * recolour the page but cannot load anything or break out of its rule.
+ */
+
+export type Vars = Record<string, string>
+
+export interface Palette {
+  id: string
+  name: string
+  /** Overrides for the light page; absent means the page's own colours. */
+  light?: Vars
+  /** Overrides for the dark page. */
+  dark?: Vars
+}
+
+/** The variables a theme may set, as tweakcn names them. Radius and shadows are ignored: the page keeps one calm 8px corner. */
+const COLOUR_VARS = [
+  "background",
+  "foreground",
+  "card",
+  "card-foreground",
+  "popover",
+  "popover-foreground",
+  "primary",
+  "primary-foreground",
+  "secondary",
+  "secondary-foreground",
+  "muted",
+  "muted-foreground",
+  "accent",
+  "accent-foreground",
+  "destructive",
+  "border",
+  "input",
+  "ring",
+  "chart-1",
+  "chart-2",
+  "chart-3",
+  "chart-4",
+  "chart-5",
+] as const
+
+const FONT_VARS = ["font-sans", "font-mono"] as const
+
+const ALLOWED = new Set<string>([...COLOUR_VARS, ...FONT_VARS])
+
+/** What a colour or length may be made of. */
+const SAFE_VALUE = /^[\w\s#%.,()/+*'"-]{1,300}$/
+const BAD_VALUE = /url\s*\(|expression|import|javascript|\\|<|>/i
+
+export const MAX_THEME_BYTES = 200_000
+
+/** `oklch(0.6 0.2 250)`, `#fff`, `hsl(…)`, `var(--x)`, a font stack: kept; anything else: dropped. */
+export function safeValue(raw: string): string | undefined {
+  const value = raw.replace(/!important/gi, "").trim()
+  if (!value || !SAFE_VALUE.test(value) || BAD_VALUE.test(value)) return undefined
+  return value
+}
+
+function keep(name: string, raw: string, into: Vars): void {
+  const key = name.replace(/^--/, "").toLowerCase()
+  if (!ALLOWED.has(key)) return
+  const value = safeValue(raw)
+  if (value) into[key] = value
+}
+
+function declarations(block: string): Vars {
+  const found: Vars = {}
+  for (const match of block.matchAll(/--([a-z0-9-]+)\s*:\s*([^;}]+)/gi)) keep(match[1]!, match[2]!, found)
+  return found
+}
+
+/** A stored theme read back with the same filter as an import (the store is the user's to edit). */
+export function cleanVars(map: unknown): Vars | undefined {
+  if (!map || typeof map !== "object") return undefined
+  const out: Vars = {}
+  for (const [key, value] of Object.entries(map as Record<string, unknown>)) if (typeof value === "string") keep(key, value, out)
+  return Object.keys(out).length > 0 ? out : undefined
+}
+
+export interface Parsed {
+  light?: Vars
+  dark?: Vars
+  name?: string
+}
+
+/** A theme from tweakcn's CSS (`:root {…} .dark {…}`) or its registry JSON (`{ "cssVars": { "light": {…}, "dark": {…} } }`). */
+export function parseTheme(source: string): Parsed | { error: string } {
+  const text = source.trim()
+  if (!text) return { error: "Paste a theme first." }
+  if (text.length > MAX_THEME_BYTES) return { error: "That file is too large to be a theme." }
+  let light: Vars = {}
+  let dark: Vars = {}
+  let name: string | undefined
+  if (text.startsWith("{")) {
+    let json: unknown
+    try {
+      json = JSON.parse(text)
+    } catch {
+      return { error: "That is not valid JSON or CSS." }
+    }
+    const record = json as { name?: unknown; title?: unknown; cssVars?: { theme?: Record<string, unknown>; light?: Record<string, unknown>; dark?: Record<string, unknown> } }
+    const vars = record.cssVars
+    if (!vars || typeof vars !== "object") return { error: "That JSON has no cssVars. Copy the theme's CSS from tweakcn instead." }
+    const read = (map: Record<string, unknown> | undefined): Vars => {
+      const out: Vars = {}
+      for (const [key, value] of Object.entries(map ?? {})) if (typeof value === "string") keep(key, value, out)
+      return out
+    }
+    light = { ...read(vars.theme), ...read(vars.light) }
+    dark = { ...read(vars.theme), ...read(vars.dark) }
+    name = typeof record.title === "string" ? record.title : typeof record.name === "string" ? record.name : undefined
+  } else {
+    // Only the plain `:root` and `.dark` rules; `@theme inline` and the rest are the page's own business.
+    for (const match of text.matchAll(/(?<=^|[}\s])((?::root|html|\.dark|:root\.dark|html\.dark)(?:\s*,\s*[^{]+)?)\s*\{([^}]*)\}/g)) {
+      const selector = match[1]!.trim()
+      const vars = declarations(match[2]!)
+      if (/\.dark/.test(selector)) dark = { ...dark, ...vars }
+      else light = { ...light, ...vars }
+    }
+  }
+  const count = (vars: Vars) => Object.keys(vars).filter((key) => (COLOUR_VARS as readonly string[]).includes(key)).length
+  if (count(light) < 5 && count(dark) < 5) return { error: "No theme colours found. Copy the code from tweakcn's Code panel (the :root and .dark blocks)." }
+  return {
+    ...(count(light) >= 5 ? { light } : {}),
+    ...(count(dark) >= 5 ? { dark } : {}),
+    ...(name ? { name } : {}),
+  }
+}
+
+/** Page variables a theme does not name are worked out from the ones it does, so a theme from tweakcn is whole. */
+const DERIVED: Vars = {
+  "glass-border": "var(--border)",
+  typing: "var(--ring)",
+  "tab-active": "color-mix(in oklab, var(--primary) 14%, var(--background))",
+  you: "color-mix(in oklab, var(--primary) 9%, var(--card))",
+  heading: "var(--foreground)",
+  link: "var(--primary)",
+  bullet: "var(--primary)",
+}
+
+const SANS_FALLBACK = `"Inter Variable", ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif`
+const MONO_FALLBACK = `ui-monospace, "JetBrains Mono", "Cascadia Mono", "SF Mono", Menlo, Consolas, "DejaVu Sans Mono", monospace`
+
+function rule(selector: string, vars: Vars): string {
+  const lines: string[] = []
+  for (const [key, value] of Object.entries(vars)) {
+    if (key === "font-sans") lines.push(`--app-font-sans:${value},${SANS_FALLBACK};`)
+    else if (key === "font-mono") lines.push(`--app-font-mono:${value},${MONO_FALLBACK};`)
+    else lines.push(`--${key}:${value};`)
+  }
+  for (const [key, value] of Object.entries(DERIVED)) if (!(key in vars)) lines.push(`--${key}:${value};`)
+  return `${selector}{${lines.join("")}}`
+}
+
+/** The style sheet for a theme, or `""` for the page's own colours. */
+export function paletteCss(palette: Palette): string {
+  const parts: string[] = []
+  if (palette.light) parts.push(rule(":root", palette.light))
+  if (palette.dark) parts.push(rule(".dark", palette.dark))
+  return parts.join("\n")
+}
+
+/** A palette from one hue, in oklch: a tinted mist and a tinted near-black, the hue as the accent. Chroma 0 is a neutral theme. */
+function tinted(id: string, name: string, hue: number, chroma: number, lift = 0): Palette {
+  const h = hue
+  const c = chroma
+  const n = (value: number) => Number(value.toFixed(3))
+  const light: Vars = {
+    background: `oklch(0.975 ${n(c * 0.1)} ${h})`,
+    foreground: `oklch(0.22 ${n(c * 0.25)} ${h})`,
+    card: "oklch(1 0 0)",
+    "card-foreground": `oklch(0.22 ${n(c * 0.25)} ${h})`,
+    popover: "oklch(1 0 0 / 0.92)",
+    "popover-foreground": `oklch(0.22 ${n(c * 0.25)} ${h})`,
+    primary: `oklch(${n(0.5 + lift)} ${c} ${h})`,
+    "primary-foreground": "oklch(0.99 0 0)",
+    secondary: `oklch(0.3 ${n(c * 0.3)} ${h} / 0.06)`,
+    "secondary-foreground": `oklch(0.22 ${n(c * 0.25)} ${h})`,
+    muted: `oklch(0.3 ${n(c * 0.3)} ${h} / 0.05)`,
+    "muted-foreground": `oklch(0.5 ${n(c * 0.2)} ${h})`,
+    accent: `oklch(${n(0.5 + lift)} ${c} ${h} / 0.1)`,
+    "accent-foreground": `oklch(0.22 ${n(c * 0.25)} ${h})`,
+    destructive: "oklch(0.52 0.19 28)",
+    border: `oklch(0.92 ${n(c * 0.08)} ${h})`,
+    input: `oklch(0.87 ${n(c * 0.1)} ${h})`,
+    ring: `oklch(${n(0.6 + lift)} ${n(c * 0.9)} ${h})`,
+    "chart-1": `oklch(${n(0.5 + lift)} ${c} ${h})`,
+    "chart-2": "oklch(0.52 0.12 160)",
+    "chart-3": "oklch(0.55 0.1 200)",
+    "chart-4": "oklch(0.55 0.15 340)",
+    "chart-5": "oklch(0.6 0.13 75)",
+  }
+  const dark: Vars = {
+    background: `oklch(0.145 ${n(c * 0.08)} ${h})`,
+    foreground: `oklch(0.93 ${n(c * 0.05)} ${h})`,
+    card: `oklch(0.18 ${n(c * 0.09)} ${h})`,
+    "card-foreground": `oklch(0.93 ${n(c * 0.05)} ${h})`,
+    popover: `oklch(0.18 ${n(c * 0.09)} ${h} / 0.94)`,
+    "popover-foreground": `oklch(0.93 ${n(c * 0.05)} ${h})`,
+    primary: `oklch(${n(0.76 + lift / 2)} ${n(c * 0.85)} ${h})`,
+    "primary-foreground": `oklch(0.18 ${n(c * 0.4)} ${h})`,
+    secondary: "oklch(1 0 0 / 0.045)",
+    "secondary-foreground": `oklch(0.93 ${n(c * 0.05)} ${h})`,
+    muted: "oklch(1 0 0 / 0.04)",
+    "muted-foreground": `oklch(0.7 ${n(c * 0.15)} ${h})`,
+    accent: `oklch(0.76 ${n(c * 0.85)} ${h} / 0.14)`,
+    "accent-foreground": `oklch(0.93 ${n(c * 0.05)} ${h})`,
+    destructive: "oklch(0.74 0.12 25)",
+    border: `oklch(0.25 ${n(c * 0.1)} ${h})`,
+    input: `oklch(0.3 ${n(c * 0.1)} ${h})`,
+    ring: `oklch(${n(0.76 + lift / 2)} ${n(c * 0.85)} ${h})`,
+    "chart-1": `oklch(${n(0.76 + lift / 2)} ${n(c * 0.85)} ${h})`,
+    "chart-2": "oklch(0.78 0.11 160)",
+    "chart-3": "oklch(0.8 0.1 195)",
+    "chart-4": "oklch(0.78 0.11 340)",
+    "chart-5": "oklch(0.8 0.12 80)",
+  }
+  return { id, name, light, dark }
+}
+
+export const DEFAULT_ID = "mist"
+
+/** The themes that come with the page; Mist is the page's own colours and sets nothing. */
+export const PRESETS: readonly Palette[] = [
+  { id: DEFAULT_ID, name: "Mist" },
+  tinted("forest", "Forest", 155, 0.12),
+  tinted("ocean", "Ocean", 225, 0.12),
+  tinted("violet", "Violet", 305, 0.16),
+  tinted("rose", "Rose", 5, 0.16),
+  tinted("amber", "Amber", 70, 0.14, 0.06),
+  tinted("mono", "Mono", 260, 0),
+]
+
+/** Colours for a preview swatch, per mode: Mist's own values by hand, the rest from the theme. */
+const MIST_SWATCH = {
+  light: { background: "#f4f5f9", card: "#ffffff", primary: "#4650d1", accent: "#e6e9fb" },
+  dark: { background: "#08090c", card: "#0e1015", primary: "#8f9bff", accent: "#151a33" },
+} as const
+
+export function swatch(palette: Palette, dark: boolean): { background: string; card: string; primary: string; accent: string } {
+  const vars = dark ? palette.dark : palette.light
+  const base = MIST_SWATCH[dark ? "dark" : "light"]
+  if (!vars) return { ...base }
+  return {
+    background: vars.background ?? base.background,
+    card: vars.card ?? base.card,
+    primary: vars.primary ?? base.primary,
+    accent: vars.primary ? `color-mix(in oklab, ${vars.primary} 18%, ${vars.background ?? base.background})` : base.accent,
+  }
+}

package/src/webui/protocol.ts

@@ -12,6 +12,7 @@ import type { LiveSession } from "../lobby/host.ts";
 import type { TaskRow } from "../lobby/task-rows.ts";
 import type { PlanComment } from "../state/comments.ts";
 import type { BotLobbyConfig, PanelMember } from "../schemas/configuration.ts";
+import type { QaRiskAssessment } from "../schemas/task.ts";
 import type { MemberState, PanelNote, PanelQuestion, PlannerMessage } from "../lobby/planner.ts";
 import type { QuickFixJob } from "../lobby/quickfix.ts";
 
@@ -80,6 +81,21 @@ export interface KeyInfo {
 }
 
 /** `status.get`: everything the page shell needs before it reads a tab. */
+/** A colour theme the user saved, kept for every pi session (`themes.json`). */
+export interface SavedThemeInfo {
+  id: string;
+  name: string;
+  light?: Record<string, string>;
+  dark?: Record<string, string>;
+  savedAt: string;
+}
+
+/** The saved themes and the chosen one. */
+export interface ThemeStoreInfo {
+  themes: SavedThemeInfo[];
+  active?: string;
+}
+
 export interface StatusInfo {
   workspace: { name: string; branch?: string };
   branch?: string;
@@ -93,6 +109,8 @@ export interface StatusInfo {
   tabs: TabInfo[];
   keys: KeyInfo[];
   windows: Array<{ name: string; url: string }>;
+  /** What this window carried on after pi stopped unexpectedly: the page says so once. */
+  recovered?: { at: number; text: string };
 }
 
 /** Agent work time as of the reply: the page adds the time that passes while `running`. */
@@ -215,6 +233,34 @@ export interface PlannerSnapshot {
   busy: boolean;
 }
 
+/** A previous plan as a list shows it: a planning session never saved as a task. */
+export interface PreviousPlanInfo {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  archivedAt?: string;
+  messages: number;
+  rounds: number;
+  hasDraft: boolean;
+}
+
+/** A previous plan, whole, to read. */
+export interface PreviousPlanDetail {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  archivedAt?: string;
+  rounds: number;
+  seats: PanelMember[];
+  messages: PlannerMessage[];
+  draft?: string;
+  notes: PanelNote[];
+  /** Where it started, when it came from an issue. */
+  seed?: string;
+}
+
 /** One issue a planning session can start from. */
 export interface PlannerSeedInfo {
   issue: { number: number; title: string; url?: string };
@@ -381,6 +427,8 @@ export interface TaskDetail {
   blockers: Array<{ reason: string; need: string }>;
   /** The last six runs, one line each (`✓ DEV worker · 3m 12s · …`). */
   runs: string[];
+  /** Jev's last read of what the built change warrants of QA: level, test budget, focus and evidence. */
+  qaRisk?: QaRiskAssessment;
 }
 
 /** `plans.get`: one saved plan. */
@@ -549,6 +597,7 @@ export interface Api {
   "tasks.message": { request: { taskId: string; text: string; attachments?: string[] }; result: { notice: string } };
   "tasks.get": { request: { taskId: string }; result: TaskDetail };
   "tasks.open": { request: { taskId: string }; result: { sessionId?: string; key?: string; notice?: string } };
+  "tasks.resume": { request: { taskId: string }; result: { notice: string; key?: string } };
   "tasks.deliveryReview": { request: { taskId: string }; result: { delivery: Delivery } };
   "tasks.deliveryDefer": { request: { taskId: string; reviewId: string }; result: { delivery: Delivery } };
   "tasks.deliver": { request: { taskId: string; reviewId: string; action: DeliveryAction; confirmMain?: boolean }; result: { delivery: Delivery } };
@@ -573,6 +622,11 @@ export interface Api {
   "planner.retry": { request: Record<string, never>; result: { notice: string } };
   "planner.commentLine": { request: { line: string; text: string }; result: { notice: string } };
   "planner.answer": { request: Record<string, never>; result: { notice: string } };
+  "planner.previous": { request: { archived?: boolean }; result: { plans: PreviousPlanInfo[] } };
+  "planner.previousGet": { request: { id: string }; result: PreviousPlanDetail };
+  "planner.previousArchive": { request: { id: string; archived: boolean }; result: { notice: string } };
+  "planner.previousDelete": { request: { id: string }; result: { notice: string } };
+  "planner.previousOpen": { request: { id: string }; result: { notice: string } };
   "planner.save": { request: Record<string, never>; result: { notice: string } };
   "quickfix.list": { request: Record<string, never>; result: { jobs: QuickFixJob[] } };
   "quickfix.submit": { request: { text: string; attachments?: string[] }; result: { notice: string; id: string } };
@@ -609,6 +663,11 @@ export interface Api {
   "settings.get": { request: Record<string, never>; result: SettingsInfo };
   "settings.set": { request: { patch: Record<string, unknown> }; result: { config: BotLobbyConfig } };
   "settings.linters": { request: Record<string, never>; result: { linters: SettingsLinter[] } };
+  "themes.get": { request: Record<string, never>; result: ThemeStoreInfo };
+  "themes.save": { request: { name: string; light?: Record<string, string>; dark?: Record<string, string> }; result: ThemeStoreInfo & { id: string } };
+  "themes.rename": { request: { id: string; name: string }; result: ThemeStoreInfo };
+  "themes.remove": { request: { id: string }; result: ThemeStoreInfo };
+  "themes.choose": { request: { id: string }; result: ThemeStoreInfo };
 }
 
 export type ApiName = keyof Api;

package/src/webui/server.ts

@@ -31,6 +31,14 @@ import { EventHub } from "./events.ts";
 import { servePreview } from "./files.ts";
 import { MAX_UPLOAD_BYTES, saveUpload } from "./uploads.ts";
 
+/** What a call made while pi switches sessions is told; the page reads again once the new session is up. */
+export const SWITCHING = "pi is switching sessions — the page catches up in a moment";
+
+/** pi's refusal of a context from a session it has replaced or reloaded. */
+export function staleSession(error: unknown): boolean {
+  return /ctx is stale after session replacement or reload/i.test((error as Error)?.message ?? "");
+}
+
 /** The default port; the server tries it, then the next free port up to +20. */
 export const DEFAULT_PORT = 7347;
 /** How many ports past the base are tried. */
@@ -320,6 +328,8 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
         return;
       }
       if (error instanceof HttpError) sendError(res, error.code, error.message, error.status);
+      // Between pi replacing the session and the lobby following it, the old session answers nothing.
+      else if (staleSession(error)) sendError(res, "failed", SWITCHING, 503);
       else {
         lobbyFeed.log("LOBBY", `the web server could not do that — ${error.message}`, "error");
         sendError(res, "failed", "the lobby could not do that", 500);

package/src/workflow/track.ts

@@ -276,6 +276,8 @@ export interface TrackOptions {
   forced?: TrackPath;
   /** The task follows a plan agreed in the planning panel. */
   approvedPlan?: boolean;
+  /** That panel's seats that took part; QA not among them sat the plan out, and the task runs without it. Absent: not known (an older plan). */
+  planPanel?: readonly string[];
 }
 
 /**
@@ -311,8 +313,10 @@ export function chooseTrack(request: string, triage: TaskTriage | undefined, opt
       : !options.fastTrack
         ? ["full", ["the fast track is off in settings"], source]
         : [fast ? "fast" : "full", [], source];
-  // The full workflow always ends with the QA gate.
-  if (path === "full") roster.add("qa");
+  // An agreed plan's panel decides who works on it; otherwise the full workflow always ends with the QA gate.
+  const panel = options.approvedPlan ? options.planPanel : undefined;
+  const benched = panel ? seatPlanPanel(roster, panel, why) : [];
+  if (!panel && path === "full") roster.add("qa");
   return {
     path,
     size,
@@ -320,10 +324,36 @@ export function chooseTrack(request: string, triage: TaskTriage | undefined, opt
     reasons: [...why, ...reasons],
     source: by,
     ...(options.forced ? { userChoice: options.forced } : {}),
+    ...(benched.length > 0 ? { satOut: benched } : {}),
     at: now,
   };
 }
 
+const BUILDERS: readonly TrackMember[] = ["designer", "backend"];
+
+/**
+ * The roster of a task from an agreed plan: exactly the members who took part
+ * in the panel. One who sat it out (the classifier left it out, or the user
+ * unseated it) does not work on the task, and without QA there is no QA gate.
+ * When no builder sat (the oracle planned alone), the request's reading picks
+ * who builds. Returns who sat out, and says why in `why`.
+ */
+function seatPlanPanel(roster: Set<TrackMember>, panel: readonly string[], why: string[]): TrackMember[] {
+  const sat = parseRoster(panel.filter((member) => MEMBER_ALIASES[member]));
+  const builders = sat.some((member) => BUILDERS.includes(member)) ? [] : [...roster].filter((member) => BUILDERS.includes(member));
+  const kept = new Set([...sat, ...builders]);
+  roster.clear();
+  for (const member of TRACK_MEMBERS) if (kept.has(member)) roster.add(member);
+  const out = TRACK_MEMBERS.filter((member) => !kept.has(member));
+  why.push(`the planning panel decides who works on it${out.length > 0 ? `; sat out: ${rosterWords(out)}` : ""}${builders.length > 0 ? `; no builder sat, so the request picks ${rosterWords(builders)}` : ""}`);
+  return out;
+}
+
+/** A member who sat out the planning panel of the task's plan and was not let back in: it does not work on the task. */
+export function satOut(task: Task, member: TrackMember): boolean {
+  return Boolean(task.track?.satOut?.includes(member));
+}
+
 /* ------------------------------------------------------------ quick fix or task */
 
 /** Where a new request goes before any task exists: one agent now (the lobby's quick fix), or the team. */
@@ -380,9 +410,14 @@ export function onFastTrack(task: Task): boolean {
   return task.track?.path === "fast";
 }
 
-/** Whether QA must take part before the task completes: always on the full workflow, on the fast track when the change needs tests. */
+/**
+ * Whether QA must take part before the task completes: when it is on the
+ * roster, and always on the full workflow, except for a plan QA sat out in the
+ * planning panel (the user's call).
+ */
 export function qaRequired(task: Task): boolean {
-  return !onFastTrack(task) || Boolean(task.track?.roster.includes("qa"));
+  if (task.track?.roster.includes("qa")) return true;
+  return !onFastTrack(task) && !satOut(task, "qa");
 }
 
 function finishedAt(run: { startedAt: string; finishedAt?: string }): number {
@@ -427,7 +462,8 @@ export function rosterWords(roster: readonly TrackMember[]): string {
 /** The track in one line, for the oracle's context and `/bot-lobby status`. */
 export function trackSummary(track: TaskTrack): string {
   const path = track.path === "fast" ? "fast track" : "full workflow";
-  return `Track: ${path} (${track.size}; set by ${track.source}) · who takes part: ${rosterWords(track.roster)} · why: ${track.reasons.join("; ")}`;
+  const out = track.satOut?.length ? ` · sat out the plan, so not working on it: ${rosterWords(track.satOut)}` : "";
+  return `Track: ${path} (${track.size}; set by ${track.source}) · who takes part: ${rosterWords(track.roster)}${out} · why: ${track.reasons.join("; ")}`;
 }
 
 /** A short line for the activity log. */
@@ -436,9 +472,12 @@ export function trackLine(track: TaskTrack): string {
   return `track: ${track.path} · ${track.size} · ${members || "domain to pick"} · ${track.source}`;
 }
 
+/** What the oracle does next on a planned task QA sat out, once a worker has reported. */
+export const PLANNED_NEXT = "Next: check `git diff --stat` and this report, then delegate the plan's next step. Once every step is done, call action=complete: QA sat out the planning panel, so there is no QA gate.";
+
 /** What the oracle does next on the fast track, once a worker has reported. */
 export function fastNext(task: Task): string {
-  if (!qaRequired(task)) return "Next (fast track): check `git diff --stat` and this report; if the work is in, call action=complete. No QA gate on this track: nothing here needs tests.";
+  if (!qaRequired(task)) return "Next (fast track): check `git diff --stat` and this report; if the work is in, call action=complete. No QA gate on this track: nothing here needs tests (Jev reads the change at completion, and QA joins one that turns out riskier).";
   if (qaTookPart(task)) return "Next (fast track): QA has taken part (its step came last). Check `git diff --stat`, then call action=complete.";
-  return "Next (fast track): check `git diff --stat`. QA takes part before completion: give qa the tests as the last step (action=implement domain=qa), or run action=qa; then call action=complete.";
+  return "Next (fast track): check `git diff --stat`. QA takes part before completion: run action=qa (Jev sizes it to the change; one with nothing that runs passes on the engine's checks); then call action=complete.";
 }