pi-central 0.4.0 → 0.5.0

package/README.md

@@ -110,19 +110,43 @@ passed `--port`.
 ### From npm — what a user does
 
 ```bash
-npm install --global pi-central
+npm install --global pi-central   # inert: this package runs no install scripts
+npm audit signatures              # verify BEFORE the first run
 pi-central
 ```
 
-Or without installing it at all:
+**The order is the point, and it is only sound because of the comment on line one.** `npm install`
+executes no code from this package — it declares no `preinstall`, `install`, `postinstall` or `prepare`
+script, and a test asserts that stays true. So there is a window between "the bytes are on disk" and
+"anything has run" in which you can check what you got.
 
-```bash
-npx pi-central
-```
+`npx pi-central` has no such window: it fetches and executes in one step. It is convenient and it is the
+least verifiable way to run this. If you use it, **pin an exact version** (`npx pi-central@<version>`, where
+`<version>` is what `pi-central --version` reports for the copy you mean) so you at least know which artifact
+you asked for. The number is not written here on purpose: a README that restates a version goes stale the
+moment the next release ships, and `scripts/check-version.mjs` refuses to let one.
 
 Once it is running, [install it as an app](#install-it-as-an-app) and you will not need the terminal
 again until the next reboot.
 
+#### Verify what you installed
+
+```bash
+npm audit signatures
+```
+
+Every release carries a **provenance attestation** — a signed statement, minted by the release
+workflow's OIDC identity rather than a stored token, that this tarball came from this commit via this
+workflow. That command checks it, along with the registry signature.
+
+**Be clear about what this does and does not do.** It is a check you have to run; npm does not refuse
+an unattested tarball, and neither does the app. And it answers *"did the publisher produce this?"* —
+**not** *"is the publisher trustworthy?"*. Pi Central runs **outside** the sandbox (see the constraint
+above) with your privileges, deliberately, because it is the component that spawns the sandboxed
+sessions. A malicious release of it would not need an exploit; it would have exactly what you have.
+The attestation is what lets you tell a tampered tarball from a genuine one. It cannot make a genuine
+tarball safe.
+
 The package is **one bundled ESM file plus the built UI**, with a single runtime dependency (`ws`),
 and `pi-central --version` reports the version of the package it was actually shipped in.
 

package/bin/pi-central.js

@@ -25,7 +25,7 @@ function isBlockingDialog(record) {
 }
 
 // packages/protocol/src/envelopes.ts
-var PROTOCOL_VERSION = 3;
+var PROTOCOL_VERSION = 4;
 
 // packages/protocol/src/own-installation.ts
 var PIPELINE_MARKERS = ["packages/orchestrator", "packages/ui", "packages/protocol"];
@@ -562,13 +562,13 @@ var RpcProcess = class extends EventEmitter {
     const child = this.#child;
     if (!child || !child.stdin.writable) return Promise.reject(new Error("session is not running"));
     const id = `c${++this.#seq}`;
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         this.#pending.delete(id);
         reject(new Error(`timeout after ${timeoutMs}ms waiting for ${command.type}`));
       }, timeoutMs);
       timer.unref?.();
-      this.#pending.set(id, { resolve: resolve8, reject, timer });
+      this.#pending.set(id, { resolve: resolve9, reject, timer });
       child.stdin.write(encodeLine({ ...command, id }));
     });
   }
@@ -611,12 +611,12 @@ var RpcProcess = class extends EventEmitter {
   #waitForExit(ms) {
     const child = this.#child;
     if (!child || this.#exited) return Promise.resolve(true);
-    return new Promise((resolve8) => {
-      const timer = setTimeout(() => resolve8(this.#exited), ms);
+    return new Promise((resolve9) => {
+      const timer = setTimeout(() => resolve9(this.#exited), ms);
       timer.unref?.();
       child.once("exit", () => {
         clearTimeout(timer);
-        resolve8(true);
+        resolve9(true);
       });
     });
   }
@@ -629,8 +629,41 @@ var RpcProcess = class extends EventEmitter {
   }
 };
 
+// packages/orchestrator/src/retry.ts
+import { statSync as statSync3 } from "node:fs";
+function retryRefusal(session) {
+  if (session.state === "starting" || session.state === "streaming" || session.state === "awaiting-approval") {
+    return "This session is still running. Stop it before retrying.";
+  }
+  if (session.state !== "failed") {
+    return `Only a failed session can be retried; this one is ${session.state}.`;
+  }
+  return directoryRefusal(session.cwd);
+}
+function directoryRefusal(cwd) {
+  let stats;
+  try {
+    stats = statSync3(cwd);
+  } catch (error) {
+    return refusalForCode(error.code, cwd);
+  }
+  if (!stats.isDirectory()) {
+    return `Cannot retry: ${cwd} is no longer a directory.`;
+  }
+  return void 0;
+}
+function refusalForCode(code, cwd) {
+  if (code === "ENOENT") {
+    return `Cannot retry: ${cwd} no longer exists. Open a directory that exists, or start a new session.`;
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return `Cannot retry: ${cwd} is not readable by this process (${code}). The directory exists; its permissions changed.`;
+  }
+  return `Cannot retry: ${cwd} cannot be used (${code ?? "unknown error"}).`;
+}
+
 // packages/orchestrator/src/resume.ts
-import { accessSync as accessSync2, constants as constants2, statSync as statSync3 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, statSync as statSync4 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 function checkResumable(session) {
   if (!session.cwd) {
@@ -643,7 +676,7 @@ function checkResumable(session) {
   }
   let stats;
   try {
-    stats = statSync3(session.cwd);
+    stats = statSync4(session.cwd);
   } catch (error) {
     const code = error.code;
     const unreadable = code === "EACCES" || code === "EPERM";
@@ -1129,7 +1162,7 @@ function renderPolicyFragment(options = {}) {
 }
 
 // packages/orchestrator/src/files.ts
-import { lstatSync, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync, statSync as statSync4 } from "node:fs";
+import { lstatSync, readdirSync as readdirSync2, readFileSync as readFileSync4, realpathSync, statSync as statSync5 } from "node:fs";
 import { isAbsolute, join as join7, resolve as resolve6, sep as sep3 } from "node:path";
 var MAX_FILE_BYTES = 256 * 1024;
 var MAX_IMAGE_BYTES = 8 * 1024 * 1024;
@@ -1270,7 +1303,7 @@ function describeEntry(fullPath, name) {
 }
 function linkTargetOf(fullPath) {
   try {
-    const stats = statSync4(fullPath);
+    const stats = statSync5(fullPath);
     if (stats.isDirectory()) return "directory";
     if (stats.isFile()) return "file";
     return "other";
@@ -1524,6 +1557,56 @@ var Supervisor = class extends EventEmitter2 {
     }
     return void 0;
   }
+  /**
+   * Re-spawn a session that failed, in the directory it already had (issue #11).
+   *
+   * ## Why this is not "stop, then start"
+   *
+   * The reader is asking for THIS session to try again. A client-side stop+start would put a second row in
+   * the rail beside the failed one, and the roster (keyed by session file) would then have two live entries
+   * pointing at one conversation. Reusing the id keeps the row where the reader put it.
+   *
+   * ## Refusals, all before anything is spawned
+   *
+   * - **Not failed** → refused. A silent restart is how a crash loop hides itself, and a running session is
+   *   not broken.
+   * - **Directory gone or unreadable** → refused with the reason, for the same purpose `resume` refuses: RPC
+   *   Pi exits 1 on a missing directory rather than prompting (C2), so re-spawning would produce a second
+   *   failure that says less than the first.
+   *
+   * ## What is preserved
+   *
+   * `previousError` holds the last failure. Clearing `error` is what makes the retry a retry — the composer
+   * becomes usable again — but erasing the evidence would leave a reader unable to compare attempts.
+   */
+  async retry(id) {
+    const existing = this.#sessions.get(id);
+    if (existing === void 0) return { ok: false, message: `no such session: ${id}` };
+    const refusal = retryRefusal(existing);
+    if (refusal !== void 0) return { ok: false, message: refusal };
+    const previous = this.#processes.get(id);
+    this.#processes.delete(id);
+    await previous?.stop().catch(() => void 0);
+    return this.#spawn({
+      id,
+      cwd: existing.cwd,
+      mode: existing.mode,
+      /*
+       * No `--name` when the session already has a file.
+       *
+       * `resume` makes the same choice for the same reason: the session carries its own name, and re-applying
+       * one appends a redundant `session_info` record to a file we did not create. A retry of a session that
+       * already wrote records is exactly that case. When there is no file yet the name is still needed, so it
+       * is passed only then.
+       */
+      ...existing.sessionFile === void 0 ? { name: existing.name } : {},
+      sessionPath: existing.sessionFile,
+      previousError: existing.error ?? existing.previousError
+      // `enable` and `env` are not part of `LiveSession`, so a retry cannot reproduce logins granted per
+      // spawn. Stated here rather than silently lost: a retried session may come back with fewer
+      // capabilities than the original, which is visible in the composer when a credential is missing.
+    });
+  }
   #spawn(input) {
     const env = { ...agentRoutingEnv(this.#config.agentRoot), ...input.env ?? {} };
     const providerAuth = inspectProviderAuth(this.#config.providerAgentDir);
@@ -1587,7 +1670,8 @@ var Supervisor = class extends EventEmitter2 {
         ...ownInstallationWarning(input.cwd, this.#installationRoot) !== void 0 ? [ownInstallationWarning(input.cwd, this.#installationRoot)] : []
       ],
       startedAt: Date.now(),
-      ...input.sessionPath ? { sessionFile: input.sessionPath } : {}
+      ...input.sessionPath ? { sessionFile: input.sessionPath } : {},
+      ...input.previousError ? { previousError: input.previousError } : {}
     };
     this.#sessions.set(session.id, session);
     const rpc = new RpcProcess(this.#buildLaunch(policy.launch, input.sessionPath));
@@ -1946,13 +2030,48 @@ ${rpc.stderrTail}` : ""}`;
   }
 };
 function describeExitFailure(code, signal, stderr) {
-  const base = `pi exited (code=${code ?? "-"}, signal=${signal ?? "-"})${stderr ? `
-${stderr}` : ""}`;
+  const reason = exitReason(code, signal);
+  const tail = boundedTail(stderr);
+  const base = `${reason}${tail ? `
+${tail}` : ""}`;
   if (!/sandbox_apply|Operation not permitted/i.test(stderr)) return base;
   return `${base}
 
 This looks like Seatbelt refusing to nest (C1). The orchestrator must run from a plain terminal, not inside another sandbox, editor task, or agent harness -- because \`safehouse\` applies its policy with \`sandbox-exec\`, and that cannot run inside an existing sandbox.`;
 }
+var STDERR_TAIL_LINES = 12;
+function exitReason(code, signal) {
+  const raw = `pi exited (code=${code ?? "-"}, signal=${signal ?? "-"})`;
+  if (signal) return `${raw} \u2014 killed by ${signal}`;
+  if (code !== null && code > 128 && code <= 128 + 64) {
+    const name = signame(code - 128);
+    if (name !== void 0) return `${raw} \u2014 killed by ${name}`;
+  }
+  return raw;
+}
+function signame(number) {
+  const names = {
+    1: "SIGHUP",
+    2: "SIGINT",
+    3: "SIGQUIT",
+    6: "SIGABRT",
+    9: "SIGKILL",
+    11: "SIGSEGV",
+    13: "SIGPIPE",
+    15: "SIGTERM"
+  };
+  return names[number];
+}
+function boundedTail(stderr) {
+  const text = stderr.replace(/\s+$/, "");
+  if (text === "") return "";
+  const lines = text.split("\n");
+  if (lines.length <= STDERR_TAIL_LINES) return text;
+  const kept = lines.slice(-STDERR_TAIL_LINES);
+  const omitted = lines.length - STDERR_TAIL_LINES;
+  return `\u2026 ${omitted} earlier line${omitted === 1 ? "" : "s"} of output omitted
+${kept.join("\n")}`;
+}
 function defaultName(cwd, id) {
   const base = cwd.split("/").filter(Boolean).pop();
   return base && base.length > 0 ? base : id;
@@ -2003,18 +2122,54 @@ function readPackageJson(path) {
     return void 0;
   }
 }
+var VERIFY_INSTALL_HINT = "npm audit signatures";
 
 // packages/orchestrator/src/registry.ts
-import { createReadStream, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
-import { join as join10 } from "node:path";
+import { createReadStream, readdirSync as readdirSync3, realpathSync as realpathSync2, statSync as statSync6 } from "node:fs";
+import { basename, dirname as dirname2, join as join10, resolve as resolve7, sep as sep4 } from "node:path";
 var KNOWN_SESSION_VERSIONS = /* @__PURE__ */ new Set([3]);
 var HEAD_BYTES = 256 * 1024;
+var TAIL_BYTES = 8 * 1024;
 function decodeSessionDir(dirName) {
   const inner = dirName.replace(/^--/, "").replace(/--$/, "");
   return `/${inner.replace(/-/g, "/")}`;
 }
+async function readLateSessionName(path) {
+  let stats;
+  try {
+    stats = statSync6(path);
+  } catch {
+    return void 0;
+  }
+  const start = Math.max(0, stats.size - TAIL_BYTES);
+  if (start === 0) return void 0;
+  const text = await new Promise((resolve9) => {
+    const chunks = [];
+    const stream = createReadStream(path, { start, end: stats.size - 1 });
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("error", () => resolve9(""));
+    stream.on("close", () => resolve9(Buffer.concat(chunks).toString("utf8")));
+  });
+  if (text === "") return void 0;
+  const lines = text.split("\n");
+  lines.shift();
+  let name;
+  for (const line of lines) {
+    if (!line.includes('"session_info"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type === "session_info" && typeof record.name === "string") {
+        const trimmed = record.name.trim();
+        if (trimmed.length > 0) name = trimmed;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return name;
+}
 async function readHead(path) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const chunks = [];
     let size = 0;
     const stream = createReadStream(path, { start: 0, end: HEAD_BYTES - 1 });
@@ -2022,8 +2177,8 @@ async function readHead(path) {
       chunks.push(chunk);
       size += chunk.length;
     });
-    stream.on("error", () => resolve8(""));
-    stream.on("close", () => resolve8(Buffer.concat(chunks, size).toString("utf8")));
+    stream.on("error", () => resolve9(""));
+    stream.on("close", () => resolve9(Buffer.concat(chunks, size).toString("utf8")));
   });
 }
 function parseHead(text) {
@@ -2079,6 +2234,57 @@ function flattenContent(content) {
   }
   return "";
 }
+async function describeSessionFile(config, path, projectDir, stats) {
+  const head = await readHead(path);
+  const parsed = parseHead(head);
+  if (!parsed) return { ok: false, reason: "not a Pi session file (no valid header)" };
+  const lateName = stats.size > HEAD_BYTES ? await readLateSessionName(path) : void 0;
+  if (!KNOWN_SESSION_VERSIONS.has(parsed.header.version)) {
+    return { ok: false, reason: `unknown session version ${parsed.header.version}` };
+  }
+  const cwd = parsed.header.cwd || decodeSessionDir(projectDir);
+  return {
+    ok: true,
+    session: {
+      path,
+      id: parsed.header.id,
+      cwd,
+      // The late name wins: it is the most recent rename, and the head's is the earliest one.
+      ...lateName ?? parsed.name ? { name: lateName ?? parsed.name } : {},
+      created: parsed.header.timestamp,
+      modifiedMs: stats.mtimeMs,
+      bytes: stats.size,
+      messageCount: parsed.messageCount,
+      firstMessage: parsed.firstMessage,
+      cwdExists: directoryExists(cwd),
+      scratch: isScratch(config, cwd)
+    }
+  };
+}
+async function sessionAt(config, requested) {
+  if (typeof requested !== "string" || requested.length === 0 || requested.includes("\0")) return void 0;
+  let root;
+  let real;
+  try {
+    root = realpathSync2(config.sessionsRoot);
+    real = realpathSync2(resolve7(requested));
+  } catch {
+    return void 0;
+  }
+  const inside = (parent, child) => child === parent || child.startsWith(parent.endsWith(sep4) ? parent : parent + sep4);
+  if (!inside(root, real)) return void 0;
+  if (!real.endsWith(".jsonl")) return void 0;
+  let stats;
+  try {
+    stats = statSync6(real);
+  } catch {
+    return void 0;
+  }
+  if (!stats.isFile()) return void 0;
+  const projectDir = basename(dirname2(real));
+  const row = await describeSessionFile(config, real, projectDir, stats);
+  return row.ok ? row.session : void 0;
+}
 async function discover(config, limit = 500) {
   const sessions = [];
   const skipped = [];
@@ -2102,33 +2308,16 @@ async function discover(config, limit = 500) {
       const path = join10(projectPath, entry.name);
       let stats;
       try {
-        stats = statSync5(path);
+        stats = statSync6(path);
       } catch {
         continue;
       }
-      const parsed = parseHead(await readHead(path));
-      if (!parsed) {
-        skipped.push({ path, reason: "not a Pi session file (no valid header)" });
-        continue;
-      }
-      if (!KNOWN_SESSION_VERSIONS.has(parsed.header.version)) {
-        skipped.push({ path, reason: `unknown session version ${parsed.header.version}` });
+      const row = await describeSessionFile(config, path, projectDir, stats);
+      if (!row.ok) {
+        skipped.push({ path, reason: row.reason });
         continue;
       }
-      const cwd = parsed.header.cwd || decodeSessionDir(projectDir);
-      sessions.push({
-        path,
-        id: parsed.header.id,
-        cwd,
-        ...parsed.name ? { name: parsed.name } : {},
-        created: parsed.header.timestamp,
-        modifiedMs: stats.mtimeMs,
-        bytes: stats.size,
-        messageCount: parsed.messageCount,
-        firstMessage: parsed.firstMessage,
-        cwdExists: directoryExists(cwd),
-        scratch: isScratch(config, cwd)
-      });
+      sessions.push(row.session);
     }
   }
   sessions.sort((a, b) => b.modifiedMs - a.modifiedMs);
@@ -2136,15 +2325,15 @@ async function discover(config, limit = 500) {
 }
 function directoryExists(dir) {
   try {
-    return statSync5(dir).isDirectory();
+    return statSync6(dir).isDirectory();
   } catch {
     return false;
   }
 }
 
 // packages/orchestrator/src/static-ui.ts
-import { createReadStream as createReadStream2, existsSync as existsSync6, statSync as statSync6 } from "node:fs";
-import { extname, join as join11, posix, resolve as resolve7, sep as sep4 } from "node:path";
+import { createReadStream as createReadStream2, existsSync as existsSync6, statSync as statSync7 } from "node:fs";
+import { extname, join as join11, posix, resolve as resolve8, sep as sep5 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var UI_CSP = (
   // `blob:` is REQUIRED and is not covered by `'self'` (issue #111).
@@ -2181,7 +2370,7 @@ var CONTENT_TYPES = {
 };
 function resolveUiDistDir(env = process.env, from = import.meta.url) {
   const explicit = env["PI_CENTRAL_UI_DIST"];
-  if (explicit !== void 0 && explicit !== "") return resolve7(explicit);
+  if (explicit !== void 0 && explicit !== "") return resolve8(explicit);
   const own = findOwnPackage(from);
   if (own === void 0) {
     return fileURLToPath3(new URL("../../ui/dist", from));
@@ -2199,13 +2388,13 @@ function runningFromSource(from) {
   return /[\\/]packages[\\/][^\\/]+[\\/]src[\\/]/.test(fileURLToPath3(from));
 }
 function isInside3(root, candidate) {
-  const rootPath = resolve7(root);
-  const target = resolve7(candidate);
+  const rootPath = resolve8(root);
+  const target = resolve8(candidate);
   if (target === rootPath) return true;
-  return target.startsWith(rootPath.endsWith(sep4) ? rootPath : rootPath + sep4);
+  return target.startsWith(rootPath.endsWith(sep5) ? rootPath : rootPath + sep5);
 }
 function resolveStaticPath(root, requestTarget) {
-  const rootPath = resolve7(root);
+  const rootPath = resolve8(root);
   const target = requestTarget.split("?")[0].split("#")[0];
   let decoded;
   try {
@@ -2219,16 +2408,16 @@ function resolveStaticPath(root, requestTarget) {
     return { kind: "denied", reason: "the request target contains a '..' segment" };
   }
   const relative = posix.normalize(decoded).replace(/^\/+/, "");
-  const candidate = resolve7(rootPath, relative);
+  const candidate = resolve8(rootPath, relative);
   if (!isInside3(rootPath, candidate)) {
     return { kind: "denied", reason: "the request target resolves outside the served UI root" };
   }
   return { kind: "file", path: candidate };
 }
 function createUiRequestHandler(options) {
-  const root = resolve7(options.root);
+  const root = resolve8(options.root);
   const csp = options.csp ?? UI_CSP;
-  const indexPath = resolve7(root, "index.html");
+  const indexPath = resolve8(root, "index.html");
   return (req, res) => {
     const method = req.method ?? "GET";
     if (method !== "GET" && method !== "HEAD") {
@@ -2279,7 +2468,7 @@ Build it with:
 }
 function isReadableFile(path) {
   try {
-    return statSync6(path).isFile();
+    return statSync7(path).isFile();
   } catch {
     return false;
   }
@@ -2296,9 +2485,9 @@ function sendText(res, method, status, body, csp) {
   else res.end(body);
 }
 function sendFile(res, method, path, csp) {
-  const info = statSync6(path);
+  const info = statSync7(path);
   const type = CONTENT_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
-  const immutable = path.includes(`${sep4}assets${sep4}`);
+  const immutable = path.includes(`${sep5}assets${sep5}`);
   res.writeHead(200, {
     "content-type": type,
     "content-length": String(info.size),
@@ -2315,27 +2504,29 @@ function sendFile(res, method, path, csp) {
   stream.pipe(res);
 }
 function hasBuiltUi(root) {
-  return existsSync6(resolve7(root, "index.html"));
+  return existsSync6(resolve8(root, "index.html"));
 }
 
 // packages/orchestrator/src/transport.ts
-var KNOWN_CONTROL_KINDS = /* @__PURE__ */ new Set([
-  "list",
-  "start",
-  "prompt",
-  "clearQueue",
-  "abort",
-  "stop",
-  "rename",
-  "setModel",
-  "listModels",
-  "setThinkingLevel",
-  "listThinkingLevels",
-  "answerDialog",
-  "resume",
-  "listFiles",
-  "readFile"
-]);
+var CONTROL_KINDS = {
+  list: true,
+  start: true,
+  prompt: true,
+  clearQueue: true,
+  abort: true,
+  stop: true,
+  rename: true,
+  setModel: true,
+  listModels: true,
+  setThinkingLevel: true,
+  listThinkingLevels: true,
+  answerDialog: true,
+  resume: true,
+  retry: true,
+  listFiles: true,
+  readFile: true
+};
+var KNOWN_CONTROL_KINDS = new Set(Object.keys(CONTROL_KINDS));
 function parseControl(raw) {
   let parsed;
   try {
@@ -2399,11 +2590,11 @@ var Transport = class {
     this.#server = server;
     this.#wss = wss;
     wss.on("connection", (socket) => this.#onConnection(socket));
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       server.once("error", reject);
       server.listen(this.#options.port, this.#options.host, () => {
         server.off("error", reject);
-        resolve8();
+        resolve9();
       });
     });
     const addr = server.address();
@@ -2535,10 +2726,12 @@ var Transport = class {
         return;
       }
       case "resume": {
-        const discovered = await discover(this.#config);
-        const target = discovered.sessions.find((s) => s.path === control.path);
+        const target = await sessionAt(this.#config, control.path);
         if (!target) {
-          this.#broadcast({ kind: "error", message: `no such session: ${control.path}` });
+          this.#broadcast({
+            kind: "error",
+            message: `no such session: ${control.path}`
+          });
           return;
         }
         const result = this.#supervisor.resume(target, control.mode ? { mode: control.mode } : {});
@@ -2549,6 +2742,15 @@ var Transport = class {
         this.#broadcast({ kind: "session", session: result.session });
         return;
       }
+      case "retry": {
+        const result = await this.#supervisor.retry(control.sessionId);
+        if (!result.ok) {
+          this.#broadcast({ kind: "error", message: result.message });
+          return;
+        }
+        this.#broadcast({ kind: "session", session: result.session });
+        return;
+      }
       case "prompt":
         await this.#supervisor.prompt(
           control.sessionId,
@@ -2710,13 +2912,13 @@ var Transport = class {
     this.#wss = void 0;
     this.#server = void 0;
     this.#address = void 0;
-    if (wss) await new Promise((resolve8) => wss.close(() => resolve8()));
-    if (server) await new Promise((resolve8) => server.close(() => resolve8()));
+    if (wss) await new Promise((resolve9) => wss.close(() => resolve9()));
+    if (server) await new Promise((resolve9) => server.close(() => resolve9()));
   }
 };
 
 // packages/orchestrator/src/startup-error.ts
-import { readFileSync as readFileSync6, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync6, statSync as statSync8 } from "node:fs";
 import { join as join12 } from "node:path";
 function explainStartupError(error, host, port) {
   const code = error?.code;
@@ -2756,7 +2958,7 @@ function describeBuiltUi(uiDir) {
     const html = readFileSync6(join12(uiDir, "index.html"), "utf8");
     const entry = /assets\/index-[A-Za-z0-9_-]+\.js/.exec(html)?.[0];
     if (entry === void 0) return "(no entry bundle named in index.html)";
-    const { mtime } = statSync7(join12(uiDir, "index.html"));
+    const { mtime } = statSync8(join12(uiDir, "index.html"));
     return `${entry} (built ${mtime.toISOString().slice(0, 16).replace("T", " ")})`;
   } catch {
     return "(unreadable)";
@@ -2809,6 +3011,9 @@ function assertNotSandboxed(execPath = "/usr/bin/sandbox-exec") {
 }
 
 // packages/orchestrator/src/server.ts
+function ownPackageRoot() {
+  return findOwnPackage()?.root ?? "unknown (no package.json found)";
+}
 function versionLine() {
   const own = findOwnPackage();
   if (own === void 0) return `${PACKAGE_NAME} (version unknown: no package.json found)`;
@@ -2905,6 +3110,8 @@ async function main() {
   console.log(`  default workspace: ${config.workspaceRoot}`);
   console.log(`  agent root: ${config.agentRoot}${config.agentRootManaged ? " (managed)" : " (external)"}`);
   console.log(`  isolation: ${options.mode}`);
+  console.log(`  running from: ${ownPackageRoot()}`);
+  console.log(`  verify this install: ${VERIFY_INSTALL_HINT}   (see README, "Verify what you installed")`);
   if (config.installationRoot === void 0) {
     console.log(
       `Self-hosting check: could not identify this installation's own directory, so sessions are