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

package/README.md

@@ -1,7 +1,7 @@
 # Bot-Lobby
 
-A [Pi](https://pi.dev) extension for multi-agent software development. Describe a change, agree a plan
-with the oracle, and follow the agents in a local browser lobby. Approvals, domain boundaries and QA
+A [Pi](https://pi.dev) extension for multi-agent software development. Describe a change, agree on a
+plan with the oracle, and follow the agents in a local browser lobby. Approvals, domain boundaries and QA
 are enforced before anything is called done.
 
 ![The Lobby: the conversation, the agents' activity and the Thinking orb](.github/screenshots/lobby.png)
@@ -18,12 +18,18 @@ The questionnaire and web tools are built in, so don't also install extensions w
 ## Use
 
 1. In Pi, run `/bot-lobby add a login page`. Bot-lobby turns on and the lobby opens in your browser.
-   A new pi session starts with bot-lobby off, as plain pi: `Ctrl+Shift+M` or `/bot-lobby on|off` switches it.
-2. Answer the oracle's questions and approve its plan, or agree one with the panel in **Plan** first.
+   A new Pi session starts with bot-lobby off, as plain Pi: `Ctrl+Shift+M` or `/bot-lobby on|off` switches it.
+2. Answer the oracle's questions and approve its plan, or agree on one with the panel in **Plan** first.
    A plan opens with a short list of steps; the detail of each follows for whoever wants it.
+   Plans you leave without saving them as a task wait under **Plan → Previous**. You can read, carry on,
+   archive or delete them there. A plan saved as a task leaves that list.
 3. Follow the agents in **Lobby**: the step being worked on reads `active · 1m 12s`, and each task shows
    how long its agents have worked on it (idle time left out). Models, effort and time limits are in **Settings**.
 
+**Issues** lists the repository's open issues (with `lobby.issues` on), and **Plan it** starts a
+planning session from one. **Git** lists open pull requests; an agent reviews one on request,
+read-only, and nothing is posted to GitHub. Both read GitHub through `gh`.
+
 Small changes go to **Quick fix**. `--task` forces a full task, `--fast` / `--full` picks the workflow,
 and `--branch` / `--worktree` isolates it in git. A finished isolated task pushes its branch and tries
 to open a PR through `gh`; nothing merges on its own.
@@ -37,7 +43,17 @@ QA is sized to what was built, not to the request. Once the work is in, Jev (the
 reads the diff and sets the QA risk. A change with nothing that runs (docs, styles, comments) passes
 on the engine's checks with no QA agent, and a small one gets a light check. One that touches
 security, data, concurrency or orchestration gets a deep, adversarial review. The test budget is a
-ceiling, never a quota, and the Tasks tab shows the read and why. With Jev off, the engine's rules decide.
+ceiling, never a quota, and the Tasks tab shows Jev's read and why. With Jev off, the engine's rules decide.
+
+If Pi crashes, is killed or loses its terminal, the lobby page keeps everything on screen and
+reconnects when Pi is back. The next Pi started in the project carries on what was running. The
+planning session returns as it was, and a round that was cut off runs again. Queued quick fixes
+run, and every task's session starts again from its saved file, picking up where it stopped. A
+quit on purpose stops this work, and `pi -c` brings back the planning session.
+
+A task that is paused, or that no running session drives, shows **Resume** (`R`) in **Tasks**.
+It carries the task on without moving your window: a paused task is unpaused where it runs, and a
+stopped one carries on in a background session, which restarts its own session when its file is found.
 
 | Agent | Does |
 | --- | --- |
@@ -56,14 +72,17 @@ rebound with `lobby.keys`. In Pi, `Alt+G` toggles auto mode and `Ctrl+Shift+M` t
 
 ## Screenshots
 
-| Plan | Tasks |
+| Planning | Tasks |
 | --- | --- |
-| ![The Plan start page: the panel as seats](.github/screenshots/plan.png) | ![A task with its action bar](.github/screenshots/tasks.png) |
-| **Thinking** | **Excalidraw** |
-| ![Each agent's latest thought, in steps](.github/screenshots/thinking.png) | ![A shared Excalidraw session](.github/screenshots/excalidraw.png) |
+| ![A planning session: the panel's questions with mockups, and the draft plan](.github/screenshots/plan.png) | ![The task list across sessions, with one task's steps](.github/screenshots/tasks.png) |
+| **Thinking** | **Questionnaire** |
+| ![The Thinking pop-up: each agent's thoughts, in steps](.github/screenshots/thinking.png) | ![A question with a mockup for each option](.github/screenshots/questionnaire.png) |
+| **Issues** | **Git** |
+| ![An open issue, ready to plan with the panel](.github/screenshots/issues.png) | ![A pull request with an agent's review](.github/screenshots/git.png) |
 
 ## Configuration
 
 Settings live in `~/.pi/bot-lobby/config.json` (`BOT_LOBBY_CONFIG_DIR` moves them), and
-`/bot-lobby config` shows what is in effect. Tasks and project knowledge stay in `.pi/bot-lobby/`
-inside your project.
+`/bot-lobby config` shows what is in effect. Colour themes you import, under a name you choose,
+are kept in `themes.json` beside it, so every Pi session and project shows them. Tasks and
+project knowledge stay in `.pi/bot-lobby/` inside your project.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.27",
+  "version": "0.6.28",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/lobby/host.ts

@@ -13,6 +13,7 @@ import type { ChatEntry, LobbyFeed } from "./feed.ts";
 import type { BackgroundSession } from "./sessions.ts";
 import type { QuickFixQueue } from "./quickfix.ts";
 import type { PlannerSeed, PlanningSession } from "./planner.ts";
+import type { PlanRecord, PlanSummary } from "../state/plan-history.ts";
 import type { IssuesState } from "./issues.ts";
 import type { PullsState } from "./pulls.ts";
 import type { PullReviews } from "./pr-review.ts";
@@ -115,6 +116,16 @@ export interface LobbyService {
   abortMaster(): void;
   quickfix: QuickFixQueue;
   planner(): PlanningSession | undefined;
+  /** The project's previous plans (never saved as a task), newest first; the archived ones when asked. */
+  previousPlans(archived: boolean): PlanSummary[];
+  /** One previous plan, whole; throws when there is none (or it was saved as a task). */
+  previousPlan(id: string): PlanRecord;
+  /** Archive a previous plan, or bring it back; returns a notice (throws when it cannot). */
+  archivePlan(id: string, archived: boolean): string;
+  /** Delete a previous plan for good; returns a notice (throws when it cannot). */
+  deletePlan(id: string): string;
+  /** Carry a previous plan on as the plan on screen; returns a notice. */
+  reopenPlan(id: string): string;
   /** Start a planning session (replacing any other) with these seats on the panel. */
   newPlanner(seed?: PlannerSeed, seats?: readonly PanelMember[]): PlanningSession;
   /** The oracle puts the panel's open questions to the user, one questionnaire at a time; returns a notice. */
@@ -150,6 +161,8 @@ export interface LobbyService {
   sessionModel?(): string | undefined;
   /** The Issues tab is switched on (`lobby.issues`). */
   issuesEnabled(): boolean;
+  /** What this window carried on from one that stopped unexpectedly, when it did. */
+  recovered?(): { at: number; text: string } | undefined;
   /** This window's pi session name, when it has one. */
   sessionName(): string | undefined;
   /** Background sessions this window started, oldest first. */
@@ -161,6 +174,12 @@ export interface LobbyService {
   setAuto(taskId: string, on: boolean): void;
   /** Leave a message for a task's oracle, delivered by whichever session drives it (now or once one resumes it); returns a notice. */
   sendToTask(taskId: string, text: string): string;
+  /**
+   * Resume a task from the Tasks screen, leaving this window where it is: a
+   * paused task is unpaused where it runs, one nothing runs carries on in a
+   * background session. A notice, and the background session's key.
+   */
+  resumeTask?(taskId: string): Promise<{ notice: string; key?: string }>;
   /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
   sendToSession(sessionId: string, text: string): string;
   /** Sessions running in this project, other than this window's, from their heartbeats. */

package/src/lobby/planner.ts

@@ -522,6 +522,49 @@ export function memberPrompt(member: PanelMember, instructions?: string): string
   return [base, loadPrompt("panel.md"), `## Your seat\n\n${MEMBER_SEATS[member]}`].join("\n\n---\n\n");
 }
 
+/** A planning session as JSON: what `PlanningSession.snapshot` writes and `restore` reads. */
+export interface PlanningSnapshot {
+  version: 1;
+  /** Absent on snapshots kept before sessions had ids: a restore gives them one. */
+  id?: string;
+  createdAt?: number;
+  messages: PlannerMessage[];
+  seed?: PlannerSeed;
+  reply?: PlannerReply;
+  questions: PanelQuestion[];
+  notes: PanelNote[];
+  members: MemberState[];
+  seats: PanelMember[];
+  pins: PanelMember[];
+  satOut: Array<[PanelMember, number]>;
+  lastStatus: Array<[PanelMember, "ready" | "open"]>;
+  sat: PanelMember[];
+  memberNotes: Array<[PanelMember, string[]]>;
+  turns: number;
+  mode: RoundMode;
+  answered: AskResult[];
+  lineComments: LineComment[];
+  saved?: PlannedTask;
+  savedParts: PlannedTask[];
+  error?: string;
+  autoContinued: boolean;
+  attempts: number;
+  /** A round was running when it was taken. */
+  running: boolean;
+}
+
+/** What a seat that was thinking when pi stopped shows until its round runs again. */
+export const STOPPED_WITH_PI = "pi stopped during the round";
+
+/** Whether a parsed file is a snapshot this version reads; a torn or foreign file is not. */
+export function isPlanningSnapshot(value: unknown): value is PlanningSnapshot {
+  const snapshot = value as PlanningSnapshot;
+  return Boolean(snapshot) && snapshot.version === 1 && Array.isArray(snapshot.messages) && Array.isArray(snapshot.questions) && Array.isArray(snapshot.seats)
+    && Array.isArray(snapshot.members) && Array.isArray(snapshot.pins) && Array.isArray(snapshot.satOut) && Array.isArray(snapshot.lastStatus)
+    && Array.isArray(snapshot.sat) && Array.isArray(snapshot.memberNotes) && Array.isArray(snapshot.answered) && Array.isArray(snapshot.lineComments)
+    && Array.isArray(snapshot.savedParts) && Array.isArray(snapshot.notes) && typeof snapshot.turns === "number";
+}
+
 interface RunOutcome {
   status: MetricRecord["status"];
   output: string;
@@ -530,7 +573,15 @@ interface RunOutcome {
   usage: { input: number; output: number; cost: number; turns: number };
 }
 
+/** A new planning session's id: `PS-` and the time, so ids sort by when they began. */
+export function planningId(now = Date.now()): string {
+  return `PS-${now.toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+
 export class PlanningSession {
+  /** Names the session among the project's plans (src/state/plan-history.ts). */
+  id = planningId();
+  createdAt = Date.now();
   messages: PlannerMessage[] = [];
   seed?: PlannerSeed;
   /** The oracle's latest reply; its plan is the current draft. */
@@ -718,6 +769,86 @@ export class PlanningSession {
     return PANEL_MEMBERS.filter((member) => this.sat.has(member) && this.seats.has(member));
   }
 
+  /** Everything the session needs to carry on in another pi process, as JSON. */
+  snapshot(): PlanningSnapshot {
+    return {
+      version: 1,
+      id: this.id,
+      createdAt: this.createdAt,
+      messages: this.messages,
+      ...(this.seed ? { seed: this.seed } : {}),
+      ...(this.reply ? { reply: this.reply } : {}),
+      questions: this.questions,
+      notes: this.notes,
+      members: this.members,
+      seats: [...this.seats],
+      pins: [...this.pins],
+      satOut: [...this.satOut],
+      lastStatus: [...this.lastStatus],
+      sat: [...this.sat],
+      memberNotes: [...this.memberNotes],
+      turns: this.turns,
+      mode: this.mode,
+      answered: this.answered,
+      lineComments: this.lineComments,
+      ...(this.saved ? { saved: this.saved } : {}),
+      savedParts: this.savedParts,
+      ...(this.error ? { error: this.error } : {}),
+      autoContinued: this.autoContinued,
+      attempts: this.attempts,
+      running: this.busy,
+    };
+  }
+
+  /**
+   * A session as a snapshot left it. A round that was running when pi
+   * stopped is marked interrupted: `resume` runs it again.
+   */
+  static restore(deps: PlannerDeps, snapshot: PlanningSnapshot): PlanningSession {
+    const session = new PlanningSession({ ...deps, panel: snapshot.seats }, snapshot.seed);
+    if (snapshot.id) session.id = snapshot.id;
+    if (typeof snapshot.createdAt === "number") session.createdAt = snapshot.createdAt;
+    session.messages = snapshot.messages;
+    if (snapshot.reply) session.reply = snapshot.reply;
+    session.questions = snapshot.questions;
+    session.notes = snapshot.notes;
+    session.members = snapshot.members.map((member) => member.status === "thinking" ? { ...member, status: "failed", error: STOPPED_WITH_PI, step: undefined } : member);
+    for (const member of snapshot.pins) session.pins.add(member);
+    session.satOut = new Map(snapshot.satOut);
+    for (const [member, status] of snapshot.lastStatus) session.lastStatus.set(member, status);
+    for (const member of snapshot.sat) session.sat.add(member);
+    for (const [member, notes] of snapshot.memberNotes) session.memberNotes.set(member, notes);
+    session.turns = snapshot.turns;
+    session.mode = snapshot.mode;
+    session.answered = snapshot.answered;
+    session.lineComments = snapshot.lineComments;
+    if (snapshot.saved) session.saved = snapshot.saved;
+    session.savedParts = snapshot.savedParts;
+    if (snapshot.error) session.error = snapshot.error;
+    session.autoContinued = snapshot.autoContinued;
+    session.attempts = snapshot.attempts;
+    session.interrupted = snapshot.running;
+    return session;
+  }
+
+  /** A round was running when pi stopped, and has not run again yet. */
+  interrupted = false;
+
+  /** Run again the round pi stopped in the middle of; nothing when none was. */
+  async resume(): Promise<void> {
+    if (!this.interrupted || this.busy) return;
+    this.interrupted = false;
+    const last = this.messages.at(-1);
+    if (last?.role === "you") return this.retry();
+    // The seed alone had started the first round.
+    if (this.messages.length === 0 && this.seed) {
+      this.turns = Math.max(0, this.turns - 1);
+      return this.open();
+    }
+    // The round had already written its reply: only its last checks were cut off.
+    this.deps.onChange?.();
+  }
+
   /** Save the latest draft as a pending task. */
   save(now = new Date()): PlannedTask {
     const plan = this.reply?.plan;

package/src/lobby/quickfix.ts

@@ -65,6 +65,8 @@ export interface QuickFixJob {
   profile?: QuickFixProfile;
   /** The oracle sent it here from a request typed to the lobby. */
   routed?: boolean;
+  /** An earlier run was cut off when pi stopped: some of its edits may already be in the tree. */
+  interrupted?: boolean;
 }
 
 /** How a job enters the queue besides its prompt. */
@@ -111,6 +113,10 @@ export interface QuickFixDeps {
 
 export const MAX_JOBS = 30;
 export const MAX_STEPS = 200;
+/** Steps a snapshot keeps per job: enough to read what it did. */
+const MAX_KEPT_STEPS = 40;
+/** What a job pi stopped in the middle of is told when it runs again. */
+export const INTERRUPTED_NOTE = "An earlier run of this request was cut off when pi stopped, so some of its edits may already be in the tree: look at the files before you change them, and finish the request.";
 
 function isActive(job: QuickFixJob): boolean {
   return job.status === "queued" || job.status === "running";
@@ -202,6 +208,39 @@ export class QuickFixQueue {
     return true;
   }
 
+  /** The queue as JSON, for the next pi process to carry on from. */
+  snapshot(): QuickFixJob[] {
+    return this.jobs.map((job) => ({ ...job, steps: job.steps.slice(-MAX_KEPT_STEPS) }));
+  }
+
+  /**
+   * Take up a queue an earlier pi process left: finished jobs stay as they
+   * ended, and the one that was running when pi stopped goes back to the front
+   * of the queue, told that it was cut off. Returns the jobs that will run.
+   */
+  restore(jobs: readonly QuickFixJob[]): QuickFixJob[] {
+    const kept = jobs.map((job): QuickFixJob => job.status !== "running" ? { ...job } : {
+      ...job,
+      status: "queued",
+      interrupted: true,
+      note: "pi stopped while this ran; it runs again from where the tree is",
+      steps: job.steps.map((step) => ({ ...step, pending: false })),
+    });
+    // Queues from more than one stopped window may share ids: a repeated one is numbered on.
+    const number = (job: QuickFixJob) => Number(/^QF-(\d+)$/.exec(job.id)?.[1] ?? 0);
+    this.counter = Math.max(this.counter, ...this.jobs.map(number), ...kept.map(number));
+    const taken = new Set(this.jobs.map((job) => job.id));
+    for (const job of kept) {
+      if (taken.has(job.id)) job.id = `QF-${++this.counter}`;
+      taken.add(job.id);
+    }
+    const resumed = kept.filter((job) => job.interrupted && job.status === "queued");
+    this.jobs = [...resumed, ...kept.filter((job) => !resumed.includes(job)), ...this.jobs];
+    this.changed();
+    this.pump();
+    return this.jobs.filter(isActive);
+  }
+
   /** Abort everything (session shutdown). */
   cancelAll(): void {
     for (const job of this.jobs) if (job.status === "queued") job.status = "cancelled";
@@ -259,7 +298,7 @@ export class QuickFixQueue {
       const attempt = (model: string | undefined, thinking: string) => runPiAgent(
         {
           cwd: this.deps.cwd,
-          task: likely ? `${job.prompt}\n\n${likely}` : job.prompt,
+          task: [job.prompt, job.interrupted ? INTERRUPTED_NOTE : "", likely].filter(Boolean).join("\n\n"),
           systemPrompt: quickFixPrompt(profile.instructions),
           tools: [...QUICK_FIX_TOOLS, ...(this.deps.hints?.tools() ?? [])],
           ...grantOption("quickfix"),