@a-t-h-i/bot-lobby 0.6.16 → 0.6.18

package/package.json

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

package/src/ask/relay.ts

@@ -6,7 +6,7 @@
  * sends the answers back the same way. Only runs the master lets ask (the
  * designer's) get the tool: it sets `ASK_ENV` for them.
  */
-import { tmpdir } from "node:os";
+import { previewRoot } from "../state/previews.ts";
 import { isAbsolute, join, resolve } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { MAX_OPTIONS, MAX_QUESTIONS, type AskQuestion, type AskResult, type Asker } from "./types.ts";
@@ -21,8 +21,8 @@ export function relayEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
 }
 
 /** Where an agent saves the images it shows the user for a task: outside the repository, so they are never part of its change. */
-export function previewDir(taskId: string): string {
-  return join(tmpdir(), "bot-lobby-previews", taskId.replace(/[^\w.-]/g, "_"));
+export function previewDir(taskId: string, root?: string): string {
+  return join(previewRoot(root), taskId.replace(/[^\w.-]/g, "_"));
 }
 
 /** Image paths made absolute, so the master finds them whatever its cwd. */

package/src/index.ts

@@ -5,6 +5,7 @@ import { registerOrchestrateTool } from "./pi/tools.ts";
 import { registerRouteTool } from "./pi/route.ts";
 import { onTransition } from "./state/task-state.ts";
 import { releaseAttachments } from "./state/attachments.ts";
+import { detectProjectRoot } from "./state/project.ts";
 import { TERMINAL_STATES } from "./schemas/task.ts";
 import { pingTransition } from "./pi/notify.ts";
 import { isSubagentProcess } from "./pi/quiet.ts";
@@ -19,6 +20,8 @@ import { registerWebTools } from "./web/tools.ts";
 import { registerExcalidrawTools } from "./excalidraw/tools.ts";
 
 export default function (pi: ExtensionAPI): void {
+  let root = detectProjectRoot(process.cwd(), CONFIG_DIR_NAME);
+  pi.on("session_start", (_event, ctx) => { root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME); });
   // First, so every session_start handler below finds the classifier bound to this session's keys.
   registerClassifier(pi, CONFIG_DIR_NAME);
   // Before the lifecycle, so a task that ended while the oracle was idle is closed before it builds the next turn's prompt.
@@ -30,7 +33,7 @@ export default function (pi: ExtensionAPI): void {
   // A finished task takes the files attached during it along.
   onTransition((task) => {
     pingTransition(task);
-    if (TERMINAL_STATES.includes(task.state)) releaseAttachments(task.id);
+    if (TERMINAL_STATES.includes(task.state)) releaseAttachments(task.id, root);
   });
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);

package/src/lobby/host.ts

@@ -86,6 +86,7 @@ export interface ModelChoice {
 
 /** Everything the web server needs from pi and bot-lobby. */
 export interface LobbyService {
+  projectRoot?(): string;
   sessionId(): string | undefined;
   /** This session's active task and its runs, as the lobby reads them. */
   zen(): { task?: Task; runs: readonly AgentRun[] };
@@ -100,6 +101,8 @@ export interface LobbyService {
   /** Send text to the oracle, or start a task when none is active; returns a notice. */
   toOracle(text: string): string | undefined;
   comment(taskId: string, text: string): string;
+  /** Correct a comment this session sent; returns the edited comment. */
+  editComment(taskId: string, commentId: string, text: string): PlanComment;
   startPlanned(plan: PlannedTask): string;
   discardPlan(id: string): void;
   abortMaster(): void;

package/src/lobby/keys.ts

@@ -10,6 +10,8 @@ export const LOBBY_ACTIONS = {
   settings: { key: "alt+s", help: "settings: each agent's model and effort" },
   savePlan: { key: "ctrl+s", help: "save the plan from the Plan tab" },
   sessions: { key: "alt+o", help: "browse and message your sessions" },
+  activity: { key: "alt+a", help: "show or hide Activity on the Lobby" },
+  thinking: { key: "alt+t", help: "show or hide Thinking on the Lobby" },
   nextTab: { key: "alt+]", help: "next tab" },
   prevTab: { key: "alt+[", help: "previous tab" },
 } as const;

package/src/lobby/planner.ts

@@ -86,6 +86,7 @@ export interface PlannerMessage {
   role: "you" | "planner";
   text: string;
   at: number;
+  editedAt?: number;
   /** The round's questions, attributed, when the panel asked any. */
   questions?: PanelQuestion[];
   /** Questions the classifier answered with their recommended option instead of asking. */
@@ -574,6 +575,30 @@ export class PlanningSession {
     await this.post(text, settled);
   }
 
+  /** Correct an ordinary user turn, keeping the conversation and rerunning the panel. */
+  async editMessage(messageIndex: number, at: number, text: string): Promise<void> {
+    this.validateEdit(messageIndex, at, text);
+    this.messages = this.messages.map((message, index) => index === messageIndex ? { ...message, text: text.trim(), editedAt: Date.now() } : message);
+    this.reply = undefined;
+    this.questions = [];
+    this.answered = [];
+    this.lineComments = [];
+    this.notes = [];
+    this.memberNotes.clear();
+    this.lastStatus.clear();
+    this.autoContinued = false;
+    await this.turn();
+  }
+
+  /** Shared boundary checks, also used by HTTP before starting the background round. */
+  validateEdit(messageIndex: number, at: number, text: string): void {
+    if (this.busy) throw new Error("the panel is still thinking");
+    const message = this.messages[messageIndex];
+    if (!Number.isInteger(messageIndex) || messageIndex < 0 || !message || message.at !== at) throw new Error("the message has changed — refresh the conversation");
+    if (message.role !== "you" || message.settled?.length) throw new Error("only ordinary user messages can be edited");
+    if (!text.trim()) throw new Error("an edited message needs some text");
+  }
+
   private async post(text: string, settled?: readonly SettledQuestion[]): Promise<void> {
     const body = [text.trim(), commentBlock(this.lineComments)].filter(Boolean).join("\n\n");
     if (!body) return;

package/src/lobby/pulls.ts

@@ -4,7 +4,7 @@
  * Like issues, `gh` owns authentication and repository detection; every
  * failure becomes one readable line.
  */
-import { gh, type Exec } from "./issues.ts";
+import { execCommand, gh, type Exec } from "./issues.ts";
 
 export type ChecksState = "passing" | "failing" | "pending";
 
@@ -193,6 +193,49 @@ export async function pullDiff(exec: Exec, cwd: string, number: number, limit =
   return stdout.length > limit ? `${stdout.slice(0, limit)}\n[…the diff continues: ${stdout.length - limit} more characters]` : stdout;
 }
 
+/** A pull request opened for a completed task's branch. */
+export interface CreatedPull {
+  number: number;
+  url: string;
+}
+
+const PUSH_TIMEOUT_MS = 60_000;
+
+async function run(exec: Exec, cwd: string, command: string, args: string[]): Promise<string> {
+  let result: Awaited<ReturnType<Exec>>;
+  try {
+    result = await exec(command, args, { cwd, timeout: PUSH_TIMEOUT_MS });
+  } catch (error) {
+    throw new Error(`${command} could not run — ${(error as Error).message}`);
+  }
+  if (result.code !== 0) throw new Error(result.stderr.trim() || `${command} exited with code ${result.code}`);
+  return result.stdout;
+}
+
+/** `gh pr create` ends with the URL on its own last line; the number is its tail. */
+function parseCreated(stdout: string): CreatedPull {
+  const url = stdout.trim().split("\n").map((line) => line.trim()).filter((line) => /^https?:\/\/\S+$/.test(line)).pop();
+  if (!url) throw new Error("gh pr create printed no pull request URL");
+  const match = /\/pull\/([1-9]\d*)$/.exec(url);
+  const number = Number(match?.[1]);
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`gh pr create printed an unreadable URL: ${url}`);
+  return { number, url };
+}
+
+/**
+ * Push a finished task's branch and open its pull request, so the work lands
+ * in review without the oracle having to remember a second step.
+ */
+export async function createPullRequest(options: { exec?: Exec; cwd: string; branch: string; base: string; title: string; body: string }): Promise<CreatedPull> {
+  for (const ref of [options.branch, options.base]) {
+    if (!ref || ref.startsWith("-") || /[\s~^:?*\[\\]|\.\.|@\{|\/\//.test(ref) || /[/.]$/.test(ref)) throw new Error("invalid pull request branch");
+  }
+  const exec = options.exec ?? execCommand;
+  await run(exec, options.cwd, "git", ["push", "-u", "origin", options.branch]);
+  const stdout = await gh(exec, options.cwd, ["pr", "create", "--base", options.base, "--head", options.branch, "--title", options.title, "--body", options.body.slice(0, 60_000)]);
+  return parseCreated(stdout);
+}
+
 /** Lobby state for the Git tab: the list, the open pull request, and what is loading. */
 export class PullsState {
   pulls: PullSummary[] = [];

package/src/lobby/service.ts

@@ -8,7 +8,7 @@ import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { loadTask, peekTasks } from "../state/persistence.ts";
 import { releaseAttachments } from "../state/attachments.ts";
 import { loadConfig, saveConfig as writeConfig } from "../state/project.ts";
-import { addPlanComment, readPlanComments } from "../state/comments.ts";
+import { addPlanComment, editComment, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { sendToInbox, sendToSession as leaveForSession } from "../state/inbox.ts";
 import { livePresence } from "../state/presence.ts";
@@ -82,6 +82,12 @@ function addComment(state: Runtime, taskId: string, text: string): string {
   }
   lobbyFeed.log("LOBBY", `comment on ${taskId}'s plan saved`, "info");
   lobbyTopics.bump("plans");
+  lobbyTopics.bump("tasks");
+  return deliverComment(task, sessionId);
+}
+
+function deliverComment(task: Task, sessionId: string): string {
+  const taskId = task.id;
   if (task.ownerSessionId === sessionId) {
     if (deliverComments() === 0) return `comment saved — it reaches the oracle once ${taskId} is resumed or restored`;
     return `comment sent to the oracle — it will ${task.plan ? "amend the plan" : "revise the proposal"}`;
@@ -90,6 +96,26 @@ function addComment(state: Runtime, taskId: string, text: string): string {
   return `comment saved — the session driving ${taskId} passes it to its oracle`;
 }
 
+/**
+ * Correct a comment this session sent. Ownership is checked again here, not
+ * only at the API boundary: the session that wrote the comment is the only one
+ * that may change its words.
+ */
+function editOwnComment(state: Runtime, taskId: string, commentId: string, text: string): PlanComment {
+  const task = loadTask(state.root, state.configDir, taskId);
+  if (!task) throw new Error(`no task ${taskId}`);
+  const sessionId = state.ctx.sessionManager.getSessionId();
+  const comment = readPlanComments(state.root, state.configDir, taskId).find((entry) => entry.id === commentId);
+  if (!comment) throw new Error(`no comment ${commentId} on ${taskId}`);
+  if (!comment.by || comment.by !== sessionId) throw new Error(`only the session that wrote ${commentId} can edit it`);
+  const edited = editComment(state.root, state.configDir, taskId, commentId, text);
+  lobbyFeed.log("LOBBY", `comment ${commentId} on ${taskId}'s plan edited`, "info");
+  lobbyTopics.bump("plans");
+  lobbyTopics.bump("tasks");
+  deliverComment(task, sessionId);
+  return edited;
+}
+
 function failed(state: Runtime, what: string, error: Error): void {
   lobbyFeed.log("LOBBY", `${what} — ${error.message}`, "error");
   lobbyNotify(state, `bot-lobby: ${what} — ${error.message}`, "error");
@@ -318,7 +344,7 @@ function archiveTask(state: Runtime, taskId: string): string {
   if (busy) return busy;
   try {
     archiveTaskOnDisk(state.root, state.configDir, taskId);
-    releaseAttachments(taskId);
+    releaseAttachments(taskId, state.root);
   } catch (error) {
     return (error as Error).message;
   }
@@ -347,7 +373,7 @@ function deleteTask(state: Runtime, taskId: string, where: "list" | "archive"):
   }
   try {
     deleteTaskOnDisk(state.root, state.configDir, taskId, where);
-    releaseAttachments(taskId);
+    releaseAttachments(taskId, state.root);
   } catch (error) {
     return (error as Error).message;
   }
@@ -485,6 +511,7 @@ export function createLobbyService(state: Runtime): LobbyService {
   };
   let appliedMaster = masterKey();
   return {
+    projectRoot: () => state.root,
     sessionId: () => state.ctx.sessionManager.getSessionId(),
     zen: () => {
       const snapshot = taskSnapshot();
@@ -499,6 +526,7 @@ export function createLobbyService(state: Runtime): LobbyService {
     classifierMetrics: () => readClassifierMetrics(state.root, state.configDir),
     toOracle: (text) => toOracle(state, text),
     comment: (taskId, text) => addComment(state, taskId, text),
+    editComment: (taskId, commentId, text) => editOwnComment(state, taskId, commentId, text),
     startPlanned: (plan) => startPlanned(state, plan),
     discardPlan: (id) => {
       discardPlannedTask(state.root, state.configDir, id);

package/src/state/attachments.ts

@@ -5,67 +5,67 @@
  * deleted. Files never sent, or sent with no task, go after a few days.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { previewRoot } from "./previews.ts";
 import { join } from "node:path";
 
 /** The folder the page's preview route serves attachments from. */
-export function attachmentDir(): string {
-  return join(tmpdir(), "bot-lobby-previews", "attachments");
+export function attachmentDir(root?: string): string {
+  return join(previewRoot(root), "attachments");
 }
 
-function indexPath(): string {
-  return join(tmpdir(), "bot-lobby-previews", "attachments.json");
+function indexPath(root?: string): string {
+  return join(previewRoot(root), "attachments.json");
 }
 
-function readIndex(): Record<string, string> {
+function readIndex(root?: string): Record<string, string> {
   try {
-    const parsed = JSON.parse(readFileSync(indexPath(), "utf8")) as Record<string, unknown>;
+    const parsed = JSON.parse(readFileSync(indexPath(root), "utf8")) as Record<string, unknown>;
     return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, string] => typeof entry[1] === "string"));
   } catch {
     return {};
   }
 }
 
-function writeIndex(index: Record<string, string>): void {
+function writeIndex(index: Record<string, string>, root?: string): void {
   try {
-    mkdirSync(join(tmpdir(), "bot-lobby-previews"), { recursive: true });
-    writeFileSync(indexPath(), JSON.stringify(index), { mode: 0o600 });
+    mkdirSync(previewRoot(root), { recursive: true, mode: 0o700 });
+    writeFileSync(indexPath(root), JSON.stringify(index), { mode: 0o600 });
   } catch {
     // The files then fall to the age sweep.
   }
 }
 
 /** Remember that `ids` belong to `taskId`. */
-export function claimAttachments(ids: readonly string[], taskId: string): void {
+export function claimAttachments(ids: readonly string[], taskId: string, root?: string): void {
   if (ids.length === 0) return;
-  const index = readIndex();
+  const index = readIndex(root);
   for (const id of ids) index[id] = taskId;
-  writeIndex(index);
+  writeIndex(index, root);
 }
 
 /** Delete every file that was sent while `taskId` was in play. */
-export function releaseAttachments(taskId: string): number {
-  const index = readIndex();
+export function releaseAttachments(taskId: string, root?: string): number {
+  const index = readIndex(root);
   let removed = 0;
   for (const [id, owner] of Object.entries(index)) {
     if (owner !== taskId) continue;
     try {
-      rmSync(join(attachmentDir(), id), { force: true });
+      rmSync(join(attachmentDir(root), id), { force: true });
       removed += 1;
     } catch {
       // A file already gone is the goal.
     }
     delete index[id];
   }
-  if (removed > 0 || Object.keys(index).length !== Object.keys(readIndex()).length) writeIndex(index);
+  if (removed > 0 || Object.keys(index).length !== Object.keys(readIndex(root)).length) writeIndex(index, root);
   return removed;
 }
 
 /** Delete files older than `maxAgeMs` that no task claimed. */
-export function sweepAttachments(maxAgeMs: number, now = Date.now()): number {
-  const dir = attachmentDir();
+export function sweepAttachments(maxAgeMs: number, now = Date.now(), root?: string): number {
+  const dir = attachmentDir(root);
   if (!existsSync(dir)) return 0;
-  const claimed = new Set(Object.keys(readIndex()));
+  const claimed = new Set(Object.keys(readIndex(root)));
   let removed = 0;
   for (const name of readdirSync(dir)) {
     if (claimed.has(name)) continue;

package/src/state/comments.ts

@@ -5,8 +5,9 @@
  * session rewrites state.json at the end of every workflow step and would
  * silently drop a comment written by another session in the meantime.
  *
- * Each line is one event: a comment, its delivery to the owning Master, or the
- * Master addressing it with an amended plan. Reading folds the events.
+ * Each line is one event: a comment, its delivery to the owning Master, the
+ * Master addressing it with an amended plan, or the user editing their own
+ * comment after sending it. Reading folds the events.
  */
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -23,6 +24,7 @@ export interface PlanComment {
   /** The pi session that wrote the comment, when known. */
   by?: string;
   status: CommentStatus;
+  editedAt?: string;
   deliveredAt?: string;
   addressedAt?: string;
 }
@@ -30,7 +32,8 @@ export interface PlanComment {
 type CommentEvent =
   | { kind: "comment"; id: string; text: string; at: string; by?: string }
   | { kind: "delivered"; id: string; at: string }
-  | { kind: "addressed"; id: string; at: string };
+  | { kind: "addressed"; id: string; at: string }
+  | { kind: "edited"; id: string; text: string; at: string };
 
 /** Longest comment kept; the Master gets it verbatim. */
 export const MAX_COMMENT_CHARS = 2000;
@@ -82,6 +85,13 @@ export function foldComments(taskId: string, events: readonly CommentEvent[]): P
     } else if (event.kind === "addressed" && comment.status !== "addressed") {
       comment.status = "addressed";
       comment.addressedAt = event.at;
+    } else if (event.kind === "edited") {
+      // An edit reopens the comment: the correction has not reached the Master yet.
+      comment.text = event.text;
+      comment.editedAt = event.at;
+      comment.status = "open";
+      delete comment.deliveredAt;
+      delete comment.addressedAt;
     }
   }
   return [...byId.values()];
@@ -101,6 +111,18 @@ export function addPlanComment(root: string, configDir: string, taskId: string,
   return { id, taskId, text: body, createdAt: at, ...(by ? { by } : {}), status: "open" };
 }
 
+/** Correct a comment already sent; the edit is one more event, never a rewrite. */
+export function editComment(root: string, configDir: string, taskId: string, commentId: string, text: string, now = new Date()): PlanComment {
+  const body = text.trim().slice(0, MAX_COMMENT_CHARS);
+  if (!body) throw new Error("an edited comment needs some text");
+  if (!readPlanComments(root, configDir, taskId).some((comment) => comment.id === commentId)) throw new Error(`no comment ${commentId} on ${taskId}`);
+  const path = commentsPath(root, configDir, taskId);
+  append(path, { kind: "edited", id: commentId, text: body, at: now.toISOString() });
+  const edited = readPlanComments(root, configDir, taskId).find((comment) => comment.id === commentId);
+  if (!edited) throw new Error(`no comment ${commentId} on ${taskId}`);
+  return edited;
+}
+
 export function markCommentsDelivered(root: string, configDir: string, taskId: string, ids: readonly string[], now = new Date()): void {
   const path = commentsPath(root, configDir, taskId);
   for (const id of ids) append(path, { kind: "delivered", id, at: now.toISOString() });

package/src/state/previews.ts

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { detectProjectRoot } from "./project.ts";
+
+/** Stable identity even when a project is reached through a symlink. */
+export function canonicalRoot(root: string): string {
+  try { return realpathSync(root); } catch { return resolve(root); }
+}
+
+/** No legacy global bucket fallback: files belong to exactly one project. */
+export function previewRoot(root = detectProjectRoot(process.cwd())): string {
+  return join(tmpdir(), "bot-lobby-previews", createHash("sha256").update(canonicalRoot(root)).digest("hex"));
+}

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, plannerToggleSeat, plannerSave } from "./planner.ts";
+import { plannerAnswer, plannerCommentLine, plannerGet, plannerNew, plannerRetry, plannerSend, plannerEditMessage, plannerToggleSeat, plannerSave } from "./planner.ts";
 import { quickfixCancel, quickfixList, quickfixMovedToTask, quickfixRunAnyway, quickfixSubmit } from "./quickfix.ts";
-import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksGet, tasksList, tasksMessage, tasksRestore } from "./tasks.ts";
+import { tasksArchive, tasksArchived, tasksAuto, tasksComment, tasksComments, tasksDelete, tasksEditComment, tasksGet, tasksList, tasksMessage, tasksRestore } 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";
@@ -132,6 +132,10 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ taskId: TaskId, text: CommentText, attachments: Attachments }, { additionalProperties: false }),
     run: (body, ctx) => tasksComment(body as { taskId: string; text: string; attachments?: string[] }, ctx),
   };
+  routes["tasks.editComment"] = {
+    schema: Type.Object({ taskId: TaskId, commentId: Type.String({ minLength: 1, maxLength: 200 }), text: CommentText }, { additionalProperties: false }),
+    run: (body, ctx) => tasksEditComment(body as { taskId: string; commentId: string; text: string }, ctx),
+  };
   routes["tasks.archive"] = {
     schema: Type.Object({ taskId: TaskId }, { additionalProperties: false }),
     run: (body, ctx) => tasksArchive(body as { taskId: string }, ctx),
@@ -207,6 +211,10 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ text: NoticeText, attachments: Attachments }, { additionalProperties: false }),
     run: (body, ctx) => plannerSend(body as { text: string; attachments?: string[] }, ctx),
   };
+  routes["planner.editMessage"] = {
+    schema: Type.Object({ messageIndex: Type.Integer({ minimum: 0 }), at: Type.Number(), text: NoticeText }, { additionalProperties: false }),
+    run: (body, ctx) => plannerEditMessage(body as { messageIndex: number; at: number; text: string }, ctx),
+  };
   routes["planner.toggleSeat"] = {
     schema: Type.Object({ member: Member }, { additionalProperties: false }),
     run: (body, ctx) => plannerToggleSeat(body as { member: "backend" | "designer" | "qa" | "researcher" }, ctx),

package/src/webui/api/lobby.ts

@@ -77,7 +77,7 @@ export function lobbyHistory(body: { before?: number }, ctx: ApiContext): { entr
 /** Text for the oracle; a notice when it was not simply sent. */
 export function lobbySend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
   if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
-  const notice = ctx.service.toOracle(withAttachments(body.text, body.attachments, ctx.service.zen().task?.id));
+  const notice = ctx.service.toOracle(withAttachments(body.text, body.attachments, ctx.service.zen().task?.id, ctx.service.projectRoot?.()));
   return notice ? { notice } : {};
 }
 

package/src/webui/api/planner.ts

@@ -4,7 +4,7 @@
  * answering the round's questions and saving the draft. Actions answer with
  * the same notice text the terminal shows.
  */
-import { MEMBER_LABELS } from "../../lobby/planner.ts";
+import { MEMBER_LABELS, type PlannerMessage } from "../../lobby/planner.ts";
 import type { PanelMember } from "../../schemas/configuration.ts";
 import type { PlannerSnapshot } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
@@ -50,13 +50,26 @@ export function plannerNew(body: { seed?: { issue: { number: number; title: stri
 /** Send a message to the panel; the round runs in the background. */
 export function plannerSend(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice: string } {
   if (!body.text.trim() && !body.attachments?.length) fail(400, "bad_request", "describe the task to plan");
-  const text = withAttachments(body.text, body.attachments);
+  const text = withAttachments(body.text, body.attachments, undefined, ctx.service.projectRoot?.());
   const session = ctx.service.planner() ?? ctx.service.newPlanner(undefined, [...ctx.service.defaultPanel()]);
   if (session!.busy) fail(409, "conflict", "the panel is still thinking — wait for the round to finish");
   session!.send(text).catch(() => {});
   return { notice: "sent — the panel is on the next round" };
 }
 
+/** Correct a user turn synchronously, then revise the plan in the background. */
+export function plannerEditMessage(body: { messageIndex: number; at: number; text: string }, ctx: ApiContext): { message: PlannerMessage; notice: string } {
+  const session = ctx.service.planner();
+  if (!session) fail(404, "not_found", "no planning session");
+  const message = session.messages[body.messageIndex];
+  if (session.busy) fail(409, "conflict", "the panel is still thinking — wait for the round to finish");
+  if (!message || message.at !== body.at) fail(409, "conflict", "the message has changed — refresh the conversation");
+  if (message.role !== "you" || message.settled?.length) fail(403, "forbidden", "only ordinary user messages can be edited");
+  if (!body.text.trim()) fail(400, "bad_request", "an edited message needs some text");
+  session.editMessage(body.messageIndex, body.at, body.text).catch(() => {});
+  return { message: structuredClone(session.messages[body.messageIndex]!), notice: "message edited — the panel revises the plan" };
+}
+
 /** Seat or unseat a member for the next round. */
 export function plannerToggleSeat(body: { member: PanelMember }, ctx: ApiContext): { notice: string; seated: boolean } {
   const session = ctx.service.planner() ?? ctx.service.newPlanner(undefined, [...ctx.service.defaultPanel()]);

package/src/webui/api/prompts.ts

@@ -11,13 +11,13 @@ import { fail } from "./index.ts";
 import { rewritePreviewImages } from "../files.ts";
 import type { WebPrompt } from "../protocol.ts";
 
-function withPreviewUrls(prompt: WebPrompt): WebPrompt {
-  return { ...prompt, payload: rewritePreviewImages(prompt.payload) };
+function withPreviewUrls(prompt: WebPrompt, root?: string): WebPrompt {
+  return { ...prompt, payload: rewritePreviewImages(prompt.payload, root) };
 }
 
 /** The questions still waiting for an answer, oldest first. */
-export function promptsList(_ctx: ApiContext): { prompts: WebPrompt[] } {
-  return { prompts: promptHub.pending().map(withPreviewUrls) };
+export function promptsList(ctx: ApiContext): { prompts: WebPrompt[] } {
+  return { prompts: promptHub.pending().map((prompt) => withPreviewUrls(prompt, ctx.service.projectRoot?.())) };
 }
 
 /** Answer a question; 409 when it is already settled or unknown. */

package/src/webui/api/quickfix.ts

@@ -17,7 +17,7 @@ export function quickfixList(ctx: ApiContext): { jobs: QuickFixJob[] } {
 /** Queue a quick fix; it starts at once when nothing else is running. */
 export function quickfixSubmit(body: { text: string; attachments?: string[] }, ctx: ApiContext): { notice: string; id: string } {
   if (!body.text.trim() && !body.attachments?.length) fail(400, "bad_request", "describe a quick change first");
-  const job = ctx.service.quickfix.submit(withAttachments(body.text, body.attachments));
+  const job = ctx.service.quickfix.submit(withAttachments(body.text, body.attachments, undefined, ctx.service.projectRoot?.()));
   return { notice: ctx.service.quickfix.running?.id === job.id ? `${job.id} started` : `${job.id} queued behind the running quick fix`, id: job.id };
 }
 

package/src/webui/api/sessions.ts

@@ -61,7 +61,7 @@ export function sessionsStart(body: { request?: string; planId?: string; auto?:
     return { notice: `started ${session.name} in a new session`, key: session.key };
   }
   if (!body.request?.trim() && !body.attachments?.length) fail(400, "bad_request", "describe the task first");
-  const session = ctx.service.startSession({ request: withAttachments((body.request ?? "").trim(), body.attachments), ...(body.auto ? { auto: true } : {}) });
+  const session = ctx.service.startSession({ request: withAttachments((body.request ?? "").trim(), body.attachments, undefined, ctx.service.projectRoot?.()), ...(body.auto ? { auto: true } : {}) });
   if (typeof session === "string") return { notice: session };
   return { notice: `started ${session.name} in a new session`, key: session.key };
 }
@@ -78,7 +78,7 @@ export function sessionsStop(body: { key: string }, ctx: ApiContext): { notice:
 export function sessionsMessage(body: { key?: string; sessionId?: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
   if (!body.key && !body.sessionId) fail(400, "bad_request", "a session key or id is required");
   if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
-  const text = withAttachments(body.text, body.attachments);
+  const text = withAttachments(body.text, body.attachments, undefined, ctx.service.projectRoot?.());
   const background = backgroundOf(ctx, body.key, body.sessionId);
   if (background) {
     if (!background.alive) fail(409, "conflict", `${background.name} has ended`);

package/src/webui/api/tasks.ts

@@ -4,6 +4,7 @@
  * shape is `TaskRow` in `src/lobby/task-rows.ts`.
  */
 import { TERMINAL_STATES, taskRequest, type Task } from "../../schemas/task.ts";
+import type { PlanComment } from "../../state/comments.ts";
 import type { PlannedTask } from "../../state/backlog.ts";
 import { describeRun, runFromLog } from "../../pi/run-summary.ts";
 import { pendingApprovals } from "../../workflow/approvals.ts";
@@ -138,7 +139,24 @@ export function tasksComments(body: { taskId: string }, ctx: ApiContext): { comm
 /** Comment on a task's plan; blank text is a no-op notice like the lobby's. */
 export function tasksComment(body: { taskId: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice?: string } {
   if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
-  return { notice: ctx.service.comment(body.taskId, withAttachments(body.text, body.attachments, body.taskId)) };
+  return { notice: ctx.service.comment(body.taskId, withAttachments(body.text, body.attachments, body.taskId, ctx.service.projectRoot?.())) };
+}
+
+/**
+ * Correct a comment this session sent. Only the session that wrote it may edit:
+ * an agent's comment, or one from a session that has since gone, is refused.
+ */
+export function tasksEditComment(body: { taskId: string; commentId: string; text: string }, ctx: ApiContext): { comment: PlanComment } {
+  const comment = ctx.service.comments(body.taskId).find((entry) => entry.id === body.commentId);
+  if (!comment) fail(404, "not_found", `no comment ${body.commentId} on ${body.taskId}`);
+  const sessionId = ctx.service.sessionId();
+  if (!comment.by || comment.by !== sessionId) fail(403, "forbidden", `only the session that wrote ${body.commentId} can edit it`);
+  if (!body.text.trim()) fail(400, "bad_request", "an edited comment needs some text");
+  try {
+    return { comment: ctx.service.editComment(body.taskId, body.commentId, body.text) };
+  } catch (error) {
+    return fail(400, "bad_request", (error as Error).message);
+  }
 }
 
 /** Archive, restore or delete a task; each answers the terminal's notice. */
@@ -169,7 +187,7 @@ export function tasksAuto(body: { taskId: string; on: boolean }, ctx: ApiContext
 /** Leave a message for a task's oracle; blank text is a no-op notice. */
 export function tasksMessage(body: { taskId: string; text: string; attachments?: string[] }, ctx: ApiContext): { notice: string } {
   if (!body.text.trim() && !body.attachments?.length) return { notice: "type something first" };
-  return { notice: ctx.service.sendToTask(body.taskId, withAttachments(body.text, body.attachments, body.taskId)) };
+  return { notice: ctx.service.sendToTask(body.taskId, withAttachments(body.text, body.attachments, body.taskId, ctx.service.projectRoot?.())) };
 }
 
 /** How many recent runs the detail lists (the terminal's count). */