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

package/src/state/recovery.ts

@@ -0,0 +1,170 @@
+/**
+ * What a lobby window is doing, kept on disk so the next pi process can carry
+ * on after a crash or an unexpected stop (a closed terminal, a kill).
+ *
+ * Each window running the lobby keeps one record: the pi session it runs, the
+ * background sessions it drives, and whether each was in the middle of a turn.
+ * A window that quits on purpose removes it; one that stops any other way
+ * leaves it behind, and the next window to start in the project takes it over
+ * (`claimStoppedWindows`). Each session's planning panel and quick-fix queue
+ * are kept beside it, by session, so they carry on as well.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { dataRoot } from "./project.ts";
+import { processAlive } from "./presence.ts";
+
+/** A background session a window drives, as the next window relaunches it. */
+export interface BackgroundRecord {
+  sessionId: string;
+  sessionFile: string;
+  name: string;
+  /** Its oracle was in the middle of a turn (or waiting on a question). */
+  working: boolean;
+}
+
+export interface WindowRecord {
+  pid: number;
+  /** Tells this process's record from a dead one that had the same pid. */
+  token: string;
+  /** The pi session the window runs. */
+  sessionId: string;
+  sessionFile?: string;
+  /** The window's oracle was in the middle of a turn. */
+  working: boolean;
+  background: BackgroundRecord[];
+  startedAt: string;
+  updatedAt: string;
+}
+
+/** What each kept session state holds. */
+export type SessionStateKind = "planner" | "quickfix";
+
+/** This process's token: written into its record, so a later process with the same pid is not mistaken for it. */
+const TOKEN = randomBytes(8).toString("hex");
+
+export function recoveryDir(root: string, configDir: string): string {
+  return join(dataRoot(root, configDir), "lobby");
+}
+
+function windowsDir(root: string, configDir: string): string {
+  return join(recoveryDir(root, configDir), "windows");
+}
+
+/** Session ids become file names: keep them to safe characters. */
+function safe(id: string): string | undefined {
+  return /^[\w.-]+$/.test(id) ? id : undefined;
+}
+
+/** Write through a temp file and a rename, so a crash mid-write never leaves half a file. */
+function writeAtomic(path: string, value: unknown): void {
+  mkdirSync(join(path, ".."), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value), "utf8");
+  renameSync(tmp, path);
+}
+
+function readJson(path: string): unknown {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function windowPath(root: string, configDir: string, pid = process.pid, token = TOKEN): string {
+  return join(windowsDir(root, configDir), `${pid}-${token}.json`);
+}
+
+/** Record (or refresh) what this window runs. */
+export function writeWindow(root: string, configDir: string, record: Omit<WindowRecord, "pid" | "token" | "updatedAt" | "startedAt"> & { startedAt?: string }, now = new Date()): void {
+  writeAtomic(windowPath(root, configDir), { pid: process.pid, token: TOKEN, startedAt: record.startedAt ?? now.toISOString(), ...record, updatedAt: now.toISOString() });
+}
+
+/** This window quit on purpose: nothing of it is left to carry on. */
+export function removeWindow(root: string, configDir: string): void {
+  rmSync(windowPath(root, configDir), { force: true });
+}
+
+function isWindowRecord(value: unknown): value is WindowRecord {
+  const record = value as WindowRecord;
+  return Boolean(record) && typeof record.pid === "number" && typeof record.token === "string" && typeof record.sessionId === "string" && Array.isArray(record.background);
+}
+
+/** Whether a record belongs to a process that is gone: another pid that is not running, or this pid from before. */
+export function windowStopped(record: Pick<WindowRecord, "pid" | "token">, alive: (pid: number) => boolean = processAlive): boolean {
+  if (record.pid === process.pid) return record.token !== TOKEN;
+  return !alive(record.pid);
+}
+
+/** Windows in this project that stopped without quitting, newest first, unclaimed. */
+export function stoppedWindows(root: string, configDir: string, alive: (pid: number) => boolean = processAlive): WindowRecord[] {
+  const dir = windowsDir(root, configDir);
+  if (!existsSync(dir)) return [];
+  const found: WindowRecord[] = [];
+  for (const file of readdirSync(dir)) {
+    if (!/^\d+-[a-f0-9]+\.json$/.test(file)) continue;
+    const record = readJson(join(dir, file));
+    if (!isWindowRecord(record)) {
+      rmSync(join(dir, file), { force: true });
+      continue;
+    }
+    if (windowStopped(record, alive)) found.push(record);
+  }
+  return found.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+/**
+ * Take over the windows that stopped without quitting: each record is moved
+ * out of the way first, so two windows starting at once never both carry on
+ * the same work. Returns the records this process took.
+ */
+export function claimStoppedWindows(root: string, configDir: string, alive: (pid: number) => boolean = processAlive): WindowRecord[] {
+  const claimed: WindowRecord[] = [];
+  for (const record of stoppedWindows(root, configDir, alive)) {
+    const path = windowPath(root, configDir, record.pid, record.token);
+    try {
+      renameSync(path, `${path}.claimed-${process.pid}`);
+    } catch {
+      continue;
+    }
+    rmSync(`${path}.claimed-${process.pid}`, { force: true });
+    claimed.push(record);
+  }
+  return claimed;
+}
+
+function statePath(root: string, configDir: string, kind: SessionStateKind, sessionId: string): string | undefined {
+  const id = safe(sessionId);
+  return id ? join(recoveryDir(root, configDir), `${kind}-${id}.json`) : undefined;
+}
+
+/** A session's kept planning panel or quick-fix queue, or undefined. */
+export function readSessionState(root: string, configDir: string, kind: SessionStateKind, sessionId: string): unknown {
+  const path = statePath(root, configDir, kind, sessionId);
+  return path && existsSync(path) ? readJson(path) : undefined;
+}
+
+export function writeSessionState(root: string, configDir: string, kind: SessionStateKind, sessionId: string, value: unknown): void {
+  const path = statePath(root, configDir, kind, sessionId);
+  if (path) writeAtomic(path, value);
+}
+
+export function removeSessionState(root: string, configDir: string, kind: SessionStateKind, sessionId: string): void {
+  const path = statePath(root, configDir, kind, sessionId);
+  if (path) rmSync(path, { force: true });
+}
+
+/** Hand a stopped session's kept state to the session carrying it on. */
+export function moveSessionState(root: string, configDir: string, kind: SessionStateKind, from: string, to: string): boolean {
+  const source = statePath(root, configDir, kind, from);
+  const target = statePath(root, configDir, kind, to);
+  if (!source || !target || source === target || !existsSync(source)) return false;
+  try {
+    renameSync(source, target);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/state/themes.ts

@@ -0,0 +1,127 @@
+/**
+ * The colour themes the user saved, and which theme is chosen, kept in the
+ * user-global config folder (`themes.json` beside `config.json`): every pi
+ * session and every project's lobby page reads the same list, whatever port
+ * or folder it runs from. A theme is checked on the way in and on the way out
+ * with the same filter as an import, so the file can only ever recolour the
+ * page.
+ */
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { globalConfigDir } from "./project.ts";
+import { cleanVars, PRESETS, type Vars } from "../webui/palette-core.ts";
+
+export interface SavedTheme {
+  /** `saved-…`: never one of the page's own theme ids. */
+  id: string;
+  name: string;
+  light?: Vars;
+  dark?: Vars;
+  savedAt: string;
+}
+
+export interface ThemeStore {
+  themes: SavedTheme[];
+  /** The chosen theme: one of the page's own or a saved one; absent means the default. */
+  active?: string;
+}
+
+/** Saved themes kept; saving one more lets the oldest go. */
+export const MAX_SAVED_THEMES = 24;
+export const MAX_THEME_NAME = 40;
+const SAVED_ID = /^saved-[a-z0-9]{6,20}$/;
+
+export function themesPath(): string {
+  return join(globalConfigDir(), "themes.json");
+}
+
+/** A theme name as kept: one line, trimmed, at most 40 characters; empty is refused. */
+export function themeName(raw: string): string {
+  const name = raw.replace(/\s+/g, " ").trim().slice(0, MAX_THEME_NAME).trim();
+  if (!name) throw new Error("a theme needs a name");
+  return name;
+}
+
+function cleanTheme(value: unknown): SavedTheme | undefined {
+  const theme = value as Partial<SavedTheme> | undefined;
+  if (!theme || typeof theme.id !== "string" || !SAVED_ID.test(theme.id) || typeof theme.name !== "string") return undefined;
+  const light = cleanVars(theme.light);
+  const dark = cleanVars(theme.dark);
+  if (!light && !dark) return undefined;
+  let name: string;
+  try {
+    name = themeName(theme.name);
+  } catch {
+    return undefined;
+  }
+  return { id: theme.id, name, ...(light ? { light } : {}), ...(dark ? { dark } : {}), savedAt: typeof theme.savedAt === "string" ? theme.savedAt : new Date(0).toISOString() };
+}
+
+function knownId(store: ThemeStore, id: string): boolean {
+  return PRESETS.some((preset) => preset.id === id) || store.themes.some((theme) => theme.id === id);
+}
+
+/** The saved themes and the chosen one; a missing or torn file reads as none. */
+export function readThemes(): ThemeStore {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(readFileSync(themesPath(), "utf8"));
+  } catch {
+    return { themes: [] };
+  }
+  const value = raw as { themes?: unknown; active?: unknown };
+  const seen = new Set<string>();
+  const themes = (Array.isArray(value.themes) ? value.themes : []).map(cleanTheme).filter((theme): theme is SavedTheme => {
+    if (!theme || seen.has(theme.id)) return false;
+    seen.add(theme.id);
+    return true;
+  }).slice(-MAX_SAVED_THEMES);
+  const store: ThemeStore = { themes };
+  if (typeof value.active === "string" && knownId(store, value.active)) store.active = value.active;
+  return store;
+}
+
+function writeThemes(store: ThemeStore): ThemeStore {
+  const path = themesPath();
+  mkdirSync(globalConfigDir(), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+  renameSync(tmp, path);
+  return store;
+}
+
+/** Save a theme under a name and choose it; returns the saved theme. */
+export function saveTheme(input: { name: string; light?: unknown; dark?: unknown }, now = new Date()): SavedTheme {
+  const light = cleanVars(input.light);
+  const dark = cleanVars(input.dark);
+  if (!light && !dark) throw new Error("that theme sets no colours the page can use");
+  const theme: SavedTheme = { id: `saved-${randomBytes(6).toString("hex")}`, name: themeName(input.name), ...(light ? { light } : {}), ...(dark ? { dark } : {}), savedAt: now.toISOString() };
+  const store = readThemes();
+  writeThemes({ themes: [...store.themes, theme].slice(-MAX_SAVED_THEMES), active: theme.id });
+  return theme;
+}
+
+export function renameTheme(id: string, name: string): SavedTheme {
+  const store = readThemes();
+  const theme = store.themes.find((entry) => entry.id === id);
+  if (!theme) throw new Error("no such saved theme");
+  theme.name = themeName(name);
+  writeThemes(store);
+  return theme;
+}
+
+/** Remove a saved theme; the page's default comes back if it was the chosen one. */
+export function removeTheme(id: string): ThemeStore {
+  const store = readThemes();
+  if (!store.themes.some((theme) => theme.id === id)) throw new Error("no such saved theme");
+  const themes = store.themes.filter((theme) => theme.id !== id);
+  return writeThemes({ themes, ...(store.active && store.active !== id ? { active: store.active } : {}) });
+}
+
+/** Choose a theme for every page, in every session. */
+export function chooseTheme(id: string): ThemeStore {
+  const store = readThemes();
+  if (!knownId(store, id)) throw new Error("no such theme");
+  return writeThemes({ ...store, active: id });
+}

package/src/webui/api/index.ts

@@ -13,9 +13,9 @@ import type { LobbyService } from "../../lobby/host.ts";
 import { statusGet } from "./status.ts";
 import { lobbyAbort, lobbyHistory, lobbySend, lobbySnapshot } from "./lobby.ts";
 import { promptsAnswer, promptsDismiss, promptsList } from "./prompts.ts";
-import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave } from "./planner.ts";
+import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave, plannerPrevious, plannerPreviousArchive, plannerPreviousDelete, plannerPreviousGet, plannerPreviousOpen } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver } from "./tasks.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore, tasksOpen, tasksResume, tasksDeliveryReview, tasksDeliveryDefer, tasksDeliver } from "./tasks.ts";
 import { metricsGet } from "./metrics.ts";
 import { knowledgeAdd, knowledgeComment, knowledgeEdit, knowledgeFiles, knowledgeOpen, knowledgeRemove, knowledgeReplaceFile, knowledgeUnnote } from "./knowledge.ts";
 import { excalidrawAdd, excalidrawCheck, excalidrawCreate, excalidrawList, excalidrawRemove, excalidrawRename, excalidrawReveal, excalidrawToggleAgent, excalidrawToggleAll, excalidrawToggleContribute } from "./excalidraw.ts";
@@ -24,6 +24,7 @@ import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts"
 import { issuesCreate, issuesGet, issuesList } from "./issues.ts";
 import { sessionsAnswer, sessionsChat, sessionsList, sessionsMessage, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
 import { settingsGet, settingsLinters, settingsSet } from "./settings.ts";
+import { themesChoose, themesGet, themesRemove, themesRename, themesSave } from "./themes.ts";
 import { noticeText, pushNotice } from "../notices.ts";
 
 /** What a handler reads besides the request body. */
@@ -128,6 +129,10 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksOpen(body as { taskId: string }, ctx),
   };
+  routes["tasks.resume"] = {
+    schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
+    run: (body, ctx) => tasksResume(body as { taskId: string }, ctx),
+  };
   routes["tasks.deliveryReview"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksDeliveryReview(body as { taskId: string }, ctx),
@@ -242,6 +247,12 @@ function buildRoutes(): Record<string, Route> {
   };
   routes["planner.answer"] = { schema: Empty, run: (_body, ctx) => plannerAnswer(ctx) };
   routes["planner.save"] = { schema: Empty, run: (_body, ctx) => plannerSave(ctx) };
+  const PlanId = Type.String({ minLength: 1, maxLength: 40 });
+  routes["planner.previous"] = { schema: Type.Object({ archived: Type.Optional(Type.Boolean()) }, { additionalProperties: false }), run: (body, ctx) => plannerPrevious(body as { archived?: boolean }, ctx) };
+  routes["planner.previousGet"] = { schema: Type.Object({ id: PlanId }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousGet(body as { id: string }, ctx) };
+  routes["planner.previousArchive"] = { schema: Type.Object({ id: PlanId, archived: Type.Boolean() }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousArchive(body as { id: string; archived: boolean }, ctx) };
+  routes["planner.previousDelete"] = { schema: Type.Object({ id: PlanId }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousDelete(body as { id: string }, ctx) };
+  routes["planner.previousOpen"] = { schema: Type.Object({ id: PlanId }, { additionalProperties: false }), run: (body, ctx) => plannerPreviousOpen(body as { id: string }, ctx) };
   routes["quickfix.list"] = { schema: Empty, run: (_body, ctx) => quickfixList(ctx) };
   routes["quickfix.submit"] = {
     schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
@@ -368,6 +379,17 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => settingsSet(body as { patch: Record<string, unknown> }, ctx),
   };
   routes["settings.linters"] = { schema: Empty, run: (_body, ctx) => settingsLinters(ctx) };
+  const ThemeId = Type.String({ minLength: 1, maxLength: 40 });
+  const ThemeName = Type.String({ minLength: 1, maxLength: 200 });
+  const ThemeVars = Type.Optional(Type.Record(Type.String({ maxLength: 60 }), Type.String({ maxLength: 400 })));
+  routes["themes.get"] = { schema: Empty, run: () => themesGet() };
+  routes["themes.save"] = {
+    schema: Type.Object({ name: ThemeName, light: ThemeVars, dark: ThemeVars }, { additionalProperties: false }),
+    run: (body) => themesSave(body as { name: string; light?: Record<string, string>; dark?: Record<string, string> }),
+  };
+  routes["themes.rename"] = { schema: Type.Object({ id: ThemeId, name: ThemeName }, { additionalProperties: false }), run: (body) => themesRename(body as { id: string; name: string }) };
+  routes["themes.remove"] = { schema: Type.Object({ id: ThemeId }, { additionalProperties: false }), run: (body) => themesRemove(body as { id: string }) };
+  routes["themes.choose"] = { schema: Type.Object({ id: ThemeId }, { additionalProperties: false }), run: (body) => themesChoose(body as { id: string }) };
   return routes;
 }
 

package/src/webui/api/planner.ts

@@ -6,7 +6,7 @@
  */
 import { MEMBER_LABELS, type PlannerMessage } from "../../lobby/planner.ts";
 import type { PanelMember } from "../../schemas/configuration.ts";
-import type { PlannerSnapshot } from "../protocol.ts";
+import type { PlannerSnapshot, PreviousPlanDetail, PreviousPlanInfo } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
 import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
@@ -111,3 +111,49 @@ export async function plannerSave(ctx: ApiContext): Promise<{ notice: string }>
   if (!session?.reply?.plan) fail(409, "conflict", "no plan to save yet — describe a task in the Plan tab");
   return { notice: await ctx.service.savePlan() };
 }
+
+function attempt<T>(run: () => T, status: 404 | 409 = 409): T {
+  try {
+    return run();
+  } catch (error) {
+    const message = (error as Error).message;
+    return fail(/^no plan /.test(message) ? 404 : status, /^no plan /.test(message) ? "not_found" : "conflict", message);
+  }
+}
+
+/** The previous plans: never saved as a task, newest first; the archived ones when asked. */
+export function plannerPrevious(body: { archived?: boolean }, ctx: ApiContext): { plans: PreviousPlanInfo[] } {
+  return { plans: ctx.service.previousPlans(Boolean(body.archived)) };
+}
+
+/** One previous plan, to read: its conversation, draft and the seats' notes. */
+export function plannerPreviousGet(body: { id: string }, ctx: ApiContext): PreviousPlanDetail {
+  const record = attempt(() => ctx.service.previousPlan(body.id));
+  const snapshot = record.snapshot;
+  return {
+    id: record.id,
+    title: record.title,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    ...(record.archivedAt ? { archivedAt: record.archivedAt } : {}),
+    rounds: snapshot.turns,
+    seats: [...snapshot.seats],
+    messages: snapshot.messages.map((message) => ({ ...message })),
+    ...(snapshot.reply?.plan ? { draft: snapshot.reply.plan } : {}),
+    notes: snapshot.notes.map((note) => ({ ...note })),
+    ...(snapshot.seed ? { seed: `From issue #${snapshot.seed.issue.number}: ${snapshot.seed.issue.title}` } : {}),
+  };
+}
+
+export function plannerPreviousArchive(body: { id: string; archived: boolean }, ctx: ApiContext): { notice: string } {
+  return { notice: attempt(() => ctx.service.archivePlan(body.id, body.archived)) };
+}
+
+export function plannerPreviousDelete(body: { id: string }, ctx: ApiContext): { notice: string } {
+  return { notice: attempt(() => ctx.service.deletePlan(body.id)) };
+}
+
+/** Carry a previous plan on: it becomes the plan on screen. */
+export function plannerPreviousOpen(body: { id: string }, ctx: ApiContext): { notice: string } {
+  return { notice: attempt(() => ctx.service.reopenPlan(body.id)) };
+}

package/src/webui/api/status.ts

@@ -30,6 +30,7 @@ export function statusGet(ctx: ApiContext): StatusInfo {
   const workspace = service.workspace?.() ?? { name: "bot-lobby" };
   // The service's own config when it has one, so a saved panes or keys change shows without a restart.
   const config = service.config?.() ?? loadConfig();
+  const recovered = service.recovered?.();
   return {
     workspace: { name: workspace.name, ...(workspace.branch ? { branch: workspace.branch } : {}) },
     ...(workspace.branch ? { branch: workspace.branch } : {}),
@@ -42,5 +43,6 @@ export function statusGet(ctx: ApiContext): StatusInfo {
     tabs: tabs(issuesEnabled),
     keys: keys(config.lobby.keys),
     windows: [],
+    ...(recovered ? { recovered } : {}),
   };
 }

package/src/webui/api/tasks.ts

@@ -18,6 +18,7 @@ import { planDetails } from "../../pi/plan-checklist.ts";
 import type { WorkProjection } from "../../state/work-time.ts";
 import type { TaskSection } from "../../lobby/task-rows.ts";
 import { projectPhaseTiming } from "../../state/phase-timing.ts";
+import { resumable, type Drivers } from "../../lobby/resume.ts";
 import type { DeliveryRequest } from "../../delivery/operations.ts";
 
 function deliveryTask(body: { taskId: string }, ctx: ApiContext): Task {
@@ -53,6 +54,10 @@ interface RowContext {
   names: ReadonlyMap<string, string>;
   auto: ReadonlySet<string>;
   live: ReadonlySet<string>;
+  /** Names of the sessions in other terminals, when they have one. */
+  liveNames: ReadonlyMap<string, string>;
+  /** Who could be driving each task, for Resume. */
+  drivers: Drivers;
   work: (taskId: string) => WorkProjection | undefined;
 }
 
@@ -87,11 +92,15 @@ function ago(ms: number): string {
 }
 
 function ownerOf(task: Task, sessionId: string | undefined, ctx: RowContext): string {
+  const name = task.ownerSessionId ? ctx.names.get(task.ownerSessionId) : undefined;
+  if (name) return name === task.title ? "background" : `background · ${name}`;
+  // Resumed from the Tasks screen: its background session is starting.
+  if (ctx.drivers.carrying.has(task.id)) return "background";
   if (!task.ownerSessionId) return "not running";
   if (task.ownerSessionId === sessionId) return "this session";
-  const name = ctx.names.get(task.ownerSessionId);
-  if (name) return name === task.title ? "background" : `background · ${name}`;
-  return !ctx.live.has(task.ownerSessionId) ? "not running" : `session ${task.ownerSessionId.slice(0, 8)}`;
+  if (!ctx.live.has(task.ownerSessionId)) return "not running";
+  const other = ctx.liveNames.get(task.ownerSessionId);
+  return other && other !== task.title ? `other terminal · ${other}` : "other terminal";
 }
 
 function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: string | undefined, now: number): TaskRow {
@@ -113,6 +122,7 @@ function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: str
     ...(section === "others" ? { owner: ownerOf(task, sessionId, ctx) } : {}),
     ...(section === "recent" ? { age: ago(now - Date.parse(task.updatedAt)) } : {}),
     ...(section !== "recent" && ctx.auto.has(task.id) ? { auto: true } : {}),
+    ...(section !== "recent" && resumable(task, ctx.drivers) ? { resumable: true } : {}),
   };
 }
 
@@ -149,11 +159,19 @@ function buildRows(tasks: readonly Task[], plans: readonly PlannedTask[], sessio
 
 function contextOf(ctx: ApiContext, tasks: readonly Task[]): RowContext {
   const names = new Map<string, string>();
+  const carrying = new Set<string>();
   for (const session of ctx.service.sessions()) {
-    if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
+    if (!session.alive) continue;
+    if (session.sessionId) names.set(session.sessionId, session.name);
+    if (session.taskId) carrying.add(session.taskId);
   }
   const auto = new Set(tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && ctx.service.isAuto(task.id)).map((task) => task.id));
-  return { names, auto, live: new Set(ctx.service.liveSessions().map((session) => session.sessionId)), work: (taskId) => ctx.service.work?.(taskId) };
+  const sessions = ctx.service.liveSessions();
+  const live = new Set(sessions.map((session) => session.sessionId));
+  const liveNames = new Map(sessions.flatMap((session) => (session.name ? [[session.sessionId, session.name] as const] : [])));
+  const me = ctx.service.sessionId();
+  const drivers: Drivers = { ...(me ? { me } : {}), background: new Set(names.keys()), carrying, live };
+  return { names, auto, live, liveNames, drivers, work: (taskId) => ctx.service.work?.(taskId) };
 }
 
 /** Every task, plan and recent row, oldest groups first like the terminal. */
@@ -239,6 +257,18 @@ export function tasksMessage(body: { taskId: string; text: string; attachments?:
   return { notice: ctx.service.sendToTask(body.taskId, withAttachments(body.text, body.attachments, body.taskId, ctx.service.projectRoot?.())) };
 }
 
+/**
+ * Resume a task without moving this window: unpaused where it runs, or
+ * carried on in a background session (its key comes back to open it).
+ */
+export async function tasksResume(body: { taskId: string }, ctx: ApiContext): Promise<{ notice: string; key?: string }> {
+  const task = ctx.service.tasks().find((entry) => entry.id === body.taskId);
+  if (!task) fail(404, "not_found", `no task ${body.taskId} in this project`);
+  if (TERMINAL_STATES.includes((task as Task).state)) fail(400, "bad_request", `${body.taskId} is ${(task as Task).state}; there is nothing to resume`);
+  if (!ctx.service.resumeTask) fail(400, "bad_request", "resuming tasks is unavailable");
+  return ctx.service.resumeTask!(body.taskId);
+}
+
 /** Select existing owner chat metadata only; never start, claim or switch a process. */
 export function tasksOpen(body: { taskId: string }, ctx: ApiContext): { sessionId?: string; key?: string; notice?: string } {
   const task = ctx.service.tasks().find((entry) => entry.id === body.taskId);

package/src/webui/api/themes.ts

@@ -0,0 +1,37 @@
+/**
+ * The colour themes over HTTP: the saved list and the chosen one, shared by
+ * every pi session and project (src/state/themes.ts). Each action answers with
+ * the whole store, so the page shows exactly what was kept.
+ */
+import { chooseTheme, readThemes, removeTheme, renameTheme, saveTheme, type ThemeStore } from "../../state/themes.ts";
+import { fail } from "./index.ts";
+
+function guarded<T>(run: () => T): T {
+  try {
+    return run();
+  } catch (error) {
+    return fail(400, "bad_request", (error as Error).message);
+  }
+}
+
+export function themesGet(): ThemeStore {
+  return readThemes();
+}
+
+export function themesSave(body: { name: string; light?: Record<string, string>; dark?: Record<string, string> }): ThemeStore & { id: string } {
+  const theme = guarded(() => saveTheme(body));
+  return { ...readThemes(), id: theme.id };
+}
+
+export function themesRename(body: { id: string; name: string }): ThemeStore {
+  guarded(() => renameTheme(body.id, body.name));
+  return readThemes();
+}
+
+export function themesRemove(body: { id: string }): ThemeStore {
+  return guarded(() => removeTheme(body.id));
+}
+
+export function themesChoose(body: { id: string }): ThemeStore {
+  return guarded(() => chooseTheme(body.id));
+}

package/src/webui/command.ts

@@ -157,23 +157,48 @@ export function webSessionStarted(ctx: ExtensionContext, deps?: WebCommandDeps):
   const service = resolveService(deps);
   const running = currentWebServer();
   if (running) {
+    // The page follows the new session; with bot-lobby off in it there is no lobby to serve.
     if (service) running.rebind(service);
+    else void stopWebServer(ctx);
     return;
   }
   if (!service) return;
-  startWebServer({ service, port: loadConfig().lobby.web.port })
+  // Back after a reload: the same port, quietly (the open page reconnects to it).
+  const reloaded = takeReloadedPort();
+  startWebServer({ service, port: reloaded ?? loadConfig().lobby.web.port })
     .then((server) => {
       latestLink = server.link;
       heartbeat();
       showAddress(ctx, server.port);
+      if (reloaded !== undefined && server.port === reloaded) return;
       ctx.ui.notify(`bot-lobby web: ${server.link}`, "info");
       openLink(server.link, deps);
     })
     .catch((error: Error) => ctx.ui.notify(`bot-lobby web could not start — ${error.message}`, "warning"));
 }
 
+/**
+ * A reload imports the extension afresh, so the server this copy runs would
+ * stay bound to a session that is gone while the new copy starts another.
+ * It closes instead, and leaves its port on the process for the new copy.
+ */
+const RELOADED = Symbol.for("bot-lobby.web.reloadedPort");
+const processState = globalThis as { [RELOADED]?: number };
+
+function takeReloadedPort(): number | undefined {
+  const port = processState[RELOADED];
+  delete processState[RELOADED];
+  return port;
+}
+
 /** Wire the web server's lifecycle; called with the other session wiring. */
 export function registerWebServer(pi: ExtensionAPI): void {
   if (isSubagentProcess()) return;
   pi.on("session_start", (_event, ctx) => webSessionStarted(ctx));
+  pi.on("session_shutdown", async (event) => {
+    const running = currentWebServer();
+    if (event.reason !== "reload" || !running) return;
+    processState[RELOADED] = running.port;
+    await running.close();
+  });
 }