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

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

@@ -9,6 +9,7 @@ import { LobbyFeed } from "../../lobby/feed.ts";
 import { promptHub } from "../../lobby/prompt-hub.ts";
 import { lobbyTopics } from "../../lobby/topics.ts";
 import type { BackgroundSession, DialogAnswer, SessionDialog } from "../../lobby/sessions.ts";
+import type { PlanComment } from "../../state/comments.ts";
 import type { LobbyService } from "../../lobby/host.ts";
 import { loadScenario, type ScenarioFixture } from "./fixtures.ts";
 
@@ -40,6 +41,13 @@ function fakePlanner(entry: NonNullable<ScenarioFixture["mockPlanner"]>): Record
     async send(text: string): Promise<void> {
       (session.messages as Array<Record<string, unknown>>).push({ role: "you", text, at: Date.now() });
     },
+    async editMessage(messageIndex: number, at: number, text: string): Promise<void> {
+      const message = session.messages[messageIndex];
+      if (session.busy || !message || message.at !== at) throw new Error("the message has changed");
+      if (message.role !== "you" || (Array.isArray(message.settled) && message.settled.length > 0)) throw new Error("only ordinary user messages can be edited");
+      if (!text.trim()) throw new Error("an edited message needs some text");
+      session.messages[messageIndex] = { ...message, text: text.trim(), editedAt: Date.now() };
+    },
     async retry(): Promise<void> {},
     commentOnLine(line: string, text: string): boolean {
       session.lineComments.push({ line, text });
@@ -464,10 +472,20 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     checkExcalidraw: async () => ({ ok: true, text: "reached the server; nobody has this session open yet — open the link in Excalidraw, and agents can read and draw" }),
     comments: (taskId: string) => [...(comments.get(taskId) ?? [])],
     comment: (taskId: string, text: string) => {
-      const entry = { id: `C-mock-${(commentSeq += 1)}`, taskId, text, createdAt: new Date().toISOString(), status: "open" };
+      const entry = { id: `C-mock-${(commentSeq += 1)}`, taskId, text, by: fixture.status.sessionId, createdAt: new Date().toISOString(), status: "open" };
       comments.set(taskId, [...(comments.get(taskId) ?? []), entry]);
       return "comment sent to the oracle — it will amend the plan";
     },
+    editComment: (taskId: string, commentId: string, text: string) => {
+      const existing = (comments.get(taskId) ?? []).find((entry) => entry.id === commentId);
+      if (!existing) throw new Error(`no comment ${commentId}`);
+      if (!existing.by || existing.by !== fixture.status.sessionId) throw new Error("only your own comments can be edited");
+      const entry: Record<string, unknown> = { ...existing, text: text.trim(), editedAt: new Date().toISOString(), status: "open" };
+      delete entry.deliveredAt;
+      delete entry.addressedAt;
+      comments.set(taskId, [...(comments.get(taskId) ?? []).map((other) => (other.id === commentId ? entry : other))]);
+      return entry as unknown as PlanComment;
+    },
     startPlanned: (plan: { id: string }) => `starting ${plan.id} here — its agreed plan needs no approval…`,
     discardPlan: (id: string) => {
       const index = plans.findIndex((plan) => plan.id === id);

package/src/webui/files.ts

@@ -7,7 +7,7 @@
 import type { ServerResponse } from "node:http";
 import { readFile, realpath } from "node:fs/promises";
 import { extname, join, relative, resolve, sep } from "node:path";
-import { tmpdir } from "node:os";
+import { previewRoot } from "../state/previews.ts";
 import { previewDir } from "../ask/relay.ts";
 import { applyBaseHeaders, HttpError, sendError } from "./api/index.ts";
 
@@ -19,20 +19,16 @@ const PREVIEW_TYPES: Record<string, string> = {
   ".webp": "image/webp",
 };
 
-function previewsRoot(): string {
-  return join(tmpdir(), "bot-lobby-previews");
-}
-
 /** Whether `task`/`name` name a file without reaching outside their folder. */
 export function isPreviewName(task: string, name: string): boolean {
-  if (!/^[\w.-]+$/.test(task) || !/^[\w.-]+$/.test(name)) return false;
+  if (!/^[\w.-]+$/.test(task) || task === "." || task === ".." || !/^[\w.-]+$/.test(name)) return false;
   const ext = extname(name).toLowerCase();
   return PREVIEW_TYPES[ext] !== undefined;
 }
 
 /** An absolute image path under the previews root as its preview URL, if it is one. */
-export function previewUrlFor(absPath: string): string | undefined {
-  const root = previewsRoot();
+export function previewUrlFor(absPath: string, projectRoot?: string): string | undefined {
+  const root = previewRoot(projectRoot);
   const resolved = resolve(absPath);
   if (resolved !== root && !resolved.startsWith(root + sep)) return undefined;
   const rel = relative(root, resolved);
@@ -42,27 +38,29 @@ export function previewUrlFor(absPath: string): string | undefined {
 }
 
 /** Every absolute preview path in a prompt payload as its preview URL. */
-export function rewritePreviewImages(payload: unknown): unknown {
-  if (typeof payload === "string") return previewUrlFor(payload) ?? payload;
-  if (Array.isArray(payload)) return payload.map(rewritePreviewImages);
+export function rewritePreviewImages(payload: unknown, root?: string): unknown {
+  if (typeof payload === "string") return previewUrlFor(payload, root) ?? payload;
+  if (Array.isArray(payload)) return payload.map((value) => rewritePreviewImages(value, root));
   if (payload && typeof payload === "object") {
-    return Object.fromEntries(Object.entries(payload as Record<string, unknown>).map(([key, value]) => [key, rewritePreviewImages(value)]));
+    return Object.fromEntries(Object.entries(payload as Record<string, unknown>).map(([key, value]) => [key, rewritePreviewImages(value, root)]));
   }
   return payload;
 }
 
 /** The preview file's bytes, jailed to its task's preview dir, or undefined when refused. */
-export async function readPreview(task: string, name: string): Promise<{ body: Buffer; type: string } | undefined> {
+export async function readPreview(task: string, name: string, root?: string): Promise<{ body: Buffer; type: string } | undefined> {
   if (!isPreviewName(task, name)) return undefined;
   let real: string;
   try {
-    real = await realpath(join(previewDir(task), name));
+    real = await realpath(join(previewDir(task, root), name));
   } catch {
     return undefined;
   }
   let base: string;
   try {
-    base = await realpath(previewDir(task));
+    base = await realpath(previewDir(task, root));
+    const jail = await realpath(previewRoot(root));
+    if (!base.startsWith(jail + sep)) return undefined;
   } catch {
     return undefined;
   }
@@ -75,12 +73,12 @@ export async function readPreview(task: string, name: string): Promise<{ body: B
 }
 
 /** Serve one preview; 401 without the cookie, 404 for anything jailed away. */
-export async function servePreview(res: ServerResponse, task: string, name: string, signedIn: boolean): Promise<void> {
+export async function servePreview(res: ServerResponse, task: string, name: string, signedIn: boolean, root?: string): Promise<void> {
   if (!signedIn) {
     sendError(res, "unauthorized", "open the link Pi printed", 401);
     return;
   }
-  const found = await readPreview(task, name);
+  const found = await readPreview(task, name, root);
   if (!found) throw new HttpError(404, "not_found", "no such preview");
   applyBaseHeaders(res);
   res.writeHead(200, { "Content-Type": found.type, "Cache-Control": "no-store" });

package/src/webui/gateway.ts

@@ -0,0 +1,64 @@
+import { request, type IncomingMessage, type ServerResponse } from "node:http";
+import { applyBaseHeaders, HttpError, sendError } from "./api/index.ts";
+import { browserSession, probeProject, scanProjects, type ProjectRegistry, type ProjectRecord } from "./projects.ts";
+
+/** Only API and preview paths are project-owned; static files stay at entry. */
+export function projectRoute(path: string): { id: string; path: string } | undefined {
+  const match = /^\/projects\/([a-f0-9]{32})(\/(?:api\/[^/]+|files\/preview\/[^/]+\/[^/]+))$/.exec(path);
+  if (!match) return undefined;
+  return { id: match[1]!, path: match[2]! };
+}
+
+export async function gateway(req: IncomingMessage, res: ServerResponse, url: URL, registry: ProjectRegistry): Promise<URL | undefined> {
+  const target = projectRoute(url.pathname);
+  if (!target) throw new HttpError(404, "not_found", "no such project route");
+  if (/^\/api\/(auth\.login|projects\.)/.test(target.path)) throw new HttpError(403, "forbidden", "entry-only call");
+  if (target.id === registry.record.id) { url.pathname = target.path; return url; }
+  const record = scanProjects(registry.dir).find((r) => r.id === target.id);
+  if (!record) throw new HttpError(404, "not_found", "no such running project");
+  const cookie = browserSession(req.headers.cookie);
+  const health = await probeProject(record, cookie);
+  if (health === "unauthorized") { sendError(res, "unauthorized", "open the link Pi printed", 401); return; }
+  if (health !== "healthy") throw new HttpError(503, "failed", "the project is offline or changed");
+  await proxy(req, res, record, target.path + url.search, cookie);
+}
+
+function requestHeaders(req: IncomingMessage, port: number, cookie?: string): Record<string, string> {
+  const headers: Record<string, string> = { Host: `127.0.0.1:${port}`, Origin: `http://127.0.0.1:${port}` };
+  for (const name of ["content-type", "content-length", "accept", "last-event-id"]) {
+    const value = req.headers[name];
+    if (typeof value === "string") headers[name] = value;
+  }
+  if (cookie) headers.Cookie = cookie;
+  return headers;
+}
+
+function responseHeaders(res: IncomingMessage): Record<string, string> {
+  const headers: Record<string, string> = {};
+  const hop = String(res.headers.connection ?? "").toLowerCase().split(",").map((name) => name.trim());
+  for (const name of ["content-type", "content-length", "cache-control", "x-content-type-options"]) {
+    const value = res.headers[name];
+    if (typeof value === "string" && !hop.includes(name)) headers[name] = value;
+  }
+  return headers;
+}
+
+function proxy(req: IncomingMessage, res: ServerResponse, record: ProjectRecord, path: string, cookie?: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const upstream = request({ hostname: "127.0.0.1", port: record.port, path, method: req.method,
+      headers: requestHeaders(req, record.port, cookie) }, (response) => {
+      if (response.headers["content-type"]?.startsWith("text/event-stream")) clearTimeout(timer);
+      applyBaseHeaders(res);
+      res.writeHead(response.statusCode ?? 503, responseHeaders(response));
+      response.pipe(res);
+      response.on("end", () => { clearTimeout(timer); resolve(); });
+      response.on("error", fail);
+    });
+    const fail = () => { clearTimeout(timer); upstream.destroy(); reject(new HttpError(503, "failed", "the project is offline")); };
+    const timer = setTimeout(fail, 5000);
+    upstream.on("error", fail);
+    res.on("close", () => { clearTimeout(timer); upstream.destroy(); resolve(); });
+    req.on("aborted", () => upstream.destroy());
+    req.pipe(upstream);
+  });
+}

package/src/webui/projects.ts

@@ -0,0 +1,111 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { request } from "node:http";
+import { basename, join } from "node:path";
+import { globalConfigDir } from "../state/project.ts";
+import { canonicalRoot } from "../state/previews.ts";
+import type { ProjectInfo } from "./protocol.ts";
+
+export interface ProjectRecord extends ProjectInfo { pid: number; startedAt: number }
+export const PROJECT_ID = /^[a-f0-9]{32}$/;
+export const registryDirectory = () => join(globalConfigDir(), "web-projects");
+export const projectInfo = ({ id, name, cwd, port }: ProjectInfo): ProjectInfo => ({ id, name, cwd, port });
+
+export function livePid(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function validRecord(r: ProjectRecord): boolean {
+  return !!r && PROJECT_ID.test(r.id) && typeof r.name === "string" && typeof r.cwd === "string"
+    && r.cwd === canonicalRoot(r.cwd) && Number.isInteger(r.port) && r.port > 0 && r.port <= 65535
+    && Number.isInteger(r.pid) && r.pid > 0 && Number.isFinite(r.startedAt) && livePid(r.pid);
+}
+
+export function scanProjects(dir: string): ProjectRecord[] {
+  let names: string[];
+  try { names = readdirSync(dir).sort().slice(0, 128); } catch { return []; }
+  return names.flatMap((name) => readRecord(dir, name) ?? []);
+}
+
+function readRecord(dir: string, name: string): ProjectRecord | undefined {
+  if (!/^[a-f0-9]{32}\.json$/.test(name)) return undefined;
+  try {
+    const path = join(dir, name);
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.size > 16384) return undefined;
+    const record = JSON.parse(readFileSync(path, "utf8")) as ProjectRecord;
+    return validRecord(record) && name === `${record.id}.json` ? record : undefined;
+  } catch { return undefined; }
+}
+
+export class ProjectRegistry {
+  record: ProjectRecord;
+  readonly dir: string;
+  constructor(dir: string, root: string, port: number) {
+    this.dir = dir;
+    this.record = this.make(root, port);
+    this.save();
+  }
+  private make(root: string, port: number): ProjectRecord {
+    const cwd = canonicalRoot(root);
+    return { id: randomBytes(16).toString("hex"), name: basename(cwd) || cwd, cwd, port, pid: process.pid, startedAt: Date.now() };
+  }
+  private save(): void {
+    mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+    chmodSync(this.dir, 0o700);
+    writeFileSync(join(this.dir, `${this.record.id}.json`), JSON.stringify(this.record), { mode: 0o600, flag: "wx" });
+  }
+  rebind(root: string): void {
+    const cwd = canonicalRoot(root);
+    const previous = this.record;
+    this.close();
+    this.record = cwd === previous.cwd ? { ...previous, name: basename(cwd) || cwd } : this.make(cwd, previous.port);
+    this.save();
+  }
+  close(): void { rmSync(join(this.dir, `${this.record.id}.json`), { force: true }); }
+}
+
+/** The only browser credential we relay; never forward arbitrary cookies. */
+export function browserSession(cookie?: string): string | undefined {
+  return cookie?.split(";").map((s) => s.trim()).find((s) => /^bl_session=[^;\s]+$/.test(s));
+}
+
+export function probeProject(record: ProjectRecord, cookie?: string): Promise<"healthy" | "unauthorized" | "offline"> {
+  return new Promise((resolve) => {
+    const req = request({ hostname: "127.0.0.1", port: record.port, path: "/api/projects.self", method: "POST",
+      headers: { "Content-Type": "application/json", ...(cookie ? { Cookie: cookie } : {}) } }, (res) => {
+      const chunks: Buffer[] = []; let size = 0;
+      res.on("data", (chunk: Buffer) => { size += chunk.length; if (size > 16384) { resolve("offline"); req.destroy(); } else chunks.push(chunk); });
+      res.on("end", () => resolve(probeResult(res.statusCode, Buffer.concat(chunks), record)));
+      res.on("error", () => resolve("offline"));
+    });
+    const timer = setTimeout(() => { resolve("offline"); req.destroy(); }, 1000);
+    req.on("close", () => clearTimeout(timer));
+    req.on("error", () => resolve("offline"));
+    req.end("{}");
+  });
+}
+
+function probeResult(status: number | undefined, bytes: Buffer, record: ProjectRecord): "healthy" | "unauthorized" | "offline" {
+  if (status === 401) return "unauthorized";
+  try {
+    const reply = JSON.parse(bytes.toString());
+    const p = reply.result?.project;
+    return status === 200 && reply.ok === true && p?.id === record.id && p.cwd === record.cwd && p.port === record.port ? "healthy" : "offline";
+  } catch { return "offline"; }
+}
+
+export function selectProjects(records: ProjectRecord[], local: ProjectRecord): ProjectInfo[] {
+  const grouped = new Map<string, ProjectRecord>();
+  for (const r of records.sort((a, b) => b.startedAt - a.startedAt || b.id.localeCompare(a.id))) {
+    if (!grouped.has(r.cwd)) grouped.set(r.cwd, r);
+  }
+  grouped.set(local.cwd, local);
+  return [...grouped.values()].map(projectInfo).sort((a, b) => a.name.localeCompare(b.name) || a.cwd.localeCompare(b.cwd));
+}
+
+export async function listProjects(registry: ProjectRegistry, cookie?: string): Promise<ProjectInfo[]> {
+  const records = scanProjects(registry.dir);
+  const healthy = await Promise.all(records.map(async (r) => await probeProject(r, cookie) === "healthy" ? r : undefined));
+  return selectProjects(healthy.filter((r): r is ProjectRecord => !!r), registry.record);
+}

package/src/webui/protocol.ts

@@ -13,6 +13,8 @@ import type { BotLobbyConfig, PanelMember } from "../schemas/configuration.ts";
 import type { MemberState, PanelNote, PanelQuestion, PlannerMessage } from "../lobby/planner.ts";
 import type { QuickFixJob } from "../lobby/quickfix.ts";
 
+export interface ProjectInfo { id: string; name: string; cwd: string; port: number }
+
 export type { WebPrompt };
 export type { LobbyTopic };
 export type { DialogAnswer, SessionDialog, TaskRow, PlanComment };
@@ -510,6 +512,7 @@ export interface Api {
   "tasks.archived": { request: Record<string, never>; result: { rows: TaskRow[] } };
   "tasks.comments": { request: { taskId: string }; result: { comments: PlanComment[] } };
   "tasks.comment": { request: { taskId: string; text: string; attachments?: string[] }; result: { notice?: string } };
+  "tasks.editComment": { request: { taskId: string; commentId: string; text: string }; result: { comment: PlanComment } };
   "tasks.archive": { request: { taskId: string }; result: { notice: string } };
   "tasks.restore": { request: { taskId: string }; result: { notice: string } };
   "tasks.delete": { request: { taskId: string; where: "list" | "archive" }; result: { notice: string } };
@@ -532,6 +535,7 @@ export interface Api {
   "planner.get": { request: Record<string, never>; result: PlannerSnapshot };
   "planner.new": { request: { seed?: PlannerSeedInfo; seats?: PanelMember[] }; result: { notice: string } };
   "planner.send": { request: { text: string; attachments?: string[] }; result: { notice: string } };
+  "planner.editMessage": { request: { messageIndex: number; at: number; text: string }; result: { message: PlannerMessage; notice: string } };
   "planner.toggleSeat": { request: { member: PanelMember }; result: { notice: string; seated: boolean } };
   "planner.retry": { request: Record<string, never>; result: { notice: string } };
   "planner.commentLine": { request: { line: string; text: string }; result: { notice: string } };

package/src/webui/server.ts

@@ -6,7 +6,10 @@
  */
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import type { AddressInfo } from "node:net";
-import { loadConfig } from "../state/project.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { canonicalRoot } from "../state/previews.ts";
+import { ProjectRegistry, registryDirectory, projectInfo, listProjects, browserSession } from "./projects.ts";
+import { gateway } from "./gateway.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import type { LobbyService } from "../lobby/host.ts";
 import {
@@ -35,6 +38,8 @@ export const PORT_RANGE = 20;
 
 export interface WebServerOptions {
   service: LobbyService;
+  projectRoot?: string;
+  registryDir?: string;
   /** Base port (config `lobby.web.port` once a later step adds it). */
   port?: number;
   /** The built page; defaults to `webui/dist`. */
@@ -82,7 +87,7 @@ function hookExit(): void {
 }
 
 /** Read a JSON body, capped at a megabyte (413 past it, 400 when it is no JSON). */
-async function readJson(req: IncomingMessage): Promise<unknown> {
+async function readJson(req: IncomingMessage, allowEmpty = true): Promise<unknown> {
   const chunks: Buffer[] = [];
   let size = 0;
   for await (const chunk of req) {
@@ -92,7 +97,7 @@ async function readJson(req: IncomingMessage): Promise<unknown> {
     chunks.push(buffer);
   }
   const text = Buffer.concat(chunks).toString("utf8");
-  if (!text.trim()) return {};
+  if (!text.trim() && allowEmpty) return {};
   try {
     return JSON.parse(text);
   } catch {
@@ -133,7 +138,7 @@ async function upload(req: IncomingMessage, res: ServerResponse, url: URL, state
     sendError(res, "bad_request", "the file is empty");
     return;
   }
-  sendJson(res, 200, { ok: true, result: saveUpload(name, url.searchParams.get("type") ?? "", bytes) });
+  sendJson(res, 200, { ok: true, result: saveUpload(name, url.searchParams.get("type") ?? "", bytes, state.projectRoot) });
 }
 
 function numParam(url: URL, name: string): number | undefined {
@@ -151,6 +156,8 @@ interface RouteState {
   guard: LoginGuard;
   hub: EventHub;
   root: string;
+  projectRoot: string;
+  registry?: ProjectRegistry;
 }
 
 async function login(req: IncomingMessage, res: ServerResponse, state: RouteState): Promise<void> {
@@ -190,6 +197,15 @@ async function routeApi(req: IncomingMessage, res: ServerResponse, url: URL, sta
     sendError(res, "unauthorized", "open the link Pi printed", 401);
     return;
   }
+  if (url.pathname === "/api/projects.self" || url.pathname === "/api/projects.list") {
+    const body = await readJson(req, false);
+    if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length) throw new HttpError(400, "bad_request", "send exactly {}");
+    const registry = state.registry!;
+    const result = url.pathname.endsWith(".self") ? { project: projectInfo(registry.record) }
+      : { projects: await listProjects(registry, browserSession(req.headers.cookie)), currentId: registry.record.id };
+    sendJson(res, 200, { ok: true, result });
+    return;
+  }
   const name = callName(url);
   if (name === undefined) {
     sendError(res, "not_found", `no call ${url.pathname.slice("/api/".length)}`, 404);
@@ -210,7 +226,14 @@ async function route(req: IncomingMessage, res: ServerResponse, state: RouteStat
     sendError(res, "forbidden", "unknown host", 403);
     return;
   }
-  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  let url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname.startsWith("/projects/")) {
+    if (isCrossSite(req.headers.origin, req.headers["sec-fetch-site"] as string | undefined, state.port)) throw new HttpError(403, "forbidden", "cross-site request");
+    if (!isSignedIn(req.headers.cookie, state.session)) throw new HttpError(401, "unauthorized", "open the link Pi printed");
+    const local = await gateway(req, res, url, state.registry!);
+    if (!local) return;
+    url = local;
+  }
   if (url.pathname.startsWith("/files/preview/")) {
     if (req.method !== "GET") {
       sendError(res, "unsupported", "only GET", 405);
@@ -221,7 +244,7 @@ async function route(req: IncomingMessage, res: ServerResponse, state: RouteStat
       sendError(res, "not_found", "no such preview", 404);
       return;
     }
-    await servePreview(res, names.task, names.name, isSignedIn(req.headers.cookie, state.session));
+    await servePreview(res, names.task, names.name, isSignedIn(req.headers.cookie, state.session), state.projectRoot);
     return;
   }
   if (!url.pathname.startsWith("/api/")) {
@@ -288,6 +311,7 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
     guard: new LoginGuard(),
     hub,
     root: distDir(options.dist),
+    projectRoot: canonicalRoot(options.service.projectRoot?.() ?? options.projectRoot ?? detectProjectRoot(process.cwd())),
   };
   const server: Server = createServer((req, res) => {
     route(req, res, state).catch((error: Error) => {
@@ -318,6 +342,8 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
     throw new Error(`no free port from ${base} to ${base + PORT_RANGE}`);
   }
   state.port = bound;
+  try { state.registry = new ProjectRegistry(options.registryDir ?? registryDirectory(), state.projectRoot, bound); }
+  catch (error) { hub.close(); server.close(); throw error; }
   hookExit();
   const api: WebServer = {
     link: `http://127.0.0.1:${bound}/#token=${link}`,
@@ -325,6 +351,8 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
     clients: () => hub.clients(),
     rebind: (service) => {
       state.service = service;
+      state.projectRoot = canonicalRoot(service.projectRoot?.() ?? options.projectRoot ?? detectProjectRoot(process.cwd()));
+      state.registry!.rebind(state.projectRoot);
       hub.attach(service);
       hub.hello();
     },
@@ -336,6 +364,7 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
       return `http://127.0.0.1:${state.port}/#token=${state.link}`;
     },
     close: async () => {
+      state.registry!.close();
       hub.close();
       await new Promise<void>((resolve) => {
         server.close(() => resolve());

package/src/webui/uploads.ts

@@ -6,8 +6,9 @@
  * them. Images are also served back to the page through the preview route.
  */
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
-import { extname, join } from "node:path";
+import { existsSync, mkdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { extname, join, sep } from "node:path";
+import { previewRoot } from "../state/previews.ts";
 import { previewDir } from "../ask/relay.ts";
 import { claimAttachments, sweepAttachments } from "../state/attachments.ts";
 import { ATTACHMENTS_MARK } from "../lobby/prompts.ts";
@@ -44,9 +45,9 @@ function kindOf(mime: string): UploadKind {
 }
 
 /** Save one file; the id is its name in the attachments folder. */
-export function saveUpload(name: string, claimedType: string, bytes: Buffer): Upload {
-  sweepAttachments(STALE_MS);
-  const dir = previewDir(ATTACHMENT_BUCKET);
+export function saveUpload(name: string, claimedType: string, bytes: Buffer, root?: string): Upload {
+  sweepAttachments(STALE_MS, Date.now(), root);
+  const dir = previewDir(ATTACHMENT_BUCKET, root);
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   const id = `${Date.now().toString(36)}${randomBytes(3).toString("hex")}-${safeName(name)}`;
   writeFileSync(join(dir, id), bytes, { mode: 0o600 });
@@ -55,14 +56,23 @@ export function saveUpload(name: string, claimedType: string, bytes: Buffer): Up
   return { id, name: safeName(name), mime, size: bytes.length, kind, ...(kind === "image" ? { url: `/files/preview/${ATTACHMENT_BUCKET}/${id}` } : {}) };
 }
 
+function attachmentExists(dir: string, id: string, root?: string): boolean {
+  if (!/^[\w.-]+$/.test(id) || !existsSync(join(dir, id))) return false;
+  try {
+    const base = realpathSync(dir);
+    return base.startsWith(realpathSync(previewRoot(root)) + sep)
+      && realpathSync(join(dir, id)).startsWith(base + sep) && statSync(join(dir, id)).isFile();
+  } catch { return false; }
+}
+
 /** `text`, then the files it carries by path, the way the agents read them; they belong to `taskId` and go with it. */
-export function withAttachments(text: string, ids: readonly string[] | undefined, taskId?: string): string {
+export function withAttachments(text: string, ids: readonly string[] | undefined, taskId?: string, root?: string): string {
   if (!ids || ids.length === 0) return text;
-  const dir = previewDir(ATTACHMENT_BUCKET);
+  const dir = previewDir(ATTACHMENT_BUCKET, root);
   const lines = ids.slice(0, MAX_ATTACHMENTS).map((id) => {
-    if (!/^[\w.-]+$/.test(id) || !existsSync(join(dir, id)) || !statSync(join(dir, id)).isFile()) fail(400, "bad_request", `the attachment ${id} is not there; attach it again`);
+    if (!attachmentExists(dir, id, root)) fail(400, "bad_request", `the attachment ${id} is not there; attach it again`);
     return `- ${join(dir, id)} (${mimeOf(id, "")})`;
   });
-  if (taskId) claimAttachments(ids.slice(0, MAX_ATTACHMENTS), taskId);
+  if (taskId) claimAttachments(ids.slice(0, MAX_ATTACHMENTS), taskId, root);
   return `${text.trim()}${text.trim() ? "\n\n" : ""}${ATTACHMENTS_MARK}\n${lines.join("\n")}`;
 }

package/src/workflow/workflow.ts

@@ -64,6 +64,8 @@ import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { markCommentsAddressed, pendingComments, readPlanComments } from "../state/comments.ts";
 import { fastNext, onFastTrack, parseRoster, qaRequired, qaStillDue, qaTookPart, rosterWords, trackSummary } from "./track.ts";
 import { missingWorktree, taskCwd } from "../execution/workspace.ts";
+import { createPullRequest } from "../lobby/pulls.ts";
+import type { Exec } from "../lobby/issues.ts";
 
 export const ORCHESTRATE_ACTIONS = [
   "clarify",
@@ -144,6 +146,8 @@ export interface WorkflowDeps {
   askQuestions?: (questions: AskQuestion[], from: string, signal?: AbortSignal) => Promise<AskResult>;
   notify: (message: string, level?: "info" | "warning" | "error") => void;
   runProcess?: ProcessRunner;
+  /** Command seam for completion's bounded git/gh calls. */
+  exec?: Exec;
   /** Likely files for scouts and workers, while the classifier's file hints are on. */
   hints?: FileHinter;
   /** Picks the relevant sections of long knowledge files for scouts, workers and the QA gate, while the classifier's knowledge picks are on. */
@@ -708,7 +712,7 @@ function askRelay(task: Task, deps: WorkflowDeps, domain: Domain): { onAsk: Rela
   if (!ASKING_DOMAINS.has(domain) || !deps.askQuestions || isAutoMode(deps.root, deps.configDir, task.id)) return undefined;
   const askQuestions = deps.askQuestions;
   const label = AGENT_LABELS[domain];
-  const previews = previewDir(task.id);
+  const previews = previewDir(task.id, deps.root);
   try {
     mkdirSync(previews, { recursive: true });
   } catch {
@@ -1300,13 +1304,43 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   if (oversized.length > 0) throw new Error(`cannot complete: knowledge files over the compaction threshold: ${oversized.map((entry) => `${entry.agent}/${entry.file} (${entry.chars})`).join(", ")}. First record domain-relevant facts where they belong with action=knowledge (domain=designer|backend|qa), then rewrite each oversized file with action=compact, then call complete again.`);
   const summary = params.text?.trim() || task.proposal || task.title;
-  flushDecisions(deps, task);
   recordCompletion(deps, task, summary);
   removeTaskScratchpads(deps.root, deps.configDir, task.id);
   task.blockers = [];
   if (task.state === "implementing") transition(task, "reviewing");
   transition(task, "completed");
-  return `Task ${task.id} completed. History recorded and temporary scratchpads removed.`;
+  const opened = await openPullRequest(task, deps);
+  flushDecisions(deps, task);
+  return `Task ${task.id} completed. History recorded and temporary scratchpads removed.${opened}`;
+}
+
+/** Longest pull request body `gh` takes without complaint. */
+const PR_BODY_CHARS = 60_000;
+
+/**
+ * Open the task's pull request once it completes, so its branch lands in
+ * review by itself. Every reason it cannot (no isolation, no remote, `gh` not
+ * signed in) is recorded as a note and the completion stands either way.
+ */
+async function openPullRequest(task: Task, deps: WorkflowDeps): Promise<string> {
+  const git = task.git;
+  if (!git || (git.mode !== "branch" && git.mode !== "worktree")) return pullNote(task, "No pull request opened — task has no git isolation");
+  const base = git.from?.trim();
+  if (!base || /^detached at /i.test(base) || /^[a-f0-9]{40,64}$/i.test(base)) return pullNote(task, "No pull request opened — task has no valid base branch");
+  const body = [task.proposal?.trim() || task.plan?.trim() || task.title, task.qaVerdict ? `QA verdict: ${task.qaVerdict}` : ""].filter(Boolean).join("\n\n").slice(0, PR_BODY_CHARS);
+  try {
+    const pull = await createPullRequest({ exec: deps.exec, cwd: taskCwd(task, deps.cwd), branch: git.branch, base, title: task.title, body });
+    recordDecision(task, `Opened pull request #${pull.number} for ${git.branch}: ${pull.url}`);
+    deps.notify(`Pull request #${pull.number} is open: ${pull.url}`, "info");
+    return ` Pull request #${pull.number} is open: ${pull.url}.`;
+  } catch (error) {
+    return pullNote(task, `No pull request opened for ${git.branch} — ${(error as Error).message}`);
+  }
+}
+
+function pullNote(task: Task, note: string): string {
+  recordDecision(task, note);
+  return ` ${note}.`;
 }
 
 /** Asked when the oracle completes a task QA has not passed (the user told it to finish, say). */