@computesdk/loops 0.1.2 → 0.1.3

package/dist/server.mjs

@@ -1,10 +1,38 @@
 // server/index.ts
-import fs8 from "node:fs";
-import { randomBytes } from "node:crypto";
+import fs9 from "node:fs";
+import { randomBytes, randomUUID } from "node:crypto";
 import http from "node:http";
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
-import { execFile, execFileSync as execFileSync2, spawn as spawn6 } from "node:child_process";
+import { execFile as execFile2, execFileSync as execFileSync2, spawn as spawn6 } from "node:child_process";
+
+// ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  res;
+  status;
+  /**
+  * Creates an instance of `HTTPException`.
+  * @param status - HTTP status code for the exception. Defaults to 500.
+  * @param options - Additional options for the exception.
+  */
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  /**
+  * Returns the response object associated with the exception.
+  * If a response object is not provided, a new response is created with the error message and status code.
+  * @returns The response object.
+  */
+  getResponse() {
+    if (this.res) return new Response(this.res.body, {
+      status: this.status,
+      headers: this.res.headers
+    });
+    return new Response(this.message, { status: this.status });
+  }
+};
 
 // ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
@@ -79,26 +107,26 @@ var throwNestingLimitExceeded = () => {
 };
 
 // ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/utils/url.js
-var splitPath = (path9) => {
-  const paths = path9.split("/");
+var splitPath = (path10) => {
+  const paths = path10.split("/");
   if (paths[0] === "") paths.shift();
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path9 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path9);
+  const { groups, path: path10 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path10);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path9) => {
+var extractGroupsFromPath = (path10) => {
   const groups = [];
-  path9 = path9.replace(/\{[^}]+\}/g, (match2, index) => {
+  path10 = path10.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
   return {
     groups,
-    path: path9
+    path: path10
   };
 };
 var replaceGroupMarks = (paths, groups) => {
@@ -161,8 +189,8 @@ var getPath = (request) => {
       const queryIndex = url.indexOf("?", i);
       const hashIndex = url.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path9 = url.slice(start, end);
-      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
+      const path10 = url.slice(start, end);
+      return tryDecodeURI(path10.includes("%25") ? path10.replace(/%25/g, "%2525") : path10);
     } else if (charCode === 63 || charCode === 35) break;
   }
   return url.slice(start, i);
@@ -175,9 +203,9 @@ var mergePath = (base, sub, ...rest) => {
   if (rest.length) sub = mergePath(sub, ...rest);
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path9) => {
-  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) return null;
-  const segments = path9.split("/");
+var checkOptionalParameter = (path10) => {
+  if (path10.charCodeAt(path10.length - 1) !== 63 || !path10.includes(":")) return null;
+  const segments = path10.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -288,9 +316,9 @@ var HonoRequest = class {
   */
   path;
   bodyCache = {};
-  constructor(request, path9 = "/", matchResult = [[]]) {
+  constructor(request, path10 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path9;
+    this.path = path10;
     this.#matchResult = matchResult;
   }
   param(key) {
@@ -1020,8 +1048,8 @@ var Hono = class Hono2 {
         return this;
       };
     });
-    this.on = (method, path9, ...handlers) => {
-      for (const p of [path9].flat()) {
+    this.on = (method, path10, ...handlers) => {
+      for (const p of [path10].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           const methodName = m.toUpperCase();
@@ -1075,8 +1103,8 @@ var Hono = class Hono2 {
   * app.route("/api", app2) // GET /api/user
   * ```
   */
-  route(path9, app2) {
-    const subApp = this.basePath(path9);
+  route(path10, app2) {
+    const subApp = this.basePath(path10);
     app2.routes.map((r) => {
       let handler;
       if (app2.errorHandler === errorHandler) handler = r.handler;
@@ -1101,9 +1129,9 @@ var Hono = class Hono2 {
   * const api = new Hono().basePath('/api')
   * ```
   */
-  basePath(path9) {
+  basePath(path10) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path9);
+    subApp._basePath = mergePath(this._basePath, path10);
     return subApp;
   }
   /**
@@ -1179,7 +1207,7 @@ var Hono = class Hono2 {
   * })
   * ```
   */
-  mount(path9, applicationHandler, options) {
+  mount(path10, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -1202,7 +1230,7 @@ var Hono = class Hono2 {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path9);
+      const mergedPath = mergePath(this._basePath, path10);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -1215,18 +1243,18 @@ var Hono = class Hono2 {
       if (res) return res;
       await next();
     };
-    this.#addRoute("ALL", mergePath(path9, "*"), handler);
+    this.#addRoute("ALL", mergePath(path10, "*"), handler);
     return this;
   }
-  #addRoute(method, path9, handler, baseRoutePath) {
-    path9 = mergePath(this._basePath, path9);
+  #addRoute(method, path10, handler, baseRoutePath) {
+    path10 = mergePath(this._basePath, path10);
     const r = {
       basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-      path: path9,
+      path: path10,
       method,
       handler
     };
-    this.router.add(method, path9, [handler, r]);
+    this.router.add(method, path10, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -1235,10 +1263,10 @@ var Hono = class Hono2 {
   }
   #dispatch(request, executionCtx, env, method) {
     if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-    const path9 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path9);
+    const path10 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path10);
     const c = new Context(request, {
-      path: path9,
+      path: path10,
       matchResult,
       env,
       executionCtx,
@@ -1326,19 +1354,19 @@ var createNullObject = () => /* @__PURE__ */ Object.create(null);
 
 // ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path9) {
+function match(method, path10) {
   const matchers = this.buildAllMatchers();
-  const match2 = ((method2, path10) => {
+  const match2 = ((method2, path11) => {
     const matcher = matchers[method2] || matchers["ALL"];
-    const staticMatch = matcher[2][path10];
+    const staticMatch = matcher[2][path11];
     if (staticMatch) return staticMatch;
-    const match3 = path10.match(matcher[0]);
+    const match3 = path11.match(matcher[0]);
     if (!match3) return [[], emptyParam];
     const index = match3.indexOf("", 1);
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path9);
+  return match2(method, path10);
 }
 
 // ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -1428,14 +1456,14 @@ var Trie = class {
   #root = new Node();
   #index = 0;
   paths = createNullObject();
-  insert(path9, isStatic) {
+  insert(path10, isStatic) {
     if (isStatic) {
-      this.#root.insert(path9.split(""), 0, [], this.#context, true);
+      this.#root.insert(path10.split(""), 0, [], this.#context, true);
       return;
     }
     const paramAssoc = [];
     const groups = [];
-    let markedPath = path9;
+    let markedPath = path10;
     for (let i = 0; ; ) {
       let replaced = false;
       markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
@@ -1456,7 +1484,7 @@ var Trie = class {
       }
     }
     this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
-    this.paths[path9] = [this.#index++, paramAssoc];
+    this.paths[path10] = [this.#index++, paramAssoc];
   }
   buildRegExp() {
     let regexp = this.#root.buildRegExpStr();
@@ -1489,11 +1517,11 @@ var Trie = class {
 
 // ../../node_modules/.pnpm/hono@4.13.14/node_modules/hono/dist/router/reg-exp-router/router.js
 var wildcardRegExpCache = createNullObject();
-function buildWildcardRegExp(path9) {
-  return wildcardRegExpCache[path9] ??= new RegExp(`^${path9.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
+function buildWildcardRegExp(path10) {
+  return wildcardRegExpCache[path10] ??= new RegExp(`^${path10.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
 }
-function findMiddleware(middleware, path9) {
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path9)) return [...middleware[k]];
+function findMiddleware(middleware, path10) {
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path10)) return [...middleware[k]];
 }
 var RegExpRouter = class {
   name = "RegExpRouter";
@@ -1505,14 +1533,14 @@ var RegExpRouter = class {
     this.#routes = { ["ALL"]: createNullObject() };
     this.#tries = { ["ALL"]: new Trie() };
   }
-  #insertPath(method, path9) {
+  #insertPath(method, path10) {
     try {
-      this.#tries[method].insert(path9, !/\*|\/:/.test(path9));
+      this.#tries[method].insert(path10, !/\*|\/:/.test(path10));
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path10) : e;
     }
   }
-  add(method, path9, handler) {
+  add(method, path10, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
@@ -1526,24 +1554,24 @@ var RegExpRouter = class {
         }
       }
     }
-    if (path9 === "/*") path9 = "*";
+    if (path10 === "/*") path10 = "*";
     const methods = method === "ALL" ? Object.keys(middleware) : [method];
-    if (/\*$/.test(path9)) {
-      const re = buildWildcardRegExp(path9);
-      for (const m of methods) if (!middleware[m][path9]) {
-        this.#insertPath(m, path9);
-        middleware[m][path9] = findMiddleware(middleware[m], path9) || findMiddleware(middleware["ALL"], path9) || [];
+    if (/\*$/.test(path10)) {
+      const re = buildWildcardRegExp(path10);
+      for (const m of methods) if (!middleware[m][path10]) {
+        this.#insertPath(m, path10);
+        middleware[m][path10] = findMiddleware(middleware[m], path10) || findMiddleware(middleware["ALL"], path10) || [];
       }
-      for (const handlerMap of [middleware, routes]) for (const m of methods) for (const p in handlerMap[m]) re.test(p) && handlerMap[m][p].push([handler, path9]);
+      for (const handlerMap of [middleware, routes]) for (const m of methods) for (const p in handlerMap[m]) re.test(p) && handlerMap[m][p].push([handler, path10]);
       return;
     }
-    const paths = checkOptionalParameter(path9) || [path9];
-    for (const path10 of paths) for (const m of methods) {
-      if (!routes[m][path10]) {
-        this.#insertPath(m, path10);
-        routes[m][path10] = findMiddleware(middleware[m], path10) || findMiddleware(middleware["ALL"], path10) || [];
+    const paths = checkOptionalParameter(path10) || [path10];
+    for (const path11 of paths) for (const m of methods) {
+      if (!routes[m][path11]) {
+        this.#insertPath(m, path11);
+        routes[m][path11] = findMiddleware(middleware[m], path11) || findMiddleware(middleware["ALL"], path11) || [];
       }
-      routes[m][path10].push([handler, path10]);
+      routes[m][path11].push([handler, path11]);
     }
   }
   match = match;
@@ -1561,11 +1589,11 @@ var RegExpRouter = class {
     const staticMap = createNullObject();
     const handlerData = [];
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-    for (const r of [middleware, routes]) for (const path9 in r) {
-      const handlers = r[path9];
-      const pathData = trie.paths[path9];
+    for (const r of [middleware, routes]) for (const path10 in r) {
+      const handlers = r[path10];
+      const pathData = trie.paths[path10];
       if (!pathData) {
-        staticMap[path9] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+        staticMap[path10] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
         continue;
       }
       handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [h, trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
@@ -1589,15 +1617,15 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path9, handler) {
+  add(method, path10, handler) {
     if (!this.#routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     this.#routes.push([
       method,
-      path9,
+      path10,
       handler
     ]);
   }
-  match(method, path9) {
+  match(method, path10) {
     if (!this.#routes) throw new Error("Fatal error");
     const routers = this.#routers;
     const routes = this.#routes;
@@ -1608,7 +1636,7 @@ var SmartRouter = class {
       const router = routers[i];
       try {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) router.add(...routes[i2]);
-        res = router.match(method, path9);
+        res = router.match(method, path10);
       } catch (e) {
         if (e instanceof UnsupportedPathError) continue;
         throw e;
@@ -1637,9 +1665,9 @@ var Node3 = class Node4 {
   #patterns = [];
   #pattern;
   #params = emptyParams;
-  insert(method, path9, handler) {
+  insert(method, path10, handler) {
     let curNode = this;
-    const parts = splitRoutingPath(path9);
+    const parts = splitRoutingPath(path10);
     const possibleKeys = /* @__PURE__ */ new Set();
     let i = 0;
     for (const p of parts) {
@@ -1675,11 +1703,11 @@ var Node3 = class Node4 {
       }
     }
   }
-  search(method, path9) {
+  search(method, path10) {
     const handlerSets = [];
     this.#params = emptyParams;
     let curNodes = [this];
-    const parts = splitPath(path9);
+    const parts = splitPath(path10);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -1715,13 +1743,13 @@ var Node3 = class Node4 {
           if (matcher !== true) {
             if (!partOffsets) {
               partOffsets = [];
-              let offset = path9[0] === "/" ? 1 : 0;
+              let offset = path10[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path9.slice(partOffsets[i]);
+            const restPathString = path10.slice(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               if (!Object.hasOwn(params, name)) params[name] = m[0];
@@ -1762,11 +1790,11 @@ var Node3 = class Node4 {
 var TrieRouter = class {
   name = "TrieRouter";
   #node = new Node3();
-  add(method, path9, handler) {
-    for (const result of checkOptionalParameter(path9) || [path9]) this.#node.insert(method, result, handler);
+  add(method, path10, handler) {
+    for (const result of checkOptionalParameter(path10) || [path10]) this.#node.insert(method, result, handler);
   }
-  match(method, path9) {
-    return this.#node.search(method, path9);
+  match(method, path10) {
+    return this.#node.search(method, path10);
   }
 };
 
@@ -2347,19 +2375,19 @@ var flushHeaders = (outgoing) => {
   }
 };
 var responseViaCache = async (res, outgoing) => {
-  let [status, body, header] = res[cacheKey];
+  let [status, body, header2] = res[cacheKey];
   let hasContentLength = false;
-  if (!header) {
-    header = { "content-type": "text/plain; charset=UTF-8" };
-  } else if (header instanceof Headers) {
-    hasContentLength = header.has("content-length");
-    header = buildOutgoingHttpHeaders(header);
-  } else if (Array.isArray(header)) {
-    const headerObj = new Headers(header);
+  if (!header2) {
+    header2 = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header2 instanceof Headers) {
+    hasContentLength = header2.has("content-length");
+    header2 = buildOutgoingHttpHeaders(header2);
+  } else if (Array.isArray(header2)) {
+    const headerObj = new Headers(header2);
     hasContentLength = headerObj.has("content-length");
-    header = buildOutgoingHttpHeaders(headerObj);
+    header2 = buildOutgoingHttpHeaders(headerObj);
   } else {
-    for (const key in header) {
+    for (const key in header2) {
       if (key.length === 14 && key.toLowerCase() === "content-length") {
         hasContentLength = true;
         break;
@@ -2368,14 +2396,14 @@ var responseViaCache = async (res, outgoing) => {
   }
   if (!hasContentLength) {
     if (typeof body === "string") {
-      header["Content-Length"] = Buffer.byteLength(body);
+      header2["Content-Length"] = Buffer.byteLength(body);
     } else if (body instanceof Uint8Array) {
-      header["Content-Length"] = body.byteLength;
+      header2["Content-Length"] = body.byteLength;
     } else if (body instanceof Blob) {
-      header["Content-Length"] = body.size;
+      header2["Content-Length"] = body.size;
     }
   }
-  outgoing.writeHead(status, header);
+  outgoing.writeHead(status, header2);
   if (typeof body === "string" || body instanceof Uint8Array) {
     outgoing.end(body);
   } else if (body instanceof Blob) {
@@ -2572,6 +2600,9 @@ var PiRpc = class {
   options;
   constructor(options) {
     this.options = options;
+    if (options.onEvent) this.listeners.add(options.onEvent);
+    if (options.onUiRequest) this.uiListeners.add(options.onUiRequest);
+    if (options.onExit) this.exitListeners.add(options.onExit);
   }
   get running() {
     return !!this.proc && !this.exited;
@@ -2584,12 +2615,16 @@ var PiRpc = class {
   }
   async start() {
     if (this.proc) return;
-    const proc = spawn(this.options.command ?? "pi", ["--mode", "rpc", ...this.options.args ?? []], {
+    const command = this.options.command ?? "pi";
+    const script = /\.m?js$/i.test(command);
+    const proc = spawn(script ? process.execPath : command, [...script ? [command] : [], "--mode", "rpc", ...this.options.args ?? []], {
       cwd: this.options.cwd,
       env: { ...process.env, ...this.options.env },
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.proc = proc;
+    proc.stdin.on("error", () => {
+    });
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => {
       this.buffer += chunk;
@@ -2627,7 +2662,7 @@ var PiRpc = class {
         }
       }
     };
-    proc.on("exit", done);
+    proc.on("close", done);
     proc.on("error", (e) => {
       this.stderr += `
 spawn error: ${e.message}`;
@@ -2699,7 +2734,9 @@ spawn error: ${e.message}`;
       const entry = this.pending.get(id);
       this.pending.set(id, { resolve: (d) => settle(() => resolve(d)), reject: (e) => settle(() => reject(e)) });
       try {
-        this.proc.stdin.write(payload);
+        this.proc.stdin.write(payload, (error) => {
+          if (error && this.pending.delete(id)) settle(() => reject(error));
+        });
       } catch (e) {
         this.pending.delete(id);
         settle(() => reject(e));
@@ -2708,12 +2745,11 @@ spawn error: ${e.message}`;
   }
   /** Answer an extension dialog. Without an answer the extension's tool call waits forever. */
   async respondUi(id, response) {
-    if (!this.proc || this.exited) return;
-    const record = { type: "extension_ui_response", id, ...response };
-    try {
-      this.proc.stdin.write(JSON.stringify(record) + "\n");
-    } catch {
-    }
+    if (!this.proc || this.exited) throw new Error("Pi is not running. Retry the agent before answering.");
+    const record = { ...response, type: "extension_ui_response", id };
+    await new Promise((resolve, reject) => {
+      this.proc.stdin.write(JSON.stringify(record) + "\n", (error) => error ? reject(error) : resolve());
+    });
   }
   prompt(message, behavior) {
     return this.send({ type: "prompt", message, ...behavior ? { streamingBehavior: behavior } : {} });
@@ -2732,9 +2768,8 @@ spawn error: ${e.message}`;
           proc.kill("SIGKILL");
         } catch {
         }
-        resolve();
       }, 3e3);
-      proc.once("exit", () => {
+      proc.once("close", () => {
         clearTimeout(t);
         resolve();
       });
@@ -3069,6 +3104,13 @@ function itemsFromMessages(messages) {
   }
   return items;
 }
+function readSessionMessages(file) {
+  try {
+    return fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => e.type === "message" && e.message).map((e) => e.message);
+  } catch {
+    return [];
+  }
+}
 var Chat = class {
   id;
   options;
@@ -3079,6 +3121,8 @@ var Chat = class {
   live = null;
   liveLoops = /* @__PURE__ */ new Map();
   dialogs = [];
+  answeringUi = /* @__PURE__ */ new Set();
+  dialogTimers = /* @__PURE__ */ new Map();
   notices = [];
   runs = [];
   model = null;
@@ -3086,6 +3130,9 @@ var Chat = class {
   refreshing = null;
   lastBroadcast = 0;
   stderr = "";
+  exitError = "";
+  refreshError = "";
+  stopping = false;
   file = null;
   sessionName = null;
   autoNamed = false;
@@ -3095,14 +3142,22 @@ var Chat = class {
     this.model = options.model ?? null;
     this.pi = new PiRpc({
       command: options.piCommand,
-      args: ["--session-dir", options.sessionDir, "--session-id", id, ...options.args ?? [], ...options.model ? ["--model", options.model] : []],
+      args: ["--session-dir", options.sessionDir, ...options.sessionFile ? ["--session", options.sessionFile] : ["--session-id", id], ...options.args ?? [], ...options.model ? ["--model", options.model] : []],
       cwd: options.cwd,
       onEvent: (event) => this.onEvent(event),
-      onExit: (code) => {
-        this.stderr = this.pi.stderrText;
+      onExit: (code, stderr) => {
+        this.stderr = stderr;
+        const hadDialog = this.dialogs.length > 0;
+        this.dialogs = [];
+        for (const { timer } of this.dialogTimers.values()) clearTimeout(timer);
+        this.dialogTimers.clear();
         this.live = null;
+        if (!this.stopping) {
+          const diagnostic = stderr.split("\n").map((l) => l.trim()).filter((l) => l && !/^warn(ing)?\b/i.test(l)).slice(-3).join(" \xB7 ").slice(-300);
+          this.exitError = hadDialog ? "Pi exited while an extension decision was pending. Retry the agent; if you selected a custom Pi executable, use the default Loops runner for startup-dialog support." : code === 0 ? "Pi exited unexpectedly." : `Pi exited (code ${code ?? "unknown"}).`;
+          if (diagnostic) this.exitError += ` ${diagnostic}`;
+        }
         this.broadcast(true);
-        if (code != null) this.touch();
       }
     });
   }
@@ -3133,10 +3188,21 @@ var Chat = class {
   async start() {
     if (this.started) return;
     this.started = true;
-    await this.pi.start();
+    let signalDialog;
+    const dialogReady = new Promise((resolve) => {
+      signalDialog = resolve;
+    });
     this.pi.onUiRequest((request) => {
-      if (["select", "confirm", "input", "editor"].includes(request.method)) this.dialogs.push(request);
-      else if (request.method === "notify") {
+      if (["select", "confirm", "input", "editor"].includes(request.method)) {
+        this.dialogs.push(request);
+        if (typeof request.timeout === "number" && Number.isFinite(request.timeout) && request.timeout > 0) {
+          const timeout = Math.min(request.timeout, 2 ** 31 - 1);
+          const timer = setTimeout(() => this.closeDialog(request.id), timeout);
+          timer.unref();
+          this.dialogTimers.set(request.id, { timer, deadline: Date.now() + timeout });
+        }
+        signalDialog();
+      } else if (request.method === "notify") {
         console.log(`[${this.id}] ${request.level ?? "info"}: ${request.message ?? ""}`);
         this.notices.push({ t: Date.now(), level: String(request.level ?? "info"), message: String(request.message ?? "") });
         this.notices = this.notices.slice(-20);
@@ -3144,13 +3210,15 @@ var Chat = class {
       void this.refresh();
       this.broadcast(true);
     });
+    await this.pi.start();
     if (!this.pi.running) {
       this.stderr = this.pi.stderrText;
       return;
     }
-    await this.refresh(true);
+    await Promise.race([this.refresh(true), dialogReady]);
   }
   async stop() {
+    this.stopping = true;
     await this.pi.stop();
   }
   /** Re-read the session's entries (cursor-based) and messages, then rebuild the runs. */
@@ -3178,9 +3246,10 @@ var Chat = class {
           await this.rename(auto).catch(() => {
           });
         }
+        this.refreshError = "";
       } catch (e) {
         console.error(`[${this.id}] refresh failed:`, e.message ?? e);
-        this.stderr = String(e.message ?? e);
+        this.refreshError = String(e.message ?? e);
       } finally {
         this.refreshing = null;
         this.broadcast(true);
@@ -3235,6 +3304,8 @@ var Chat = class {
       void this.refresh();
       this.broadcast(true);
     } else if (type === "extension_ui_request") {
+    } else if (type === "extension_ui_request_cancelled") {
+      this.closeDialog(String(event.id));
     } else if (type.startsWith("session_") || type === "compaction_start" || type === "compaction_end") {
       if (type === "session_idle" || type === "session_start") void this.refresh(true);
     }
@@ -3265,11 +3336,36 @@ var Chat = class {
     } catch {
     }
   }
-  async answerUi(id, response) {
+  closeDialog(id) {
+    const timed = this.dialogTimers.get(id);
+    if (timed) {
+      clearTimeout(timed.timer);
+      this.dialogTimers.delete(id);
+    }
     this.dialogs = this.dialogs.filter((d) => d.id !== id);
-    await this.pi.respondUi(id, response);
     this.broadcast(true);
   }
+  async answerUi(id, response) {
+    if (!this.isUp) throw new Error("Pi is not running. Retry the agent before answering.");
+    if ((this.dialogTimers.get(id)?.deadline ?? Infinity) <= Date.now()) this.closeDialog(id);
+    const dialog = this.dialogs.find((d) => d.id === id);
+    if (!dialog) throw new Error("This decision is no longer pending. Refresh the chat.");
+    if (this.answeringUi.has(id)) throw new Error("An answer to this decision is already being submitted.");
+    if (!response || typeof response !== "object" || Array.isArray(response)) throw new Error("Invalid decision response.");
+    if (response.cancelled !== true) {
+      if (dialog.method === "select" && (typeof response.value !== "string" || !dialog.options?.includes(response.value))) throw new Error("Choose one of the available options.");
+      if (dialog.method === "confirm" && typeof response.confirmed !== "boolean") throw new Error("A confirmation is required.");
+      if (["input", "editor"].includes(dialog.method) && typeof response.value !== "string") throw new Error("A text response is required.");
+    }
+    this.answeringUi.add(id);
+    try {
+      await this.pi.respondUi(id, response);
+      if (!this.isUp || !this.dialogs.some((d) => d.id === id)) throw new Error("This decision is no longer pending. Refresh the chat.");
+      this.closeDialog(id);
+    } finally {
+      this.answeringUi.delete(id);
+    }
+  }
   async abort() {
     await this.pi.send({ type: "abort" }).catch(() => {
     });
@@ -3341,7 +3437,7 @@ var Chat = class {
       live: this.live,
       runs,
       model: this.model,
-      error: this.pi.running ? void 0 : this.stderr || void 0,
+      error: this.pi.running ? this.refreshError || void 0 : this.exitError || this.refreshError || void 0,
       questions: runs.flatMap((r) => r.questions),
       dialogs: this.dialogs,
       notices: this.notices.slice(-6),
@@ -3357,11 +3453,17 @@ function listChats(sessionDir, cwd = process.cwd()) {
       const full = path2.join(sessionDir, f);
       let title;
       let firstUser;
+      let recordedCwd;
+      let sessionId;
       const entries = [];
       try {
         for (const line of fs2.readFileSync(full, "utf8").split("\n")) {
           if (!line.trim()) continue;
           const e = JSON.parse(line);
+          if (e.type === "session" && typeof e.cwd === "string") {
+            recordedCwd = e.cwd;
+            sessionId = e.id;
+          }
           entries.push(e);
           if ((e.type === "session_name" || e.type === "name") && e.name) title = String(e.name);
           if (!firstUser && e.type === "message" && e.message?.role === "user") {
@@ -3372,15 +3474,23 @@ function listChats(sessionDir, cwd = process.cwd()) {
       } catch {
       }
       summary = summarize(cwd, entries);
-      return { id: path2.basename(f, ".jsonl").replace(/^.*_/, ""), last: fs2.statSync(full).mtimeMs, title: title ?? (firstUser ? firstUser.replace(/\s+/g, " ").slice(0, 46) : void 0), summary };
+      return { id: path2.basename(f, ".jsonl").replace(/^.*_/, ""), last: fs2.statSync(full).mtimeMs, title: title ?? (firstUser ? firstUser.replace(/\s+/g, " ").slice(0, 46) : void 0), summary, cwd: recordedCwd, sessionId };
     });
   } catch {
     return [];
   }
-  return files.filter((f) => /^chat-/.test(f.id)).sort((a, b) => b.last - a.last).map((f) => ({ id: f.id, title: f.title ?? goalName("New chat"), ts: f.last, last: f.last, summary: f.summary }));
+  const canonical2 = (p) => {
+    try {
+      return fs2.realpathSync(p);
+    } catch {
+      return path2.resolve(p);
+    }
+  };
+  return files.filter((f) => /^chat-/.test(f.id) && (f.sessionId === void 0 || f.sessionId === f.id) && f.cwd && canonical2(f.cwd) === canonical2(cwd)).sort((a, b) => b.last - a.last).map((f) => ({ id: f.id, title: f.title ?? goalName("New chat"), ts: f.last, last: f.last, summary: f.summary }));
 }
 var ChatManager = class {
   chats = /* @__PURE__ */ new Map();
+  operations = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   base;
   /** Where a chat lives. Set by the server from the workspace registry, which owns the persistence. */
@@ -3404,33 +3514,66 @@ var ChatManager = class {
   get(id) {
     return this.chats.get(id) ?? null;
   }
-  async open(id) {
-    const existing = this.chats.get(id);
-    if (existing?.isUp) {
-      await existing.start();
-      return existing;
+  async serialize(id, operation) {
+    const result = (this.operations.get(id) ?? Promise.resolve()).then(operation);
+    const settled = result.then(() => {
+    }, () => {
+    });
+    this.operations.set(id, settled);
+    try {
+      return await result;
+    } finally {
+      if (this.operations.get(id) === settled) this.operations.delete(id);
     }
-    const where = this.bind(id);
-    const chat = new Chat(id, { ...this.base, ...where, onUpdate: (c) => {
-      for (const fn of this.listeners) {
-        try {
-          fn(c);
-        } catch {
+  }
+  open(id) {
+    return this.serialize(id, async () => {
+      const where = this.bind(id);
+      const existing = this.chats.get(id);
+      if (existing && existing.workspacePath !== where.cwd) throw new Error("chat directory does not match its Pi session");
+      if (existing) return existing;
+      const chat = new Chat(id, { ...this.base, ...where, onUpdate: (c) => {
+        for (const fn of this.listeners) {
+          try {
+            fn(c);
+          } catch {
+          }
         }
-      }
-    } });
-    this.chats.set(id, chat);
-    await chat.start();
-    return chat;
+      } });
+      this.chats.set(id, chat);
+      await chat.start();
+      return chat;
+    });
+  }
+  retry(id) {
+    return this.serialize(id, async () => {
+      const where = this.bind(id);
+      const existing = this.chats.get(id);
+      if (existing?.isUp) throw new Error("chat is already running");
+      await existing?.stop();
+      const chat = new Chat(id, { ...this.base, ...where, onUpdate: (c) => {
+        for (const fn of this.listeners) {
+          try {
+            fn(c);
+          } catch {
+          }
+        }
+      } });
+      this.chats.set(id, chat);
+      await chat.start();
+      return chat;
+    });
   }
-  async close(id) {
-    const chat = this.chats.get(id);
-    this.chats.delete(id);
-    await chat?.stop();
+  close(id, afterClose) {
+    return this.serialize(id, async () => {
+      const chat = this.chats.get(id);
+      await chat?.stop();
+      this.chats.delete(id);
+      afterClose?.();
+    });
   }
   async closeAll() {
-    await Promise.all([...this.chats.values()].map((c) => c.stop()));
-    this.chats.clear();
+    await Promise.all([.../* @__PURE__ */ new Set([...this.chats.keys(), ...this.operations.keys()])].map((id) => this.close(id)));
   }
   openChats() {
     return [...this.chats.values()];
@@ -4184,13 +4327,52 @@ import fs7 from "node:fs";
 import path7 from "node:path";
 import { execFileSync } from "node:child_process";
 var slug = (p) => path7.basename(p).replace(/[^a-z0-9._-]+/gi, "-").toLowerCase() || "repo";
+var canonical = (p) => {
+  const abs = path7.resolve(p);
+  try {
+    return fs7.realpathSync(abs);
+  } catch {
+    return abs;
+  }
+};
+var available = (p) => {
+  try {
+    return fs7.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+function header(file) {
+  const fd = fs7.openSync(file, "r");
+  try {
+    const chunks = [];
+    let size = 0;
+    while (size < 1024 * 1024) {
+      const buf = Buffer.alloc(4096);
+      const n = fs7.readSync(fd, buf, 0, buf.length, null);
+      if (!n) break;
+      const end = buf.subarray(0, n).indexOf(10);
+      chunks.push(buf.subarray(0, end < 0 ? n : end));
+      size += end < 0 ? n : end;
+      if (end >= 0) break;
+    }
+    if (size >= 1024 * 1024) throw new Error("session header too large");
+    const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (typeof result.cwd !== "string" || !result.cwd || result.id !== void 0 && typeof result.id !== "string") throw new Error("invalid session header");
+    return result;
+  } finally {
+    fs7.closeSync(fd);
+  }
+}
 var Workspaces = class {
-  /** Where workspaces.json and the per-repo session dirs live. */
   root;
   file;
   data;
   byId = /* @__PURE__ */ new Map();
   chatMap;
+  files = /* @__PURE__ */ new Map();
+  // A new chat may not have written its first session file yet. This is never persisted.
+  pending = /* @__PURE__ */ new Set();
   constructor({ root, cwd }) {
     this.root = root;
     this.file = path7.join(root, "workspaces.json");
@@ -4198,139 +4380,185 @@ var Workspaces = class {
     let data = { workspaces: [], chats: {} };
     if (fs7.existsSync(this.file)) {
       try {
-        data = JSON.parse(fs7.readFileSync(this.file, "utf8"));
+        const parsed = JSON.parse(fs7.readFileSync(this.file, "utf8"));
+        if (!Array.isArray(parsed.workspaces) || !parsed.chats || typeof parsed.chats !== "object" || Array.isArray(parsed.chats)) throw new Error("invalid registry");
+        data = parsed;
       } catch {
-        try {
-          fs7.renameSync(this.file, `${this.file}.corrupt-${Date.now()}`);
-        } catch {
-        }
-        console.error(`[workspaces] could not read ${this.file}; kept a copy and rebuilding from sessions`);
+        fs7.renameSync(this.file, `${this.file}.corrupt-${Date.now()}`);
       }
     }
-    this.data = { workspaces: data.workspaces ?? [], chats: data.chats ?? {}, default: data.default };
-    this.chatMap = new Map(Object.entries(this.data.chats));
-    const first = this.add(cwd, { persist: false });
-    this.restore();
-    if (!this.data.default || !this.byId.has(this.data.default)) this.data.default = first.id;
+    this.data = { version: 2, workspaces: [], chats: {}, default: data.default };
+    this.chatMap = new Map(Object.entries(data.chats));
+    if (data.files && typeof data.files === "object") {
+      for (const [chat, files] of Object.entries(data.files)) {
+        if (Array.isArray(files) && files.every((f) => typeof f === "string")) this.files.set(chat, new Set(files));
+      }
+    }
+    for (const w of data.workspaces) {
+      if (!w || typeof w.id !== "string" || typeof w.path !== "string" || this.byId.has(w.id)) continue;
+      const p = canonical(w.path);
+      const legacy = path7.join(p, ".pi", "loops-ui", "sessions");
+      const sessionDir = w.sessionDir ?? (fs7.existsSync(legacy) ? legacy : path7.join(root, "workspaces", w.id, "sessions"));
+      this.byId.set(w.id, { id: w.id, path: p, sessionDir, title: path7.basename(p) || p, open: w.open !== false, available: available(p) });
+    }
+    this.recoverSessions(void 0, data.version !== 2);
+    if (cwd && ![...this.byId.values()].some((w) => w.path === canonical(cwd))) {
+      this.add(cwd);
+    }
     this.save();
   }
   save() {
+    this.data.workspaces = [...this.byId.values()].map(({ id, path: p, sessionDir, open }) => ({ id, path: p, sessionDir, open }));
     this.data.chats = Object.fromEntries(this.chatMap);
-    try {
-      const tmp = `${this.file}.tmp`;
-      fs7.writeFileSync(tmp, JSON.stringify(this.data, null, 2) + "\n");
-      fs7.renameSync(tmp, this.file);
-    } catch {
-    }
+    this.data.files = Object.fromEntries([...this.files].map(([chat, files]) => [chat, [...files]]));
+    const tmp = `${this.file}.tmp`;
+    fs7.writeFileSync(tmp, JSON.stringify(this.data, null, 2) + "\n");
+    fs7.renameSync(tmp, this.file);
   }
   get defaultId() {
-    return this.data.default ?? [...this.byId.keys()][0] ?? "";
+    return this.get()?.id ?? "";
   }
   list() {
-    return [...this.byId.values()];
+    return [...this.byId.values()].map((w) => ({ ...w, available: available(w.path) }));
   }
   get(id) {
-    return this.byId.get(id ?? "") ?? this.byId.get(this.defaultId) ?? null;
+    const w = id != null ? this.byId.get(id) : this.byId.get(this.data.default ?? "")?.open ? this.byId.get(this.data.default) : [...this.byId.values()].find((x) => x.open);
+    return w ? { ...w, available: available(w.path) } : null;
   }
-  /** Add (or re-find) a repo. `persist: false` is used for the startup cwd. */
-  add(dir, { persist = true } = {}) {
-    const abs = path7.resolve(dir);
-    const existing = [...this.byId.values()].find((w) => w.path === abs);
+  register(p, sessionDir, preferredId) {
+    const existing = [...this.byId.values()].find((w) => w.path === p);
     if (existing) return existing;
-    if (!fs7.existsSync(abs) || !fs7.statSync(abs).isDirectory()) throw new Error(`${abs} is not a directory`);
-    const st = fs7.statSync(abs);
-    if (!st.isDirectory()) throw new Error(`${abs} is not a directory`);
-    let id = slug(abs);
-    for (let i = 2; this.byId.has(id); i++) id = `${slug(abs)}-${i}`;
-    const legacy = path7.join(abs, ".pi", "loops-ui", "sessions");
-    const sessionDir = fs7.existsSync(legacy) ? legacy : path7.join(this.root, "workspaces", id, "sessions");
-    const ws = { id, path: abs, sessionDir, title: path7.basename(abs) || abs };
-    fs7.mkdirSync(ws.sessionDir, { recursive: true });
+    let id = preferredId && !this.byId.has(preferredId) ? preferredId : slug(p);
+    for (let i = 2; this.byId.has(id); i++) id = `${slug(p)}-${i}`;
+    const legacy = path7.join(p, ".pi", "loops-ui", "sessions");
+    const ws = { id, path: p, sessionDir: sessionDir ?? (fs7.existsSync(legacy) ? legacy : path7.join(this.root, "workspaces", id, "sessions")), title: path7.basename(p) || p, open: true, available: available(p) };
     this.byId.set(id, ws);
-    if (persist) {
-      this.data.workspaces = [...this.data.workspaces.filter((w) => w.path !== abs), { id, path: abs }];
-      this.save();
-    }
     return ws;
   }
-  /** Register the persisted workspaces (their paths may have been deleted since), then rebuild from Pi sessions. */
+  add(dir) {
+    const p = canonical(dir);
+    if (!available(p)) throw new Error(`${p} is not a directory`);
+    const ws = this.register(p);
+    ws.open = true;
+    fs7.mkdirSync(ws.sessionDir, { recursive: true });
+    if (!this.data.default || !this.byId.get(this.data.default)?.open) this.data.default = ws.id;
+    this.recoverSessions([ws.sessionDir], false);
+    this.save();
+    return this.get(ws.id);
+  }
+  /** Re-scan sessions, including legacy session directories. */
   restore() {
-    for (const w of this.data.workspaces) {
-      try {
-        this.add(w.path);
-      } catch {
-      }
-    }
-    this.recoverSessions();
+    this.recoverSessions(void 0, false);
     this.save();
   }
-  /**
-   * Chat -> repo is recoverable from Pi itself: each session header carries `cwd`, and the session dir names the
-   * workspace. This runs on startup, so a lost or stale `workspaces.json` is a cache miss, not lost history.
-   */
-  recoverSessions() {
-    const root = path7.join(this.root, "workspaces");
-    let ids = [];
-    try {
-      ids = fs7.readdirSync(root);
-    } catch {
-      return;
-    }
-    for (const id of ids) {
-      const dir = path7.join(root, id, "sessions");
-      let files = [];
+  recoverSessions(onlyDirs, rebind = true) {
+    const dirs = new Set(onlyDirs ?? [...this.byId.values()].map((w) => w.sessionDir));
+    const base = path7.join(this.root, "workspaces");
+    if (!onlyDirs && fs7.existsSync(base)) for (const id of fs7.readdirSync(base)) dirs.add(path7.join(base, id, "sessions"));
+    for (const dir of dirs) {
+      let names;
       try {
-        files = fs7.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+        names = fs7.readdirSync(dir).filter((n) => n.endsWith(".jsonl"));
       } catch {
         continue;
       }
-      let cwd = null;
-      for (const f of files) {
-        try {
-          const head = JSON.parse(fs7.readFileSync(path7.join(dir, f), "utf8").split("\n")[0]);
-          if (typeof head?.cwd === "string" && head.cwd) {
-            cwd = head.cwd;
-            break;
-          }
-        } catch {
-        }
-      }
-      let ws = this.byId.get(id) ?? null;
-      if (!ws && cwd) {
+      for (const name of names) {
+        const chat = path7.basename(name, ".jsonl").replace(/^.*_/, "");
+        if (!chat.startsWith("chat-")) continue;
+        const file = path7.join(dir, name);
+        const files = this.files.get(chat) ?? /* @__PURE__ */ new Set();
+        files.add(file);
+        this.files.set(chat, files);
+        let cwd;
         try {
-          ws = this.add(cwd);
-          if (ws.id !== id) ws.sessionDir = dir;
+          const head = header(file);
+          if (head.id !== void 0 && head.id !== chat) continue;
+          cwd = canonical(head.cwd);
         } catch {
+          continue;
         }
-      }
-      if (!ws) continue;
-      for (const f of files) {
-        const chat = f.replace(/\.jsonl$/, "").replace(/^.*_/, "");
-        if (/^chat-/.test(chat) && !this.chatMap.has(chat)) this.chatMap.set(chat, ws.id);
+        const parent = path7.dirname(dir);
+        const preferred = path7.dirname(parent) === base ? path7.basename(parent) : void 0;
+        const ws = this.register(cwd, dir, preferred);
+        if (rebind || !this.chatMap.has(chat)) this.chatMap.set(chat, ws.id);
       }
     }
   }
   remove(id) {
-    if (id === this.defaultId) throw new Error("cannot remove the workspace this app was started in");
-    this.byId.delete(id);
-    this.data.workspaces = this.data.workspaces.filter((w) => w.id !== id);
-    for (const [chat, ws] of this.chatMap) if (ws === id) this.chatMap.delete(chat);
+    const ws = this.byId.get(id);
+    if (!ws) throw new Error(`unknown workspace: ${id}`);
+    ws.open = false;
     this.save();
   }
-  /** Which workspace a chat belongs to. Unknown ids fall back to the default (older chats predate the registry). */
+  hasChat(chat) {
+    return this.chatMap.has(chat) && this.byId.has(this.chatMap.get(chat));
+  }
   ofChat(chat) {
-    return this.get(this.chatMap.get(chat)) ?? this.get();
+    const ws = this.get(this.chatMap.get(chat) ?? "");
+    if (!ws) throw new Error(`unknown chat: ${chat}`);
+    const files = this.candidates(chat, ws);
+    if (files.length === 0 && !this.pending.has(chat)) throw new Error(`missing session for chat: ${chat}`);
+    if (files.length > 1) throw new Error(`ambiguous session for chat: ${chat}`);
+    if (files.length === 1 && !this.validFile(files[0], chat, ws)) throw new Error(`invalid session for chat: ${chat}`);
+    return ws;
   }
   bindChat(chat, ws) {
-    if (this.byId.has(ws)) {
-      this.chatMap.set(chat, ws);
+    if (!this.byId.has(ws)) throw new Error(`unknown workspace: ${ws}`);
+    const existing = this.chatMap.get(chat);
+    if (existing && existing !== ws) throw new Error(`chat ${chat} is already bound to ${existing}`);
+    if (!existing) this.pending.add(chat);
+    this.chatMap.set(chat, ws);
+    this.save();
+  }
+  unbindChat(chat) {
+    if (this.chatMap.delete(chat)) {
+      this.pending.delete(chat);
+      this.files.delete(chat);
       this.save();
     }
   }
-  unbindChat(chat) {
-    if (this.chatMap.delete(chat)) this.save();
+  /** All known session directories for this workspace, including recovered secondary directories. */
+  sessionDirs(id) {
+    const ws = this.get(id);
+    if (!ws) return [];
+    const dirs = /* @__PURE__ */ new Set([ws.sessionDir]);
+    for (const [chat, files] of this.files) {
+      if (this.chatMap.get(chat) === id) for (const file of files) dirs.add(path7.dirname(file));
+    }
+    return [...dirs];
+  }
+  candidates(chat, ws) {
+    const files = new Set(this.files.get(chat) ?? []);
+    const oldSize = files.size;
+    for (const dir of this.sessionDirs(ws.id)) {
+      try {
+        for (const name of fs7.readdirSync(dir)) {
+          if (name.endsWith(".jsonl") && path7.basename(name, ".jsonl").replace(/^.*_/, "") === chat) files.add(path7.join(dir, name));
+        }
+      } catch {
+      }
+    }
+    if (files.size) this.pending.delete(chat);
+    if (files.size !== oldSize) {
+      this.files.set(chat, files);
+      this.save();
+    }
+    return [...files];
+  }
+  validFile(file, chat, ws) {
+    try {
+      const h = header(file);
+      return (h.id === void 0 || h.id === chat) && canonical(h.cwd) === ws.path;
+    } catch {
+      return false;
+    }
+  }
+  sessionFile(chat) {
+    if (!this.hasChat(chat)) return null;
+    const ws = this.get(this.chatMap.get(chat));
+    const files = this.candidates(chat, ws);
+    return files.length === 1 && this.validFile(files[0], chat, ws) ? files[0] : null;
   }
-  /** A repo is loopable when git can name a commit in it; that is what the sidebar shows. */
   static loopable(dir) {
     try {
       execFileSync("git", ["rev-parse", "HEAD"], { cwd: dir, stdio: "pipe" });
@@ -4341,9 +4569,48 @@ var Workspaces = class {
   }
 };
 
+// server/directories.ts
+import fs8 from "node:fs/promises";
+import os4 from "node:os";
+import path8 from "node:path";
+import { execFile } from "node:child_process";
+function directoryPath(value) {
+  if (typeof value !== "string" || !value.trim()) throw new Error("an absolute directory path is required");
+  const expanded = value.trim().replace(/^~(?=\/|$)/, os4.homedir());
+  if (!path8.isAbsolute(expanded)) throw new Error("use an absolute path on the server, or ~/ for its home directory");
+  return expanded;
+}
+async function browseDirectories(value, hidden = false) {
+  const requested = value === void 0 ? os4.homedir() : directoryPath(value);
+  const dir = await fs8.realpath(requested);
+  const entries = [];
+  let scanned = 0, truncated = false;
+  const handle = await fs8.opendir(dir);
+  for await (const entry of handle) {
+    if (++scanned > 1e4) {
+      truncated = true;
+      break;
+    }
+    if (!hidden && entry.name.startsWith(".")) continue;
+    const full = path8.join(dir, entry.name);
+    const symlink = entry.isSymbolicLink();
+    if (!entry.isDirectory() && !(symlink && await fs8.stat(full).then((s) => s.isDirectory(), () => false))) continue;
+    entries.push({ name: entry.name, path: full, symlink });
+    if (entries.length >= 500) {
+      truncated = true;
+      break;
+    }
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  const loopable = await new Promise((resolve) => {
+    execFile("git", ["rev-parse", "--verify", "HEAD"], { cwd: dir, timeout: 2e3 }, (e) => resolve(!e));
+  });
+  return { path: dir, parent: path8.dirname(dir) === dir ? null : path8.dirname(dir), home: os4.homedir(), entries, truncated, loopable };
+}
+
 // server/index.ts
-var HERE = path8.dirname(fileURLToPath(import.meta.url));
-var APP_ROOT = path8.resolve(HERE, "..");
+var HERE = path9.dirname(fileURLToPath(import.meta.url));
+var APP_ROOT = path9.resolve(HERE, "..");
 var arg = (name, fallback) => {
   const i = process.argv.indexOf(`--${name}`);
   return i >= 0 ? process.argv[i + 1] : process.env[`LOOPS_UI_${name.toUpperCase().replace(/-/g, "_")}`] ?? fallback;
@@ -4351,16 +4618,24 @@ var arg = (name, fallback) => {
 var PORT = Number(arg("port", "8001"));
 var HOST = arg("host", "127.0.0.1");
 var LOOPBACK = ["127.0.0.1", "localhost", "::1"].includes(HOST);
-var CWD = path8.resolve(arg("cwd", process.cwd()));
+var PUBLIC_ORIGINS = [...new Set((arg("public-origin", "") ?? "").split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
+  const url = new URL(s);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.pathname !== "/" || url.search || url.hash) {
+    throw new Error(`--public-origin must contain HTTP(S) origins, not paths or credentials: ${s}`);
+  }
+  return url.origin;
+}))];
+var SEED = arg("cwd");
+var CWD = SEED ? path9.resolve(SEED) : null;
 var DEV = process.argv.includes("--dev") || process.env.NODE_ENV === "development";
 var VITE = arg("vite", "http://localhost:5173");
-var PI = arg("pi", "pi");
-var DATA = path8.resolve(arg("data", process.env.LOOPS_UI_DATA ?? path8.join(process.env.HOME ?? process.cwd(), ".pi", "loops-ui")));
+var PI = arg("pi", path9.join(APP_ROOT, "bin", "pi-rpc.mjs"));
+var DATA = path9.resolve(arg("data", process.env.LOOPS_UI_DATA ?? path9.join(process.env.HOME ?? process.cwd(), ".pi", "loops-ui")));
 var MODEL = arg("model", void 0) || null;
-var EXTENSIONS = (arg("extensions", path8.resolve(APP_ROOT, "../pi-loops/extensions/loop.ts")) ?? "").split(",").filter(Boolean);
+var EXTENSIONS = (arg("extensions", path9.resolve(APP_ROOT, "../pi-loops/extensions/loop.ts")) ?? "").split(",").filter(Boolean);
 function prerequisites() {
   const out = [];
-  const onPath = PI.includes("/") || /^[A-Za-z]:\\/.test(PI) ? fs8.existsSync(PI) : (() => {
+  const onPath = PI.includes("/") || /^[A-Za-z]:\\/.test(PI) ? fs9.existsSync(PI) : (() => {
     try {
       execFileSync2(process.platform === "win32" ? "where" : "which", [PI], { stdio: ["ignore", "pipe", "ignore"] });
       return true;
@@ -4370,18 +4645,18 @@ function prerequisites() {
   })();
   if (!onPath) out.push({ name: "pi", detail: `\`${PI}\` is not on PATH`, fix: "install Pi, or pass --pi <path to the pi binary>" });
   for (const e of EXTENSIONS) {
-    if (!fs8.existsSync(e)) out.push({ name: "extension", detail: `${e} does not exist`, fix: "pi install npm:@computesdk/pi-loops, or pass --extensions <path to extensions/loop.ts>" });
+    if (!fs9.existsSync(e)) out.push({ name: "extension", detail: `${e} does not exist`, fix: "pi install npm:@computesdk/pi-loops, or pass --extensions <path to extensions/loop.ts>" });
   }
   return out;
 }
 var PROBLEMS = prerequisites();
-fs8.mkdirSync(DATA, { recursive: true });
+fs9.mkdirSync(DATA, { recursive: true });
 var TOKEN = (() => {
   const explicit = arg("token", void 0);
-  const file = path8.join(DATA, "token");
+  const file = path9.join(DATA, "token");
   const stored = (() => {
     try {
-      return fs8.readFileSync(file, "utf8").trim() || null;
+      return fs9.readFileSync(file, "utf8").trim() || null;
     } catch {
       return null;
     }
@@ -4389,7 +4664,7 @@ var TOKEN = (() => {
   if (explicit) {
     if (!LOOPBACK) {
       try {
-        fs8.writeFileSync(file, explicit + "\n", { mode: 384 });
+        fs9.writeFileSync(file, explicit + "\n", { mode: 384 });
       } catch {
       }
     }
@@ -4398,32 +4673,53 @@ var TOKEN = (() => {
   if (stored) return stored;
   if (LOOPBACK) return null;
   const made = randomBytes(24).toString("base64url");
-  fs8.writeFileSync(file, made + "\n", { mode: 384 });
+  fs9.writeFileSync(file, made + "\n", { mode: 384 });
   return made;
 })();
 if (!LOOPBACK && !TOKEN) {
   console.error(`refusing to listen on ${HOST} without a token: this UI drives an agent that has bash. Pass --token <secret> (or let it generate one in ${DATA}/token).`);
   process.exit(2);
 }
-var workspaces = new Workspaces({ root: DATA, cwd: CWD });
+var workspaces = new Workspaces({ root: DATA, ...CWD ? { cwd: CWD } : {} });
+var requireWorkspace = (id) => {
+  const ws = workspaces.get(id);
+  if (!ws) throw new HTTPException(404, { message: id ? `unknown workspace: ${id}` : "choose a workspace first" });
+  if (!ws.available) throw new HTTPException(409, { message: `workspace directory is unavailable: ${ws.path}` });
+  return ws;
+};
+var requireChatWorkspace = (id) => {
+  if (!workspaces.hasChat(id)) throw new HTTPException(404, { message: `unknown chat: ${id}` });
+  let ws;
+  try {
+    ws = workspaces.ofChat(id);
+  } catch (e) {
+    throw new HTTPException(409, { message: e.message });
+  }
+  return requireWorkspace(ws.id);
+};
 var manager = new ChatManager({
   piCommand: PI,
   args: EXTENSIONS.flatMap((e) => ["-e", e]),
   model: MODEL,
   // a chat's repo comes from the registry: the browser never hands us a path
   bind: (chat) => {
-    const ws = workspaces.ofChat(chat);
-    return { cwd: ws.path, sessionDir: ws.sessionDir };
+    const ws = requireChatWorkspace(chat);
+    return { cwd: ws.path, sessionDir: ws.sessionDir, sessionFile: workspaces.sessionFile(chat) ?? void 0 };
   }
 });
-var wsOf = (chat) => chat ? workspaces.ofChat(chat) : workspaces.get();
+var wsOf = (chat) => chat ? requireChatWorkspace(chat) : requireWorkspace();
 var wsOfRun = (run3) => {
-  const byIndex = workspaces.list().find((w) => fs8.existsSync(path8.join(w.path, STATE_DIR, `${run3}.json`)));
+  const byIndex = workspaces.list().find((w) => fs9.existsSync(path9.join(w.path, STATE_DIR, `${run3}.json`)));
   if (byIndex) return byIndex;
   const chat = manager.findRun(run3);
-  return chat ? workspaces.ofChat(chat.id) : workspaces.get();
+  if (chat) return requireChatWorkspace(chat.id);
+  throw new HTTPException(404, { message: `unknown run: ${run3}` });
+};
+var listWorkspaceChats = (ws) => {
+  const all = workspaces.sessionDirs(ws.id).flatMap((sessionDir) => manager.list({ ...ws, sessionDir }));
+  return [...new Map(all.map((chat) => [chat.id, chat])).values()].sort((a, b) => b.last - a.last);
 };
-var chatsOf = (wsId) => wsId ? manager.list(workspaces.get(wsId)) : workspaces.list().flatMap((w) => manager.list(w));
+var chatsOf = (wsId) => wsId ? listWorkspaceChats(requireWorkspace(wsId)) : workspaces.list().filter((w) => w.available).flatMap(listWorkspaceChats);
 var withLive = (state) => {
   for (const run3 of state.runs ?? []) {
     const url = liveUrl(run3.id);
@@ -4446,7 +4742,7 @@ var watchOf = (wsId) => {
   if (!w) {
     const read = () => {
       try {
-        return JSON.parse(fs8.readFileSync(path8.join(ws.path, ".pi", "loops.json"), "utf8"));
+        return JSON.parse(fs9.readFileSync(path9.join(ws.path, ".pi", "loops.json"), "utf8"));
       } catch {
         return {};
       }
@@ -4454,7 +4750,7 @@ var watchOf = (wsId) => {
     w = { cwd: ws.path, accepted: read() };
     watches.set(ws.id, w);
     try {
-      fs8.watch(path8.join(ws.path, ".pi"), (_e, name) => {
+      fs9.watch(path9.join(ws.path, ".pi"), (_e, name) => {
         if (name && name !== "loops.json") return;
         clearTimeout(watchTimers.get(ws.id));
         watchTimers.set(ws.id, setTimeout(() => checkConfig(ws.id), 120));
@@ -4476,10 +4772,10 @@ function notifyProposals() {
 }
 function checkConfig(wsId) {
   const w = watchOf(wsId);
-  const CONFIG = path8.join(w.cwd, ".pi", "loops.json");
+  const CONFIG = path9.join(w.cwd, ".pi", "loops.json");
   const raw2 = (() => {
     try {
-      return fs8.readFileSync(CONFIG, "utf8");
+      return fs9.readFileSync(CONFIG, "utf8");
     } catch {
       return "";
     }
@@ -4500,13 +4796,13 @@ function checkConfig(wsId) {
   notifyProposals();
 }
 var inside = (root, p) => {
-  const abs = path8.resolve(root, p);
-  return abs === root || abs.startsWith(root + path8.sep) ? abs : null;
+  const abs = path9.resolve(root, p);
+  return abs === root || abs.startsWith(root + path9.sep) ? abs : null;
 };
 var stateOf = (run3) => manager.findRun(run3)?.stateFor(run3) ?? readState(wsOfRun(run3).path, run3);
 var app = new Hono3();
-var OWN_HOSTS = /* @__PURE__ */ new Set([`127.0.0.1:${PORT}`, `localhost:${PORT}`, `[::1]:${PORT}`]);
-var OWN_ORIGINS = new Set([...OWN_HOSTS].map((h) => `http://${h}`));
+var OWN_HOSTS = /* @__PURE__ */ new Set([`127.0.0.1:${PORT}`, `localhost:${PORT}`, `[::1]:${PORT}`, ...PUBLIC_ORIGINS.map((o) => new URL(o).host)]);
+var OWN_ORIGINS = /* @__PURE__ */ new Set([`http://127.0.0.1:${PORT}`, `http://localhost:${PORT}`, `http://[::1]:${PORT}`, ...PUBLIC_ORIGINS]);
 var ALLOWED_ORIGINS = (arg("allow-origin", "") ?? "").split(",").map((o) => o.trim()).filter(Boolean);
 var originAllowed = (origin) => {
   if (ALLOWED_ORIGINS.includes("*")) return true;
@@ -4544,6 +4840,11 @@ app.use("/api/v1/*", async (c, next) => {
   await next();
 });
 var api = new Hono3();
+api.onError((error, c) => {
+  if (error instanceof HTTPException) return c.json({ error: error.message }, error.status);
+  console.error(error);
+  return c.json({ error: error.message }, 500);
+});
 api.get("/health", (c) => c.json({ ok: PROBLEMS.length === 0, problems: PROBLEMS, cwd: CWD, data: DATA, pi: PI, extensions: EXTENSIONS, workspaces: workspaces.list() }));
 api.get("/credentials", (c) => c.json({ dir: agentDir2(), providers: credentialStatus() }));
 api.post("/credentials", async (c) => {
@@ -4564,7 +4865,7 @@ api.post("/credentials", async (c) => {
         }
       }
     }
-    const verified = model ? { model, ...await verifyModel({ pi: PI, model, cwd: CWD }) } : null;
+    const verified = model ? { model, ...await verifyModel({ pi: PI, model, cwd: CWD ?? DATA }) } : null;
     return c.json({ ok: true, provider, file, configured: credentialStatus().find((s) => s.id === provider)?.configured ?? true, verified });
   } catch (e) {
     return c.json({ error: String(e.message ?? e).slice(0, 200) }, 400);
@@ -4578,16 +4879,20 @@ api.get("/chats/:id/events", async (c) => {
   return streamSSE(c, async (stream2) => {
     const send = (event, data, cursor) => stream2.writeSSE({ event, data: JSON.stringify(data), ...cursor ? { id: cursor } : {} }).catch(() => {
     });
-    await send("state", snapshotOf(chat, space.id), chat.entryCursor);
     const entry = { chat: id, send };
     streams.add(entry);
+    const aborted = new Promise((resolve) => stream2.onAbort(resolve));
     const ping = setInterval(() => {
       void stream2.writeSSE({ event: "ping", data: "{}" }).catch(() => {
       });
     }, 2e4);
-    await new Promise((resolve) => stream2.onAbort(resolve));
-    clearInterval(ping);
-    streams.delete(entry);
+    try {
+      await send("state", snapshotOf(chat, space.id), chat.entryCursor);
+      await aborted;
+    } finally {
+      clearInterval(ping);
+      streams.delete(entry);
+    }
   });
 });
 api.get("/state", async (c) => {
@@ -4599,34 +4904,48 @@ api.get("/state", async (c) => {
 });
 api.post("/chat", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const ws = workspaces.get(body.ws) ?? workspaces.get();
-  const id = String(body.id ?? `chat-${Date.now().toString(36)}`).replace(/[^a-zA-Z0-9._-]/g, "").slice(0, 60);
-  workspaces.bindChat(id, ws.id);
+  if (!body || typeof body !== "object") return c.json({ error: "a chat request object is required" }, 400);
+  let id;
+  let ws;
+  if (body.id !== void 0) {
+    id = String(body.id);
+    ws = requireChatWorkspace(id);
+    if (body.ws !== void 0 && body.ws !== ws.id) return c.json({ error: "an existing chat cannot move to another workspace" }, 409);
+  } else {
+    if (typeof body.ws !== "string" || !body.ws) return c.json({ error: "workspace required for a new chat" }, 400);
+    ws = requireWorkspace(body.ws);
+    if (!ws.open) return c.json({ error: "open the workspace before creating a chat" }, 409);
+    id = `chat-${randomUUID()}`;
+    workspaces.bindChat(id, ws.id);
+  }
   watchOf(ws.id);
   await manager.open(id);
   return c.json({ chat: id, ws: ws.id, chats: chatsOf(ws.id) });
 });
 api.post("/chat/delete", async (c) => {
   const { chat: id } = await c.req.json();
-  const chat = manager.get(String(id));
-  const file = chat?.sessionFile ?? null;
-  await manager.close(String(id));
-  workspaces.unbindChat(String(id));
-  if (file && fs8.existsSync(file)) {
-    try {
-      fs8.rmSync(file);
-    } catch {
-    }
-  }
+  requireChatWorkspace(String(id));
+  await manager.close(String(id), () => {
+    const file = workspaces.sessionFile(String(id));
+    if (file && fs9.existsSync(file)) fs9.unlinkSync(file);
+    workspaces.unbindChat(String(id));
+  });
   return c.json({ ok: true });
 });
 api.get("/workspaces", (c) => c.json(workspaces.list()));
+api.get("/directories", async (c) => {
+  try {
+    return c.json(await browseDirectories(c.req.query("path"), c.req.query("hidden") === "1"));
+  } catch (e) {
+    const error = e;
+    return c.json({ error: error.message }, error.code === "EACCES" || error.code === "EPERM" ? 403 : error.code === "ENOENT" || error.code === "ENOTDIR" ? 404 : 400);
+  }
+});
 api.post("/workspaces", async (c) => {
   const body = await c.req.json().catch(() => ({}));
   try {
-    const dir = path8.resolve(String(body.path ?? "").replace(/^~(?=\/|$)/, process.env.HOME ?? "~"));
-    if (!dir || dir === "/") throw new Error("a path is required");
-    if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) throw new Error(`${dir} is not a directory`);
+    const dir = directoryPath(body.path);
+    if (!fs9.existsSync(dir) || !fs9.statSync(dir).isDirectory()) throw new Error(`${dir} is not a directory`);
     const ws = workspaces.add(dir);
     watchOf(ws.id);
     return c.json({ ok: true, workspace: ws, loopable: Workspaces.loopable(ws.path) });
@@ -4636,6 +4955,7 @@ api.post("/workspaces", async (c) => {
 });
 api.post("/workspaces/remove", async (c) => {
   const { id } = await c.req.json();
+  if (!workspaces.get(String(id))) return c.json({ error: `unknown workspace: ${id}` }, 404);
   try {
     workspaces.remove(String(id));
     return c.json({ ok: true });
@@ -4661,11 +4981,25 @@ api.post("/abort", async (c) => {
   await chat.abort();
   return c.json({ ok: true });
 });
+api.post("/chat/retry", async (c) => {
+  const { chat: id } = await c.req.json();
+  requireChatWorkspace(String(id));
+  try {
+    await manager.retry(String(id));
+    return c.json({ ok: true });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 409);
+  }
+});
 api.post("/ui", async (c) => {
   const { chat: id, id: dialogId, response } = await c.req.json();
   const chat = await manager.open(String(id));
-  await chat.answerUi(String(dialogId), response ?? {});
-  return c.json({ ok: true });
+  try {
+    await chat.answerUi(String(dialogId), response ?? {});
+    return c.json({ ok: true });
+  } catch (e) {
+    return c.json({ ok: false, error: String(e.message ?? e) }, 409);
+  }
 });
 api.post("/answer", async (c) => {
   const { chat: id, question, choice } = await c.req.json();
@@ -4710,9 +5044,8 @@ api.get("/session", async (c) => {
   if (!run3 || !name) return c.json([]);
   const state = stateOf(run3);
   const file = state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label === name)?.session ?? state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label?.toLowerCase() === name.toLowerCase())?.session;
-  if (!file || !fs8.existsSync(file)) return c.json([]);
-  const chat = await manager.open(c.req.query("chat") ?? manager.list()[0]?.id ?? "");
-  return c.json(chat.sessionItems(file));
+  if (!file || !fs9.existsSync(file)) return c.json([]);
+  return c.json(itemsFromMessages(readSessionMessages(file)));
 });
 api.post("/talk", async (c) => {
   const { chat: id, run: run3, name, text } = await c.req.json();
@@ -4729,21 +5062,22 @@ api.get("/shot", (c) => {
   const repo = wsOfRun(run3).path;
   if (file.startsWith(STATE_DIR)) {
     const abs2 = inside(repo, file);
-    if (!abs2 || !fs8.existsSync(abs2)) return c.notFound();
-    return new Response(fs8.readFileSync(abs2), { headers: { "content-type": abs2.endsWith(".jpg") || abs2.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
+    if (!abs2 || !fs9.existsSync(abs2)) return c.notFound();
+    return new Response(fs9.readFileSync(abs2), { headers: { "content-type": abs2.endsWith(".jpg") || abs2.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
   }
   const dir = attempt === "CURRENT" ? state?.best?.dir ?? null : state?.rounds?.flatMap((r) => r.attempts).find((a) => a.label === attempt || a.label?.toLowerCase() === attempt.toLowerCase())?.dir;
   if (!dir) return c.notFound();
-  const abs = inside(repo, path8.join(dir, file));
-  if (!abs || !fs8.existsSync(abs)) return c.notFound();
-  return new Response(fs8.readFileSync(abs), { headers: { "content-type": abs.endsWith(".jpg") || abs.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
+  const abs = inside(repo, path9.join(dir, file));
+  if (!abs || !fs9.existsSync(abs)) return c.notFound();
+  return new Response(fs9.readFileSync(abs), { headers: { "content-type": abs.endsWith(".jpg") || abs.endsWith(".jpeg") ? "image/jpeg" : "image/png", "cache-control": "no-cache" } });
 });
 api.get("/sheet", (c) => {
   const file = c.req.query("f") ?? "";
-  const ws = workspaces.list().find((w) => fs8.existsSync(path8.join(w.path, file))) ?? workspaces.get();
+  const ws = c.req.query("run") ? wsOfRun(c.req.query("run")) : workspaces.list().find((w) => fs9.existsSync(path9.join(w.path, file)));
+  if (!ws) return c.notFound();
   const abs = inside(ws.path, file);
-  if (!abs || !abs.includes(STATE_DIR) || !fs8.existsSync(abs)) return c.notFound();
-  return new Response(fs8.readFileSync(abs), { headers: { "content-type": "image/png", "cache-control": "no-cache" } });
+  if (!abs || !abs.includes(STATE_DIR) || !fs9.existsSync(abs)) return c.notFound();
+  return new Response(fs9.readFileSync(abs), { headers: { "content-type": "image/png", "cache-control": "no-cache" } });
 });
 api.get("/diff", async (c) => {
   const run3 = c.req.query("run") ?? "";
@@ -4756,8 +5090,8 @@ api.get("/diff", async (c) => {
   const from = state.baseCommit;
   if (!to || !from) return c.text("");
   return c.text(await new Promise((resolve) => {
-    execFile("git", ["diff", "--stat", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e, stat) => {
-      execFile("git", ["diff", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e2, diff) => resolve(`${stat}
+    execFile2("git", ["diff", "--stat", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e, stat) => {
+      execFile2("git", ["diff", `${from}..${to}`], { cwd: wsOfRun(run3).path, maxBuffer: 1 << 26 }, (_e2, diff) => resolve(`${stat}
 ${diff}`.slice(0, 4e5)));
     });
   }));
@@ -4780,7 +5114,7 @@ api.get("/proposals", (c) => c.json(proposals));
 api.post("/proposals/:id/apply", (c) => {
   const p = proposals.find((x) => x.id === c.req.param("id"));
   if (!p) return c.json({ ok: false, error: "no such proposal" }, 404);
-  const cwd = p.ws ? workspaces.get(p.ws).path : CWD;
+  const cwd = requireWorkspace(p.ws).path;
   acceptConfig(cwd, p.after);
   const w = p.ws ? watches.get(p.ws) : null;
   if (w) w.accepted = p.after;
@@ -4807,7 +5141,7 @@ api.post("/config", async (c) => {
     writeSetting(ws.path, String(key), value);
     const w = watchOf(ws.id);
     try {
-      w.accepted = JSON.parse(fs8.readFileSync(path8.join(ws.path, ".pi", "loops.json"), "utf8"));
+      w.accepted = JSON.parse(fs9.readFileSync(path9.join(ws.path, ".pi", "loops.json"), "utf8"));
     } catch {
     }
     return c.json({ ok: true });
@@ -4824,7 +5158,7 @@ api.get("/size", async (c) => {
   const state = stateOf(run3);
   if (!state) return c.json({ bytes: 0, dirs: 0 });
   const dirs = (state.rounds ?? []).flatMap((r) => r.attempts).map((a) => a.dir).filter(Boolean);
-  const bytes = await new Promise((resolve) => execFile("du", ["-sk", ...dirs], { cwd: wsOfRun(run3).path }, (_e, out) => resolve(Number(String(out ?? "").split("\n").map((l) => Number(l.split(/\s+/)[0]) || 0).reduce((a, b) => a + b, 0)) * 1024)));
+  const bytes = await new Promise((resolve) => execFile2("du", ["-sk", ...dirs], { cwd: wsOfRun(run3).path }, (_e, out) => resolve(Number(String(out ?? "").split("\n").map((l) => Number(l.split(/\s+/)[0]) || 0).reduce((a, b) => a + b, 0)) * 1024)));
   return c.json({ bytes, dirs: dirs.length });
 });
 api.get("/files", (c) => {
@@ -4854,7 +5188,8 @@ api.get("/meta", (c) => c.json({
 }));
 app.route("/api", api);
 app.route("/api/v1", api);
-var DIST = path8.join(APP_ROOT, "dist");
+app.all("/api/*", (c) => c.json({ error: `unknown API route: ${c.req.path}` }, 404));
+var DIST = path9.join(APP_ROOT, "dist");
 app.get("*", async (c) => {
   const url = c.req.path;
   if (DEV) {
@@ -4863,14 +5198,14 @@ app.get("*", async (c) => {
     return new Response(res.body, { status: res.status, headers: { "content-type": res.headers.get("content-type") ?? "text/html" } });
   }
   const abs = inside(DIST, url === "/" ? "index.html" : url.replace(/^\//, ""));
-  if (abs && fs8.existsSync(abs) && fs8.statSync(abs).isFile()) {
-    const ext = path8.extname(abs);
+  if (abs && fs9.existsSync(abs) && fs9.statSync(abs).isFile()) {
+    const ext = path9.extname(abs);
     const type = ext === ".js" ? "text/javascript" : ext === ".css" ? "text/css" : ext === ".woff2" ? "font/woff2" : ext === ".svg" ? "image/svg+xml" : ext === ".png" ? "image/png" : "text/html";
-    return new Response(fs8.readFileSync(abs), { headers: { "content-type": type } });
+    return new Response(fs9.readFileSync(abs), { headers: { "content-type": type } });
   }
-  const index = path8.join(DIST, "index.html");
-  if (!fs8.existsSync(index)) return c.text("run `npm run build` first", 500);
-  return new Response(fs8.readFileSync(index), { headers: { "content-type": "text/html" } });
+  const index = path9.join(DIST, "index.html");
+  if (!fs9.existsSync(index)) return c.text("run `npm run build` first", 500);
+  return new Response(fs9.readFileSync(index), { headers: { "content-type": "text/html" } });
 });
 var server = http.createServer(getRequestListener(app.fetch));
 setInterval(() => {
@@ -4890,7 +5225,7 @@ function openBrowser(url) {
 server.listen(PORT, HOST, () => {
   const reach = HOST === "0.0.0.0" ? "127.0.0.1" : HOST;
   const shown = reach.includes(":") ? `[${reach}]` : reach;
-  const base = `http://${shown}:${PORT}`;
+  const base = PUBLIC_ORIGINS[0] ?? `http://${shown}:${PORT}`;
   const url = TOKEN ? `${base}/?server=${encodeURIComponent(base)}&token=${encodeURIComponent(TOKEN)}` : base;
   console.log(`
   open  ${url}`);