@jyork0828/pi-pilot 0.0.7 → 0.1.0

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import { dirname as dirname6, extname, join as join16, resolve as resolve7, sep as sep3 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { dirname as dirname6, extname, join as join17, resolve as resolve8, sep as sep3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { serve } from "@hono/node-server";
 import { Hono as Hono6 } from "hono";
@@ -41,20 +41,31 @@ function configureHttpProxy() {
 }
 
 // src/api/workspaces.ts
-import { readFile as readFile7, stat as stat2 } from "fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
+import { readFile as readFile8, stat as stat3 } from "fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve6 } from "path";
 import { Hono as Hono2 } from "hono";
 
 // src/storage/resource-writer.ts
+import { execFile } from "child_process";
+import { createWriteStream } from "fs";
 import {
+  cp,
   mkdir,
+  mkdtemp,
+  readdir,
   readFile,
   rm,
   stat,
   unlink,
   writeFile
 } from "fs/promises";
+import { tmpdir } from "os";
 import { basename, dirname, isAbsolute, join as join2, resolve, sep } from "path";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+import { promisify } from "util";
+import { createGunzip } from "zlib";
+var exec = promisify(execFile);
 var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 var PROMPT_NAME_RE = /^[a-z0-9_](?:[a-z0-9_-]{0,62}[a-z0-9_])?$/;
 function ensureSkillName(name) {
@@ -231,6 +242,156 @@ async function deleteSkill(filePath, roots) {
   assertUnder(dir, [roots.userSkills, roots.projectSkills]);
   await rm(dir, { recursive: true, force: true });
 }
+var MAX_UNCOMPRESSED_BYTES = 200 * 1024 * 1024;
+var MAX_ENTRIES = 5e3;
+async function installSkillFromZip(opts) {
+  const base = opts.scope === "user" ? opts.roots.userSkills : opts.roots.projectSkills;
+  const maxBytes = opts.limits?.maxUncompressedBytes ?? MAX_UNCOMPRESSED_BYTES;
+  const maxEntries = opts.limits?.maxEntries ?? MAX_ENTRIES;
+  const work = await mkdtemp(join2(tmpdir(), "pi-pilot-skill-"));
+  try {
+    const extractDir = join2(work, "x");
+    await mkdir(extractDir, { recursive: true });
+    await extractArchive(opts.zip, work, extractDir, { maxBytes, maxEntries });
+    const srcDir = await locateSkillDir(extractDir);
+    await assertNoSymlinks(srcDir);
+    const name = await resolveInstalledSkillName(srcDir, extractDir);
+    const dest = join2(base, name);
+    assertUnder(dest, [opts.roots.userSkills, opts.roots.projectSkills]);
+    if (await exists(dest)) {
+      if (!opts.overwrite) {
+        throw new HttpError(409, `a skill named "${name}" already exists \u2014 delete it first or overwrite`);
+      }
+      await rm(dest, { recursive: true, force: true });
+    }
+    await mkdir(base, { recursive: true });
+    await cp(srcDir, dest, {
+      recursive: true,
+      // Strip macOS archive cruft so the installed dir stays clean. (The
+      // tree is already symlink-free — see assertNoSymlinks above.)
+      filter: (src) => {
+        const b = basename(src);
+        return b !== "__MACOSX" && b !== ".DS_Store";
+      }
+    });
+    return { name, filePath: join2(dest, "SKILL.md") };
+  } finally {
+    await rm(work, { recursive: true, force: true });
+  }
+}
+async function extractArchive(zip, work, extractDir, caps) {
+  const isZip = zip.length >= 4 && zip[0] === 80 && zip[1] === 75;
+  const isGzip = zip.length >= 3 && zip[0] === 31 && zip[1] === 139 && zip[2] === 8;
+  if (!isZip && !isGzip) {
+    throw new HttpError(400, "uploaded file is not a .zip or .tar.gz archive");
+  }
+  try {
+    if (isZip) {
+      const zipPath = join2(work, "skill.zip");
+      await writeFile(zipPath, zip);
+      const { stdout } = await exec("unzip", ["-Z", "-t", zipPath]);
+      const m = stdout.match(/(\d+)\s+files?,\s+(\d+)\s+bytes uncompressed/);
+      if (!m) throw new HttpError(400, "could not read the archive's contents");
+      assertEntryCount(Number(m[1]), caps.maxEntries);
+      assertUncompressedSize(Number(m[2]), caps.maxBytes);
+      await exec("unzip", ["-o", "-q", zipPath, "-d", extractDir]);
+    } else {
+      const tarPath = join2(work, "skill.tar");
+      await gunzipToFileCapped(zip, tarPath, caps.maxBytes);
+      const { stdout } = await exec("tar", ["-tf", tarPath], { maxBuffer: 16 * 1024 * 1024 });
+      assertEntryCount(stdout.split("\n").filter((l) => l.length > 0).length, caps.maxEntries);
+      await exec("tar", ["-xf", tarPath, "-C", extractDir]);
+    }
+  } catch (err2) {
+    if (err2 instanceof HttpError) throw err2;
+    const e = err2;
+    if (e.code === "ENOENT") {
+      throw new HttpError(
+        500,
+        `\`${e.path ?? "unzip/tar"}\` is not available on the server host \u2014 install it or place the skill folder under your skills directory manually`
+      );
+    }
+    throw new HttpError(400, `could not extract archive: ${e.stderr?.trim() || e.message}`);
+  }
+}
+async function gunzipToFileCapped(gz, destPath, maxBytes) {
+  let total = 0;
+  const cap = new Transform({
+    transform(chunk, _enc, cb) {
+      total += chunk.length;
+      if (total > maxBytes) {
+        cb(
+          new HttpError(
+            400,
+            `archive expands beyond the ${Math.round(maxBytes / 1024 / 1024)} MB uncompressed cap`
+          )
+        );
+        return;
+      }
+      cb(null, chunk);
+    }
+  });
+  await pipeline(Readable.from([gz]), createGunzip(), cap, createWriteStream(destPath));
+}
+function assertEntryCount(entries, max) {
+  if (entries > max) {
+    throw new HttpError(400, `archive has too many files (${entries} > ${max})`);
+  }
+}
+function assertUncompressedSize(uncompressed, maxBytes) {
+  if (uncompressed > maxBytes) {
+    throw new HttpError(
+      400,
+      `archive expands to ${Math.round(uncompressed / 1024 / 1024)} MB uncompressed (max ${Math.round(maxBytes / 1024 / 1024)} MB)`
+    );
+  }
+}
+async function locateSkillDir(extractDir) {
+  if (await exists(join2(extractDir, "SKILL.md"))) return extractDir;
+  const dirs = (await readdir(extractDir, { withFileTypes: true })).filter(
+    (e) => e.isDirectory() && e.name !== "__MACOSX"
+  );
+  const withSkill = [];
+  for (const e of dirs) {
+    const dir = join2(extractDir, e.name);
+    if (await exists(join2(dir, "SKILL.md"))) withSkill.push(dir);
+  }
+  if (withSkill.length > 1) {
+    throw new HttpError(400, "archive contains multiple skill folders \u2014 install one skill per .zip");
+  }
+  if (withSkill.length === 1) return withSkill[0];
+  throw new HttpError(400, "archive has no SKILL.md (at the root or one level down)");
+}
+async function assertNoSymlinks(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    if (e.isSymbolicLink()) {
+      throw new HttpError(
+        400,
+        "archive contains a symbolic link, which is not allowed in a skill package"
+      );
+    }
+    if (e.isDirectory()) await assertNoSymlinks(join2(dir, e.name));
+  }
+}
+async function resolveInstalledSkillName(srcDir, extractDir) {
+  const text = await readFile(join2(srcDir, "SKILL.md"), "utf8");
+  const fmName = parseFile(text).frontmatter.name;
+  if (typeof fmName === "string" && fmName.trim()) {
+    const n2 = fmName.trim();
+    ensureSkillName(n2);
+    return n2;
+  }
+  if (resolve(srcDir) === resolve(extractDir)) {
+    throw new HttpError(
+      400,
+      "SKILL.md has no `name:` field and the archive isn't wrapped in a folder \u2014 add a `name:` to the skill's frontmatter"
+    );
+  }
+  const n = basename(srcDir);
+  ensureSkillName(n);
+  return n;
+}
 async function createPrompt(opts) {
   const file = promptFileFor(opts.scope, opts.name, opts.roots);
   assertUnder(file, [opts.roots.userPrompts, opts.roots.projectPrompts]);
@@ -477,9 +638,9 @@ async function reorderWorkspaces(ids) {
 }
 
 // src/storage/workspace-stats.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var exec = promisify(execFile);
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec2 = promisify2(execFile2);
 var CACHE_TTL_MS = 3e4;
 var cache2 = /* @__PURE__ */ new Map();
 var inflight = /* @__PURE__ */ new Map();
@@ -555,7 +716,7 @@ async function probeStats(path) {
   return { gitBranch, fileCount };
 }
 async function runGit(cwd, args) {
-  const { stdout } = await exec("git", args, {
+  const { stdout } = await exec2("git", args, {
     cwd,
     timeout: 2e3,
     maxBuffer: 5 * 1024 * 1024,
@@ -1007,7 +1168,7 @@ function waitForAnswer({
   sessionFile,
   signal
 }) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let settled = false;
     let timeoutHandle;
     const cleanup = () => {
@@ -1019,7 +1180,7 @@ function waitForAnswer({
       if (settled) return;
       settled = true;
       cleanup();
-      resolve8(a);
+      resolve9(a);
     };
     const finishErr = (err2) => {
       if (settled) return;
@@ -1295,13 +1456,13 @@ function toolsField(value) {
 // src/extensions/subagent/child.ts
 import { spawn } from "child_process";
 import {
-  createWriteStream,
+  createWriteStream as createWriteStream2,
   mkdirSync,
   mkdtempSync,
   writeFileSync
 } from "fs";
 import { rm as rm3 } from "fs/promises";
-import { tmpdir } from "os";
+import { tmpdir as tmpdir2 } from "os";
 import { join as join8 } from "path";
 
 // src/extensions/subagent/schema.ts
@@ -1422,18 +1583,18 @@ function take(sessionKey) {
 }
 function acquireChildSlot(signal, sessionFile) {
   const sessionKey = keyOf2(sessionFile);
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     if (signal?.aborted) {
       reject(new Error("Aborted by user"));
       return;
     }
     if (hasCapacity(sessionKey)) {
       take(sessionKey);
-      resolve8(makeRelease(sessionKey));
+      resolve9(makeRelease(sessionKey));
       return;
     }
     const waiter = {
-      grant: () => resolve8(makeRelease(sessionKey)),
+      grant: () => resolve9(makeRelease(sessionKey)),
       sessionKey,
       signal,
       onAbort: void 0
@@ -1484,7 +1645,7 @@ function pump() {
 
 // src/extensions/subagent/child.ts
 var PROMPT_DIR_PREFIX = "pi-pilot-subagent-";
-var TRANSCRIPTS_DIR = join8(tmpdir(), "pi-pilot-subagents", "transcripts");
+var TRANSCRIPTS_DIR = join8(tmpdir2(), "pi-pilot-subagents", "transcripts");
 var ACTIVITY_MAX = 30;
 var LABEL_MAX = 160;
 var STDERR_TAIL_MAX = 2048;
@@ -1493,7 +1654,7 @@ var SIGKILL_DELAY_MS = 5e3;
 async function runChild(opts) {
   const startedAt = Date.now();
   const cli = opts.cliPath ?? process.env.PI_PILOT_SUBAGENT_CLI ?? resolvePinnedPiCli();
-  const promptDir = mkdtempSync(join8(tmpdir(), PROMPT_DIR_PREFIX));
+  const promptDir = mkdtempSync(join8(tmpdir2(), PROMPT_DIR_PREFIX));
   const promptPath = join8(promptDir, "prompt.md");
   writeFileSync(promptPath, opts.appendSystemPrompt, { mode: 384 });
   let transcriptPath;
@@ -1501,7 +1662,7 @@ async function runChild(opts) {
   try {
     mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
     transcriptPath = join8(TRANSCRIPTS_DIR, `${sanitizeId(opts.toolCallId)}.ndjson`);
-    tee = createWriteStream(transcriptPath, { flags: "w" });
+    tee = createWriteStream2(transcriptPath, { flags: "w" });
     tee.on("error", () => {
     });
   } catch {
@@ -1649,12 +1810,12 @@ ${process.pid}`);
     armStallTimer();
     stderrAccum = (stderrAccum + chunk.toString("utf8")).slice(-STDERR_TAIL_MAX);
   });
-  const exitCode = await new Promise((resolve8) => {
+  const exitCode = await new Promise((resolve9) => {
     child.on("error", (err2) => {
       errorMessage ??= err2 instanceof Error ? err2.message : String(err2);
-      resolve8(-1);
+      resolve9(-1);
     });
-    child.on("close", (code) => resolve8(code ?? -1));
+    child.on("close", (code) => resolve9(code ?? -1));
   });
   if (buf) handleLine(buf);
   clearTimeout(timeoutTimer);
@@ -2501,9 +2662,9 @@ function reconcileAfterRestart(sessionManager) {
 }
 
 // src/extensions/subagent/cleanup.ts
-import { execFile as execFile2 } from "child_process";
-import { readdir, readFile as readFile6, rm as rm4 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
+import { execFile as execFile3 } from "child_process";
+import { readdir as readdir2, readFile as readFile6, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
 import { join as join11 } from "path";
 var CUSTOM_TYPE2 = "subagent-restart-cancelled";
 function reconcileAfterRestart2(sessionManager) {
@@ -2558,10 +2719,10 @@ function reconcileAfterRestart2(sessionManager) {
     { ids: danglingIds }
   );
 }
-async function sweepOrphanedChildrenOnBoot(rootDir = tmpdir2()) {
+async function sweepOrphanedChildrenOnBoot(rootDir = tmpdir3()) {
   let dirNames;
   try {
-    dirNames = (await readdir(rootDir)).filter((n) => n.startsWith(PROMPT_DIR_PREFIX));
+    dirNames = (await readdir2(rootDir)).filter((n) => n.startsWith(PROMPT_DIR_PREFIX));
   } catch {
     return;
   }
@@ -2598,14 +2759,14 @@ function isLiveNodeProcess(pid) {
   } catch {
     return Promise.resolve(false);
   }
-  return new Promise((resolve8) => {
-    execFile2("ps", ["-o", "ucomm=", "-p", String(pid)], (err2, stdout) => {
+  return new Promise((resolve9) => {
+    execFile3("ps", ["-o", "ucomm=", "-p", String(pid)], (err2, stdout) => {
       if (err2) {
-        resolve8(false);
+        resolve9(false);
         return;
       }
       const name = stdout.trim().toLowerCase();
-      resolve8(name === "node" || name === "pi");
+      resolve9(name === "node" || name === "pi");
     });
   });
 }
@@ -2615,8 +2776,10 @@ function translatePiEvent(ev) {
   switch (ev.type) {
     case "agent_start":
       return { kind: "agent_start" };
-    case "agent_end":
-      return { kind: "agent_end", willRetry: ev.willRetry };
+    case "agent_end": {
+      const error = ev.willRetry ? void 0 : finalAssistantError(ev.messages);
+      return { kind: "agent_end", willRetry: ev.willRetry, ...error ? { error } : {} };
+    }
     case "turn_start":
       return { kind: "turn_start" };
     case "turn_end":
@@ -2711,6 +2874,21 @@ function translatePiEvent(ev) {
       return void 0;
   }
 }
+function assistantErrorText(message) {
+  const m = message;
+  if (!m || m.stopReason !== "error") return void 0;
+  const text = typeof m.errorMessage === "string" ? m.errorMessage.trim() : "";
+  return text || "The model stream ended with an error.";
+}
+function finalAssistantError(messages) {
+  if (!Array.isArray(messages)) return void 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m || m.role !== "assistant") continue;
+    return assistantErrorText(m);
+  }
+  return void 0;
+}
 var warnedUnknownRoles = /* @__PURE__ */ new Set();
 function roleOf(message) {
   const role = message?.role;
@@ -2837,6 +3015,97 @@ function extractText(result) {
   return parts.length === 0 ? void 0 : parts.join("");
 }
 
+// src/history-builder.ts
+function isAssistantSupersededByRetry(branch, index) {
+  for (let j = index + 1; j < branch.length; j++) {
+    const e = branch[j];
+    if (e?.type !== "message") continue;
+    return e.message?.role === "assistant";
+  }
+  return false;
+}
+function buildHistoryItems(branch) {
+  const items = [];
+  const argsByCallId = /* @__PURE__ */ new Map();
+  for (let i = 0; i < branch.length; i++) {
+    const entry = branch[i];
+    if (!entry || entry.type !== "message") continue;
+    const msg = entry.message;
+    const role = msg.role;
+    if (role === "user") {
+      const text = extractUserText2(msg);
+      if (text) items.push({ kind: "user", text, entryId: entry.id ?? "" });
+    } else if (role === "assistant") {
+      const { text, thinking, toolCalls } = extractAssistantContent(
+        msg
+      );
+      for (const tc of toolCalls) {
+        argsByCallId.set(tc.id, tc.args);
+      }
+      const error = isAssistantSupersededByRetry(branch, i) ? void 0 : assistantErrorText(msg);
+      if (text || thinking || error) {
+        items.push({ kind: "assistant", text, thinking, ...error ? { error } : {} });
+      }
+    } else if (role === "toolResult") {
+      const tr = msg;
+      items.push({
+        kind: "tool",
+        toolCallId: tr.toolCallId,
+        toolName: tr.toolName,
+        args: argsByCallId.get(tr.toolCallId) ?? "",
+        text: extractContentText(tr.content),
+        isError: tr.isError,
+        // Mirror live wire whitelist (bridge.ts): only ship details for
+        // tools whose cards need the structured shape, so the history
+        // payload stays small for bash / edit / read.
+        ...shouldForwardDetails(tr.toolName) && tr.details !== void 0 ? { details: tr.details } : {}
+      });
+    } else if (role === "bashExecution") {
+      const be = msg;
+      items.push({
+        kind: "bash",
+        command: be.command,
+        output: be.output,
+        exitCode: be.exitCode
+      });
+    }
+  }
+  return items;
+}
+function extractUserText2(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  return extractContentText(msg.content);
+}
+function extractAssistantContent(msg) {
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  for (const block of msg.content ?? []) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") textParts.push(b.text);
+    else if (b.type === "thinking" && typeof b.thinking === "string") thinkingParts.push(b.thinking);
+    else if (b.type === "toolCall" && typeof b.id === "string") {
+      toolCalls.push({
+        id: b.id,
+        args: b.arguments != null ? JSON.stringify(b.arguments) : ""
+      });
+    }
+  }
+  return { text: textParts.join(""), thinking: thinkingParts.join(""), toolCalls };
+}
+function extractContentText(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+
 // src/ws/extension-ui.ts
 var ExtensionUIBridge = class {
   /** Symmetric with the old bridge so workspace-manager's dispose path
@@ -3213,48 +3482,7 @@ ${err2.stack}` : "")
     if (!runtime) return { items: [], isStreaming: false };
     const isStreaming = runtime.session.isStreaming ?? false;
     const branch = runtime.session.sessionManager.getBranch();
-    const items = [];
-    const argsByCallId = /* @__PURE__ */ new Map();
-    for (const entry of branch) {
-      if (entry.type !== "message") continue;
-      const msg = entry.message;
-      const role = msg.role;
-      if (role === "user") {
-        const text = extractUserText2(msg);
-        if (text) items.push({ kind: "user", text, entryId: entry.id });
-      } else if (role === "assistant") {
-        const { text, thinking, toolCalls } = extractAssistantContent(
-          msg
-        );
-        for (const tc of toolCalls) {
-          argsByCallId.set(tc.id, tc.args);
-        }
-        if (text || thinking) items.push({ kind: "assistant", text, thinking });
-      } else if (role === "toolResult") {
-        const tr = msg;
-        items.push({
-          kind: "tool",
-          toolCallId: tr.toolCallId,
-          toolName: tr.toolName,
-          args: argsByCallId.get(tr.toolCallId) ?? "",
-          text: extractContentText(tr.content),
-          isError: tr.isError,
-          // Mirror live wire whitelist (bridge.ts): only ship details
-          // for tools whose cards need the structured shape, so the
-          // history payload stays small for bash / edit / read.
-          ...shouldForwardDetails(tr.toolName) && tr.details !== void 0 ? { details: tr.details } : {}
-        });
-      } else if (role === "bashExecution") {
-        const be = msg;
-        items.push({
-          kind: "bash",
-          command: be.command,
-          output: be.output,
-          exitCode: be.exitCode
-        });
-      }
-    }
-    return { items, isStreaming };
+    return { items: buildHistoryItems(branch), isStreaming };
   }
   /**
    * Delete a session JSONL file belonging to this workspace.
@@ -3394,39 +3622,6 @@ function toSessionSummary(info, running2) {
     ...running2 ? { running: true } : {}
   };
 }
-function extractUserText2(msg) {
-  if (typeof msg.content === "string") return msg.content;
-  return extractContentText(msg.content);
-}
-function extractAssistantContent(msg) {
-  const textParts = [];
-  const thinkingParts = [];
-  const toolCalls = [];
-  for (const block of msg.content ?? []) {
-    if (!block || typeof block !== "object") continue;
-    const b = block;
-    if (b.type === "text" && typeof b.text === "string") textParts.push(b.text);
-    else if (b.type === "thinking" && typeof b.thinking === "string") thinkingParts.push(b.thinking);
-    else if (b.type === "toolCall" && typeof b.id === "string") {
-      toolCalls.push({
-        id: b.id,
-        args: b.arguments != null ? JSON.stringify(b.arguments) : ""
-      });
-    }
-  }
-  return { text: textParts.join(""), thinking: thinkingParts.join(""), toolCalls };
-}
-function extractContentText(content) {
-  if (!Array.isArray(content)) return "";
-  const parts = [];
-  for (const block of content) {
-    if (block && typeof block === "object" && block.type === "text") {
-      const text = block.text;
-      if (typeof text === "string") parts.push(text);
-    }
-  }
-  return parts.join("");
-}
 var workspaceManager = new SessionRuntimeManager();
 function broadcastTo(subscribers, msg) {
   const wire = JSON.stringify(msg);
@@ -3630,11 +3825,11 @@ function mountConfigRoutes(app2) {
 }
 
 // src/api/files.ts
-import { execFile as execFile3 } from "child_process";
-import { readdir as readdir2 } from "fs/promises";
-import { join as join12, relative, sep as sep2 } from "path";
-import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execFile3);
+import { execFile as execFile4 } from "child_process";
+import { readdir as readdir3, readFile as readFile7, realpath, stat as stat2, writeFile as writeFile4 } from "fs/promises";
+import { join as join12, relative, resolve as resolve5, sep as sep2 } from "path";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile4);
 var LIST_TTL_MS = 1e4;
 var MAX_CACHED_WORKSPACES = 16;
 var MAX_FILES_TRACKED = 2e4;
@@ -3685,7 +3880,7 @@ async function getFileList(workspacePath) {
 }
 async function probeFileList(workspacePath) {
   try {
-    const { stdout } = await exec2(
+    const { stdout } = await exec3(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard"],
       {
@@ -3714,7 +3909,7 @@ async function walkDir(root, dir, depth, out) {
   if (depth > WALK_MAX_DEPTH) return;
   let dirents;
   try {
-    dirents = await readdir2(dir, { withFileTypes: true });
+    dirents = await readdir3(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -3744,6 +3939,21 @@ async function ensureWorkspaceExists(id) {
   const ws = await getWorkspace(id);
   return ws ? ws.path : null;
 }
+var MAX_EDIT_BYTES = 1024 * 1024;
+var TREE_MAX_FILES = 5e3;
+function resolveInWorkspace(workspacePath, relPath) {
+  const root = resolve5(workspacePath);
+  const abs = resolve5(root, relPath);
+  if (abs !== root && !abs.startsWith(root + sep2)) return null;
+  return abs;
+}
+async function resolveExistingInWorkspace(workspacePath, relPath) {
+  const abs = resolveInWorkspace(workspacePath, relPath);
+  if (!abs) return null;
+  const [rootReal, targetReal] = await Promise.all([realpath(workspacePath), realpath(abs)]);
+  if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep2)) return null;
+  return targetReal;
+}
 function mountFilesRoute(app2) {
   app2.get("/:id/files/search", async (c) => {
     const id = c.req.param("id");
@@ -3791,12 +4001,81 @@ function mountFilesRoute(app2) {
       return c.json({ ok: false, error: message }, 500);
     }
   });
+  app2.get("/:id/files/list", async (c) => {
+    const id = c.req.param("id");
+    const workspacePath = await ensureWorkspaceExists(id);
+    if (!workspacePath) return c.json({ ok: false, error: "not found" }, 404);
+    try {
+      const all = await getFileList(workspacePath);
+      const entries = all.slice(0, TREE_MAX_FILES);
+      const body = {
+        workspacePath,
+        entries,
+        truncated: all.length > TREE_MAX_FILES
+      };
+      return c.json(body);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      console.error(`[api/files] list for ${id} failed:`, err2);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+  app2.get("/:id/file", async (c) => {
+    const id = c.req.param("id");
+    const workspacePath = await ensureWorkspaceExists(id);
+    if (!workspacePath) return c.json({ ok: false, error: "not found" }, 404);
+    const relPath = c.req.query("path");
+    if (!relPath) return c.json({ ok: false, error: "path query is required" }, 400);
+    try {
+      const abs = await resolveExistingInWorkspace(workspacePath, relPath);
+      if (!abs) return c.json({ ok: false, error: "path escapes workspace" }, 400);
+      const st = await stat2(abs);
+      if (!st.isFile()) return c.json({ ok: false, error: "not a file" }, 400);
+      if (st.size > MAX_EDIT_BYTES) {
+        return c.json({ ok: false, error: "file too large to edit (>1 MB)" }, 400);
+      }
+      const buf = await readFile7(abs);
+      if (buf.includes(0)) return c.json({ ok: false, error: "binary file" }, 400);
+      const body = { relPath, content: buf.toString("utf-8") };
+      return c.json(body);
+    } catch (err2) {
+      const code = err2.code;
+      const msg = code === "ENOENT" ? "not found" : code === "EACCES" ? "permission denied" : "read failed";
+      return c.json({ ok: false, error: msg }, 400);
+    }
+  });
+  app2.put("/:id/file", async (c) => {
+    const id = c.req.param("id");
+    const workspacePath = await ensureWorkspaceExists(id);
+    if (!workspacePath) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.path !== "string" || typeof body.content !== "string") {
+      return c.json({ ok: false, error: "path and content are required" }, 400);
+    }
+    if (Buffer.byteLength(body.content, "utf-8") > MAX_EDIT_BYTES) {
+      return c.json({ ok: false, error: "content too large (>1 MB)" }, 400);
+    }
+    try {
+      const abs = await resolveExistingInWorkspace(workspacePath, body.path);
+      if (!abs) return c.json({ ok: false, error: "path escapes workspace" }, 400);
+      const st = await stat2(abs);
+      if (!st.isFile()) return c.json({ ok: false, error: "not a file" }, 400);
+      await writeFile4(abs, body.content, "utf-8");
+      const ok = { ok: true };
+      return c.json(ok);
+    } catch (err2) {
+      const code = err2.code;
+      const msg = code === "ENOENT" ? "not found" : code === "EACCES" ? "permission denied" : "write failed";
+      return c.json({ ok: false, error: msg }, 400);
+    }
+  });
 }
 
 // src/api/resources.ts
-import { readdir as readdir3 } from "fs/promises";
+import { readdir as readdir4 } from "fs/promises";
 import { join as join13 } from "path";
 import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
+var MAX_SKILL_ZIP_BYTES = 25 * 1024 * 1024;
 function toResourceSource(info) {
   return {
     scope: info.scope,
@@ -3809,7 +4088,7 @@ async function scanExtensionDirs(workspaceCwd) {
   const found = [];
   for (const dir of dirs) {
     try {
-      const entries = await readdir3(dir, { withFileTypes: true });
+      const entries = await readdir4(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
           found.push(join13(dir, entry.name));
@@ -3989,6 +4268,39 @@ function mountResourcesRoute(app2) {
       return respondError(c, err2);
     }
   });
+  app2.post("/:id/resources/skills/install", async (c) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const scope = c.req.query("scope");
+    if (!isScope(scope)) {
+      return c.json({ ok: false, error: "scope query must be 'user' or 'project'" }, 400);
+    }
+    const overwrite = c.req.query("overwrite") === "1";
+    const declared = Number(c.req.header("content-length") ?? "0");
+    if (declared > MAX_SKILL_ZIP_BYTES) {
+      return c.json({ ok: false, error: "archive too large (max 25 MB)" }, 400);
+    }
+    let zip;
+    try {
+      zip = Buffer.from(await c.req.arrayBuffer());
+    } catch {
+      return c.json({ ok: false, error: "could not read upload" }, 400);
+    }
+    if (zip.length === 0) return c.json({ ok: false, error: "empty upload" }, 400);
+    if (zip.length > MAX_SKILL_ZIP_BYTES) {
+      return c.json({ ok: false, error: "archive too large (max 25 MB)" }, 400);
+    }
+    try {
+      await workspaceManager.getOrCreate(id);
+      const { roots, workspaceCwd } = await rootsFor(id);
+      await installSkillFromZip({ roots, scope, zip, overwrite });
+      await reload(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err2) {
+      return respondError(c, err2);
+    }
+  });
   app2.put("/:id/resources/skills", async (c) => {
     const id = c.req.param("id");
     const ws = await getWorkspace(id);
@@ -4400,7 +4712,7 @@ workspacesRoute.get("/:id/export", async (c) => {
     }
     const runtime = await workspaceManager.getOrCreate(id, sessionPath || void 0);
     const outputPath = await runtime.session.exportToHtml();
-    const html = await readFile7(outputPath, "utf-8");
+    const html = await readFile8(outputPath, "utf-8");
     const filename = basename2(outputPath);
     const body = { html, filename };
     return c.json(body);
@@ -4433,9 +4745,9 @@ workspacesRoute.post("/", async (c) => {
   if (!isAbsolute3(body.path)) {
     return c.json({ ok: false, error: "path must be absolute" }, 400);
   }
-  const resolved = resolve5(body.path);
+  const resolved = resolve6(body.path);
   try {
-    const st = await stat2(resolved);
+    const st = await stat3(resolved);
     if (!st.isDirectory()) {
       return c.json({ ok: false, error: "path is not a directory" }, 400);
     }
@@ -4476,18 +4788,18 @@ mountFilesRoute(workspacesRoute);
 workspacesRoute.route("/:id/tree", treeRoute);
 
 // src/api/fs.ts
-import { readdir as readdir4 } from "fs/promises";
+import { readdir as readdir5 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join14, resolve as resolve6 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join14, resolve as resolve7 } from "path";
 import { Hono as Hono3 } from "hono";
 var fsRoute = new Hono3();
 fsRoute.get("/browse", async (c) => {
   const rawPath = c.req.query("path");
   const showHidden = c.req.query("showHidden") === "1";
-  const target = rawPath && isAbsolute4(rawPath) ? resolve6(rawPath) : homedir3();
+  const target = rawPath && isAbsolute4(rawPath) ? resolve7(rawPath) : homedir3();
   let dirents;
   try {
-    dirents = await readdir4(target, { withFileTypes: true });
+    dirents = await readdir5(target, { withFileTypes: true });
   } catch (err2) {
     const code = err2.code;
     const msg = code === "EACCES" ? "permission denied" : code === "ENOENT" ? "not found" : "read failed";
@@ -4507,7 +4819,7 @@ fsRoute.get("/browse", async (c) => {
 });
 
 // src/api/model-configs.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { join as join15 } from "path";
 import { Hono as Hono4 } from "hono";
 import {
@@ -4563,7 +4875,7 @@ function modelsPath() {
 }
 async function readModelsJson() {
   try {
-    const raw = await readFile8(modelsPath(), "utf-8");
+    const raw = await readFile9(modelsPath(), "utf-8");
     return JSON.parse(raw);
   } catch (err2) {
     if (err2?.code === "ENOENT") {
@@ -4847,6 +5159,132 @@ function isAllowedWsOrigin(origin) {
   return allowedWsOrigins.has(origin);
 }
 
+// src/ws/terminals.ts
+import { createRequire } from "module";
+import { accessSync, chmodSync, constants, statSync } from "fs";
+import { join as join16 } from "path";
+import { spawn as spawn2 } from "node-pty";
+var FALLBACK_SHELL = process.platform === "win32" ? "powershell.exe" : "/bin/bash";
+function send(ws, msg) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(msg));
+}
+function ptyEnv() {
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (typeof v === "string") env[k] = v;
+  }
+  env.TERM = "xterm-256color";
+  env.COLORTERM = "truecolor";
+  return env;
+}
+async function handleTerminalMessage(ws, terminals, msg) {
+  switch (msg.type) {
+    case "terminal_open": {
+      ensureSpawnHelperExecutable();
+      const existing = terminals.get(msg.terminalId);
+      if (existing) {
+        try {
+          existing.kill();
+        } catch {
+        }
+        terminals.delete(msg.terminalId);
+      }
+      const ws_ = await getWorkspace(msg.workspaceId);
+      if (!ws_) {
+        send(ws, { type: "terminal_error", terminalId: msg.terminalId, message: "workspace not found" });
+        return;
+      }
+      const shell = process.env.SHELL || FALLBACK_SHELL;
+      let pty;
+      try {
+        pty = spawn2(shell, [], {
+          name: "xterm-256color",
+          cols: clampDim(msg.cols, 80),
+          rows: clampDim(msg.rows, 24),
+          cwd: ws_.path,
+          env: ptyEnv()
+        });
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        send(ws, { type: "terminal_error", terminalId: msg.terminalId, message });
+        return;
+      }
+      terminals.set(msg.terminalId, pty);
+      pty.onData((data) => {
+        send(ws, { type: "terminal_output", terminalId: msg.terminalId, data });
+      });
+      pty.onExit(({ exitCode }) => {
+        terminals.delete(msg.terminalId);
+        send(ws, { type: "terminal_exit", terminalId: msg.terminalId, exitCode });
+      });
+      return;
+    }
+    case "terminal_input": {
+      terminals.get(msg.terminalId)?.write(msg.data);
+      return;
+    }
+    case "terminal_resize": {
+      const pty = terminals.get(msg.terminalId);
+      if (pty) {
+        try {
+          pty.resize(clampDim(msg.cols, 80), clampDim(msg.rows, 24));
+        } catch {
+        }
+      }
+      return;
+    }
+    case "terminal_close": {
+      const pty = terminals.get(msg.terminalId);
+      if (pty) {
+        terminals.delete(msg.terminalId);
+        try {
+          pty.kill();
+        } catch {
+        }
+      }
+      return;
+    }
+  }
+}
+function closeAllTerminals(terminals) {
+  for (const pty of terminals.values()) {
+    try {
+      pty.kill();
+    } catch {
+    }
+  }
+  terminals.clear();
+}
+function clampDim(n, fallback) {
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+var spawnHelperChecked = false;
+function ensureSpawnHelperExecutable() {
+  if (spawnHelperChecked || process.platform === "win32") return;
+  spawnHelperChecked = true;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const root = join16(require2.resolve("node-pty/package.json"), "..");
+    const candidates = [
+      join16(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper"),
+      join16(root, "build", "Release", "spawn-helper")
+    ];
+    for (const path of candidates) {
+      try {
+        accessSync(path, constants.X_OK);
+      } catch {
+        try {
+          const mode = statSync(path).mode;
+          chmodSync(path, mode | 73);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+
 // src/ws/hub.ts
 var BACKGROUND_CAP = 4;
 var replacementLocks = /* @__PURE__ */ new Map();
@@ -4877,7 +5315,7 @@ function attachWsHub(httpServer) {
     }
   });
   wss.on("connection", (ws) => {
-    const state = { background: /* @__PURE__ */ new Map() };
+    const state = { background: /* @__PURE__ */ new Map(), terminals: /* @__PURE__ */ new Map() };
     let inbound = Promise.resolve();
     ws.on("message", (raw) => {
       inbound = inbound.then(async () => {
@@ -4885,14 +5323,14 @@ function attachWsHub(httpServer) {
         try {
           msg = JSON.parse(raw.toString());
         } catch {
-          send(ws, { type: "error", message: "invalid JSON" });
+          send2(ws, { type: "error", message: "invalid JSON" });
           return;
         }
         try {
           await handle(ws, state, msg);
         } catch (err2) {
           const message = err2 instanceof Error ? err2.message : String(err2);
-          send(ws, { type: "error", message, command: msg.type });
+          send2(ws, { type: "error", message, command: msg.type });
         }
       }).catch((err2) => {
         console.error("[ws] inbound chain error:", err2);
@@ -4912,12 +5350,12 @@ async function handle(ws, state, msg) {
         runtime = await workspaceManager.getOrCreate(msg.workspaceId, msg.sessionPath);
       } catch (err2) {
         const message = err2 instanceof Error ? err2.message : String(err2);
-        send(ws, { type: "error", message, command: "subscribe" });
-        send(ws, { type: "ack", command: "subscribe" });
+        send2(ws, { type: "error", message, command: "subscribe" });
+        send2(ws, { type: "ack", command: "subscribe" });
         return;
       }
       promoteToPrimary(ws, state, msg.workspaceId, runtime);
-      send(ws, { type: "ack", command: "subscribe" });
+      send2(ws, { type: "ack", command: "subscribe" });
       return;
     }
     case "unsubscribe": {
@@ -4929,23 +5367,23 @@ async function handle(ws, state, msg) {
     case "prompt": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "prompt" });
+        send2(ws, { type: "error", message: "not subscribed", command: "prompt" });
         return;
       }
       if (replacementLocks.has(primary.workspaceId)) {
-        send(ws, { type: "error", message: "session switching in progress", command: "prompt" });
+        send2(ws, { type: "error", message: "session switching in progress", command: "prompt" });
         return;
       }
       void primary.runtime.session.prompt(msg.message, { streamingBehavior: msg.streamingBehavior }).catch((err2) => {
         const message = err2 instanceof Error ? err2.message : String(err2);
-        send(ws, { type: "error", message, command: "prompt" });
+        send2(ws, { type: "error", message, command: "prompt" });
       });
       return;
     }
     case "abort": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "abort" });
+        send2(ws, { type: "error", message: "not subscribed", command: "abort" });
         return;
       }
       await primary.runtime.session.abort();
@@ -4959,7 +5397,7 @@ async function handle(ws, state, msg) {
           runtime = await workspaceManager.createSession(workspaceId);
         } catch (err2) {
           const message = err2 instanceof Error ? err2.message : String(err2);
-          send(ws, { type: "error", message, command: "new_session" });
+          send2(ws, { type: "error", message, command: "new_session" });
           return;
         }
         promoteToPrimary(ws, state, workspaceId, runtime);
@@ -4969,22 +5407,22 @@ async function handle(ws, state, msg) {
     case "fork": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "fork" });
+        send2(ws, { type: "error", message: "not subscribed", command: "fork" });
         return;
       }
       const workspaceId = primary.workspaceId;
       await withReplacementLock(workspaceId, async () => {
         const source = state.primary;
         if (!source) {
-          send(ws, { type: "error", message: "not subscribed", command: "fork" });
+          send2(ws, { type: "error", message: "not subscribed", command: "fork" });
           return;
         }
         if (!source.sessionPath) {
-          send(ws, { type: "error", message: "cannot fork an unsaved session", command: "fork" });
+          send2(ws, { type: "error", message: "cannot fork an unsaved session", command: "fork" });
           return;
         }
         if (source.runtime.session.isStreaming) {
-          send(ws, { type: "error", message: "cannot fork while streaming", command: "fork" });
+          send2(ws, { type: "error", message: "cannot fork while streaming", command: "fork" });
           return;
         }
         let result;
@@ -4992,11 +5430,11 @@ async function handle(ws, state, msg) {
           result = await workspaceManager.fork(workspaceId, source.sessionPath, msg.entryId);
         } catch (err2) {
           const message = err2 instanceof Error ? err2.message : String(err2);
-          send(ws, { type: "error", message, command: "fork" });
+          send2(ws, { type: "error", message, command: "fork" });
           return;
         }
         if (result.cancelled || !result.runtime) {
-          send(ws, { type: "error", message: "fork cancelled", command: "fork" });
+          send2(ws, { type: "error", message: "fork cancelled", command: "fork" });
           return;
         }
         promoteToPrimary(ws, state, workspaceId, result.runtime);
@@ -5006,7 +5444,7 @@ async function handle(ws, state, msg) {
     case "answer_question": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "answer_question" });
+        send2(ws, { type: "error", message: "not subscribed", command: "answer_question" });
         return;
       }
       resolveAnswer(msg.toolCallId, msg.answer, primary.runtime.session.sessionFile ?? null);
@@ -5015,28 +5453,28 @@ async function handle(ws, state, msg) {
     case "navigate_tree": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+        send2(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
         return;
       }
       if (msg.workspaceId !== primary.workspaceId) {
-        send(ws, { type: "error", message: "workspace mismatch", command: "navigate_tree" });
+        send2(ws, { type: "error", message: "workspace mismatch", command: "navigate_tree" });
         return;
       }
       await withReplacementLock(primary.workspaceId, async () => {
         const current = state.primary;
         if (!current) {
-          send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+          send2(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
           return;
         }
         if (current.runtime.session.isStreaming) {
-          send(ws, { type: "error", message: "cannot navigate tree while streaming", command: "navigate_tree" });
+          send2(ws, { type: "error", message: "cannot navigate tree while streaming", command: "navigate_tree" });
           return;
         }
         const result = await current.runtime.session.navigateTree(msg.targetId, {
           summarize: msg.summarize,
           customInstructions: msg.customInstructions
         });
-        send(ws, {
+        send2(ws, {
           type: "navigate_tree_result",
           workspaceId: current.workspaceId,
           editorText: result.editorText,
@@ -5048,27 +5486,34 @@ async function handle(ws, state, msg) {
     case "compact": {
       const primary = state.primary;
       if (!primary) {
-        send(ws, { type: "error", message: "not subscribed", command: "compact" });
+        send2(ws, { type: "error", message: "not subscribed", command: "compact" });
         return;
       }
       if (primary.runtime.session.isStreaming) {
-        send(ws, { type: "error", message: "cannot compact while streaming", command: "compact" });
+        send2(ws, { type: "error", message: "cannot compact while streaming", command: "compact" });
         return;
       }
       if (primary.runtime.session.isCompacting) {
-        send(ws, { type: "error", message: "compaction already in progress", command: "compact" });
+        send2(ws, { type: "error", message: "compaction already in progress", command: "compact" });
         return;
       }
       primary.runtime.session.compact().catch((err2) => {
         const message = err2 instanceof Error ? err2.message : String(err2);
-        send(ws, { type: "error", message, command: "compact" });
+        send2(ws, { type: "error", message, command: "compact" });
       });
       return;
     }
+    case "terminal_open":
+    case "terminal_input":
+    case "terminal_resize":
+    case "terminal_close": {
+      await handleTerminalMessage(ws, state.terminals, msg);
+      return;
+    }
     default: {
       const _ = msg;
       void _;
-      send(ws, { type: "error", message: "unknown command" });
+      send2(ws, { type: "error", message: "unknown command" });
     }
   }
 }
@@ -5100,7 +5545,7 @@ function bindPrimary(ws, state, workspaceId, runtime) {
     } else if (payload.kind === "message_update" && payload.delta.kind === "text" && assistantStartAt !== void 0 && assistantFirstTokenAt === void 0) {
       assistantFirstTokenAt = performance.now();
     }
-    send(ws, { type: "event", workspaceId, sessionPath, payload });
+    send2(ws, { type: "event", workspaceId, sessionPath, payload });
     if (payload.kind === "message_end" && payload.role === "assistant" && assistantStartAt !== void 0) {
       const now = performance.now();
       const timing = {
@@ -5108,7 +5553,7 @@ function bindPrimary(ws, state, workspaceId, runtime) {
         firstTokenMs: assistantFirstTokenAt !== void 0 ? Math.round(assistantFirstTokenAt - assistantStartAt) : null,
         totalMs: Math.round(now - assistantStartAt)
       };
-      send(ws, { type: "event", workspaceId, sessionPath, payload: timing });
+      send2(ws, { type: "event", workspaceId, sessionPath, payload: timing });
       assistantStartAt = void 0;
       assistantFirstTokenAt = void 0;
     }
@@ -5124,16 +5569,16 @@ function bindPrimary(ws, state, workspaceId, runtime) {
     runtime.session.state.pendingToolCalls,
     scanMessages
   )) {
-    send(ws, { type: "event", workspaceId, sessionPath, payload });
+    send2(ws, { type: "event", workspaceId, sessionPath, payload });
   }
   const inFlight = inFlightAssistantSnapshot(streamingMessage);
   if (inFlight) {
     for (const payload of inFlight) {
-      send(ws, { type: "event", workspaceId, sessionPath, payload });
+      send2(ws, { type: "event", workspaceId, sessionPath, payload });
     }
   }
   for (const payload of inFlightToolCallsSnapshot(sessionPath)) {
-    send(ws, { type: "event", workspaceId, sessionPath, payload });
+    send2(ws, { type: "event", workspaceId, sessionPath, payload });
   }
   sendContextUsage(ws, runtime, workspaceId, sessionPath);
 }
@@ -5147,7 +5592,7 @@ function demotePrimaryToBackground(ws, state) {
   const unsubscribeSession = session.subscribe((ev) => {
     const payload = translatePiEvent(ev);
     if (!payload) return;
-    send(ws, { type: "event", workspaceId: primary.workspaceId, sessionPath, payload });
+    send2(ws, { type: "event", workspaceId: primary.workspaceId, sessionPath, payload });
     if (payload.kind === "agent_end" || payload.kind === "compaction_end" || payload.kind === "session_info_changed" || payload.kind === "thinking_level_changed") {
       sendContextUsage(ws, primary.runtime, primary.workspaceId, sessionPath);
     }
@@ -5163,7 +5608,7 @@ function demotePrimaryToBackground(ws, state) {
     const evicted = state.background.get(oldestKey);
     teardownBackground(state, oldestKey, ws);
     if (evicted) {
-      send(ws, {
+      send2(ws, {
         type: "background_evicted",
         workspaceId: evicted.workspaceId,
         sessionPath: evicted.sessionPath
@@ -5179,7 +5624,7 @@ function teardownBackground(state, runtimeKey, ws) {
   if (ws) unrefWorkspaceSubscriber(state, bg.workspaceId, ws);
 }
 function sendSubscribed(ws, workspaceId, runtime) {
-  send(ws, {
+  send2(ws, {
     type: "subscribed",
     workspaceId,
     sessionPath: runtime.session.sessionFile ?? null,
@@ -5199,7 +5644,7 @@ function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
     contextWindow: usage.contextWindow,
     percent: usage.percent
   };
-  send(ws, { type: "event", workspaceId, sessionPath, payload });
+  send2(ws, { type: "event", workspaceId, sessionPath, payload });
 }
 function detachPrimary(state, ws) {
   const primary = state.primary;
@@ -5213,8 +5658,9 @@ function detach(state, ws) {
   for (const runtimeKey of [...state.background.keys()]) {
     teardownBackground(state, runtimeKey, ws);
   }
+  closeAllTerminals(state.terminals);
 }
-function send(ws, msg) {
+function send2(ws, msg) {
   if (ws.readyState !== ws.OPEN) return;
   ws.send(JSON.stringify(msg));
 }
@@ -5223,8 +5669,8 @@ function send(ws, msg) {
 configureHttpProxy();
 var app = new Hono6();
 var distDir = dirname6(fileURLToPath2(import.meta.url));
-var webRoot = resolve7(process.env.PI_PILOT_WEB_ROOT ?? join16(distDir, "..", "public"));
-var webIndexPath = join16(webRoot, "index.html");
+var webRoot = resolve8(process.env.PI_PILOT_WEB_ROOT ?? join17(distDir, "..", "public"));
+var webIndexPath = join17(webRoot, "index.html");
 var mimeTypes = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -5250,7 +5696,7 @@ function safeResolveWebPath(pathname) {
     return void 0;
   }
   const relativePath = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
-  const candidate = resolve7(webRoot, relativePath);
+  const candidate = resolve8(webRoot, relativePath);
   if (candidate !== webRoot && !candidate.startsWith(`${webRoot}${sep3}`)) {
     return void 0;
   }
@@ -5258,7 +5704,7 @@ function safeResolveWebPath(pathname) {
 }
 async function readWebFile(path) {
   try {
-    return await readFile9(path);
+    return await readFile10(path);
   } catch (err2) {
     const code = err2.code;
     if (code === "ENOENT" || code === "EISDIR") return void 0;
@@ -5271,7 +5717,7 @@ async function serveWeb(c) {
   const assetPath = safeResolveWebPath(pathname);
   if (!assetPath) return c.text("invalid asset path", 400);
   const asset = await readWebFile(assetPath);
-  const body = asset ?? await readFile9(webIndexPath);
+  const body = asset ?? await readFile10(webIndexPath);
   const filePath = asset ? assetPath : webIndexPath;
   const headers = {
     "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",