@jyork0828/pi-pilot 0.0.2 → 0.0.5

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 import { existsSync } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import { dirname as dirname5, extname, join as join8, resolve as resolve5, sep as sep3 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { dirname as dirname6, extname, join as join9, resolve as resolve5, sep as sep3 } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono as Hono4 } from "hono";
@@ -24,6 +24,22 @@ var config = {
   corsOrigin: process.env.PI_PILOT_CORS_ORIGIN ?? "http://localhost:5173"
 };
 
+// src/http-proxy.ts
+import { EnvHttpProxyAgent, install, setGlobalDispatcher } from "undici";
+var configured = false;
+function configureHttpProxy() {
+  if (configured) return;
+  configured = true;
+  setGlobalDispatcher(
+    new EnvHttpProxyAgent({
+      allowH2: false,
+      bodyTimeout: 3e5,
+      headersTimeout: 3e5
+    })
+  );
+  install?.();
+}
+
 // src/api/workspaces.ts
 import { stat as stat2 } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
@@ -408,8 +424,8 @@ async function getStats(path) {
   const now = Date.now();
   const cached = cache2.get(path);
   if (cached && cached.expiresAt > now) return cached;
-  const pending = inflight.get(path);
-  if (pending) return pending;
+  const pending2 = inflight.get(path);
+  if (pending2) return pending2;
   const probe = probeStats(path).then((stats) => {
     const entry = {
       ...stats,
@@ -539,8 +555,513 @@ var planExtensionFactory = (pi) => {
   });
 };
 
+// src/extensions/ask_user/schema.ts
+import { Type as Type2 } from "typebox";
+var askUserOptionSchema = Type2.Object({
+  label: Type2.String({
+    description: "Short, distinct choice (1\u20135 words). User-facing."
+  }),
+  description: Type2.Optional(
+    Type2.String({
+      description: "Optional one-line clarification of what this choice means or implies."
+    })
+  )
+});
+var askUserParamsSchema = Type2.Object({
+  question: Type2.String({
+    description: "Full question, specific and ending with '?'. Avoid yes/no when options can be more concrete."
+  }),
+  header: Type2.Optional(
+    Type2.String({
+      maxLength: 12,
+      description: "Optional short chip label (\u2264 12 chars), e.g. 'Auth method'. Shown next to the question."
+    })
+  ),
+  options: Type2.Array(askUserOptionSchema, {
+    minItems: 2,
+    maxItems: 4,
+    description: "2\u20134 mutually exclusive choices (unless multiSelect is true). Recommended option first; append ' (Recommended)' to its label."
+  }),
+  multiSelect: Type2.Optional(
+    Type2.Boolean({
+      description: "If true, render checkboxes and allow multiple selections. Default false."
+    })
+  ),
+  allowOther: Type2.Optional(
+    Type2.Boolean({
+      description: "If true, show a freeform 'Other' input as an escape hatch. Default true."
+    })
+  ),
+  timeoutSec: Type2.Optional(
+    Type2.Integer({
+      minimum: 5,
+      description: "Auto-resolve as skip after this many seconds. Only set for time-sensitive questions where a stale answer would be worse than no answer."
+    })
+  )
+});
+
+// src/extensions/ask_user/registry.ts
+var pending = /* @__PURE__ */ new Map();
+function register(toolCallId, entry) {
+  pending.set(toolCallId, entry);
+}
+function unregister(toolCallId) {
+  pending.delete(toolCallId);
+}
+function resolveAnswer(toolCallId, answer, expectedSessionFile) {
+  const entry = pending.get(toolCallId);
+  if (!entry) return false;
+  if (entry.sessionFile !== expectedSessionFile) return false;
+  pending.delete(toolCallId);
+  entry.resolve(answer);
+  return true;
+}
+function cancelPendingExcept(keepSessionFile) {
+  for (const [id, entry] of pending) {
+    if (entry.sessionFile === keepSessionFile) continue;
+    pending.delete(id);
+    entry.reject(new Error("Session replaced before answer arrived"));
+  }
+}
+function cancelPendingForSession(sessionFile) {
+  for (const [id, entry] of pending) {
+    if (entry.sessionFile !== sessionFile) continue;
+    pending.delete(id);
+    entry.reject(new Error("Workspace disposed"));
+  }
+}
+function snapshotForSession(sessionFile) {
+  const out = [];
+  for (const [id, entry] of pending) {
+    if (entry.sessionFile !== sessionFile) continue;
+    out.push({ toolCallId: id, args: entry.args });
+  }
+  return out;
+}
+
+// src/extensions/ask_user/factory.ts
+var askUserExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: "ask_user",
+    label: "Ask user",
+    description: "Pause and ask the user a structured multiple-choice question. Use ONLY for genuine forks where the user's preference materially changes the work (UI layout, library choice, scope boundary). Returns the user's selection (or 'skip' if they dismissed).",
+    parameters: askUserParamsSchema,
+    promptSnippet: "ask_user: pause and ask the user a structured multiple-choice question when a decision is genuinely theirs.",
+    promptGuidelines: [
+      "Call ask_user only for genuine forks where the user's preference materially changes the work \u2014 UI layout, library choice, scope boundary. Don't ask for opinions you can defend yourself.",
+      "Each ask_user call asks ONE question. If you have several, call it multiple times in order so the user sees one at a time.",
+      "ask_user options must be distinct and mutually exclusive (unless multiSelect is true). 2\u20134 options; put the recommended option first and append ' (Recommended)' to its label.",
+      "Don't follow up ask_user with 'Should I proceed?' \u2014 the answer already authorizes the next step.",
+      "Only set ask_user's timeoutSec for time-sensitive questions where a stale answer would be worse than no answer; otherwise let the user take as long as they need."
+    ],
+    execute: async (toolCallId, params, signal, _onUpdate, ctx) => {
+      const sessionFile = ctx.sessionManager.getSessionFile() ?? null;
+      const startedAt = Date.now();
+      const answer = await waitForAnswer({
+        toolCallId,
+        params,
+        sessionFile,
+        signal
+      });
+      return formatResult(params, answer, startedAt);
+    }
+  });
+};
+function waitForAnswer({
+  toolCallId,
+  params,
+  sessionFile,
+  signal
+}) {
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    let timeoutHandle;
+    const cleanup = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      signal?.removeEventListener("abort", onAbort);
+      unregister(toolCallId);
+    };
+    const finishOk = (a) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve6(a);
+    };
+    const finishErr = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
+    const onAbort = () => finishErr(new Error("Aborted by user"));
+    if (signal?.aborted) {
+      finishErr(new Error("Aborted by user"));
+      return;
+    }
+    signal?.addEventListener("abort", onAbort);
+    if (typeof params.timeoutSec === "number" && params.timeoutSec > 0) {
+      const ms = params.timeoutSec * 1e3;
+      timeoutHandle = setTimeout(() => {
+        finishOk({ kind: "timeout", afterMs: ms });
+      }, ms);
+    }
+    register(toolCallId, {
+      args: params,
+      sessionFile,
+      resolve: (answer) => finishOk(answer),
+      reject: (err) => finishErr(err)
+    });
+  });
+}
+function formatResult(params, answer, startedAt) {
+  if (answer.kind === "option") {
+    const labels = answer.indices.map((i) => params.options[i]?.label).filter((l) => typeof l === "string");
+    const text2 = labels.length === 1 ? `User selected: "${labels[0]}"${descriptionSuffix(params, answer.indices[0])}.` : `User selected: ${labels.map((l) => `"${l}"`).join(", ")}.`;
+    const details2 = {
+      kind: "option",
+      indices: answer.indices,
+      labels
+    };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
+    };
+  }
+  if (answer.kind === "other") {
+    const text2 = `User answered (freeform): "${answer.text}"`;
+    const details2 = { kind: "other", text: answer.text };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
+    };
+  }
+  if (answer.kind === "skip") {
+    const text2 = "User chose to skip this question. Use your best judgement and proceed; you may ask again later if it still matters.";
+    const details2 = { kind: "skip" };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
+    };
+  }
+  const waited = Math.round((Date.now() - startedAt) / 1e3);
+  const text = `No answer within ${waited}s (agent-supplied timeout). Use your best judgement and proceed; you may ask again later if it still matters.`;
+  const details = {
+    kind: "timeout",
+    afterMs: answer.afterMs
+  };
+  return {
+    content: [{ type: "text", text }],
+    details
+  };
+}
+function descriptionSuffix(params, index) {
+  const desc = params.options[index]?.description;
+  return desc ? ` \u2014 ${desc}` : "";
+}
+
+// src/storage/builtin-extension-prefs.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+var PREFS_PATH = join4(config.dataDir, "builtin-extensions.json");
+var cache3 = { disabled: [] };
+async function loadBuiltinPrefs() {
+  try {
+    const raw = await readFile3(PREFS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    cache3 = { disabled: Array.isArray(parsed.disabled) ? parsed.disabled : [] };
+  } catch (err) {
+    cache3 = { disabled: [] };
+    if (err.code !== "ENOENT") {
+      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH}:`, err);
+    }
+  }
+}
+function isBuiltinDisabled(id) {
+  return cache3.disabled.includes(id);
+}
+function getDisabledBuiltins() {
+  return [...cache3.disabled];
+}
+async function setBuiltinEnabled(id, enabled) {
+  const next = new Set(cache3.disabled);
+  if (enabled) next.delete(id);
+  else next.add(id);
+  cache3 = { disabled: [...next] };
+  await save2();
+}
+async function save2() {
+  await mkdir3(dirname3(PREFS_PATH), { recursive: true });
+  await writeFile3(PREFS_PATH, JSON.stringify(cache3, null, 2), "utf8");
+}
+
 // src/extensions/index.ts
-var builtinExtensionFactories = [planExtensionFactory];
+var BUILTIN_EXTENSIONS = [
+  {
+    id: "plan",
+    name: "Plan",
+    description: "A live task checklist for multi-step work \u2014 adds the update_plan tool and the /plan command.",
+    tools: ["update_plan"],
+    commands: ["plan"],
+    factory: planExtensionFactory
+  },
+  {
+    id: "ask_user",
+    name: "Ask user",
+    description: "Lets the agent pause and ask you a structured multiple-choice question \u2014 adds the ask_user tool.",
+    tools: ["ask_user"],
+    commands: [],
+    factory: askUserExtensionFactory
+  }
+];
+function gate(def) {
+  return (pi) => {
+    if (isBuiltinDisabled(def.id)) return;
+    return def.factory(pi);
+  };
+}
+var builtinExtensionFactories = BUILTIN_EXTENSIONS.map(gate);
+
+// src/extensions/ask_user/cleanup.ts
+var CUSTOM_TYPE = "ask_user-restart-cancelled";
+function reconcileAfterRestart(sessionManager) {
+  const branch = sessionManager.getBranch();
+  if (branch.length === 0) return;
+  const satisfied = /* @__PURE__ */ new Set();
+  const danglingIds = [];
+  const danglingAlreadyHandled = /* @__PURE__ */ new Set();
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i];
+    if (entry.type === "custom_message") {
+      const cm = entry;
+      if (cm.customType === CUSTOM_TYPE) {
+        const ids = cm.details?.ids;
+        if (Array.isArray(ids)) {
+          for (const id of ids) {
+            if (typeof id === "string") danglingAlreadyHandled.add(id);
+          }
+        }
+      }
+      continue;
+    }
+    if (entry.type !== "message") continue;
+    const msg = entry.message;
+    if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
+      satisfied.add(msg.toolCallId);
+      continue;
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type !== "toolCall") continue;
+        if (b.name !== "ask_user") continue;
+        if (typeof b.id !== "string") continue;
+        if (satisfied.has(b.id)) continue;
+        if (danglingAlreadyHandled.has(b.id)) continue;
+        danglingIds.push(b.id);
+      }
+      break;
+    }
+    if (msg.role === "user") break;
+  }
+  if (danglingIds.length === 0) return;
+  const idList = danglingIds.join(", ");
+  const text = `[pi-pilot] Your previous ask_user call(s) [${idList}] were cancelled because the server restarted before the user answered. Use your best judgement and proceed; you may re-call ask_user if the decision still matters.`;
+  sessionManager.appendCustomMessageEntry(
+    CUSTOM_TYPE,
+    text,
+    true,
+    // display in TUI too (no-op in pi-pilot, but harmless)
+    { ids: danglingIds }
+  );
+}
+
+// src/ws/bridge.ts
+function translatePiEvent(ev) {
+  switch (ev.type) {
+    case "agent_start":
+      return { kind: "agent_start" };
+    case "agent_end":
+      return { kind: "agent_end", willRetry: ev.willRetry };
+    case "turn_start":
+      return { kind: "turn_start" };
+    case "turn_end":
+      return { kind: "turn_end" };
+    case "message_start": {
+      const role = roleOf(ev.message);
+      const text = role === "user" ? extractUserText(ev.message) : void 0;
+      return { kind: "message_start", role, text };
+    }
+    case "message_end":
+      return { kind: "message_end", role: roleOf(ev.message) };
+    case "message_update": {
+      const ame = ev.assistantMessageEvent;
+      if (ame.type === "text_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "text", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      if (ame.type === "thinking_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "thinking", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      return { kind: "message_update", delta: { kind: "other" } };
+    }
+    case "tool_execution_start":
+      return {
+        kind: "tool_execution_start",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        args: ev.args
+      };
+    case "tool_execution_update":
+      return {
+        kind: "tool_execution_update",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        partialText: extractText(ev.partialResult)
+      };
+    case "tool_execution_end": {
+      const details = shouldForwardDetails(ev.toolName) ? ev.result?.details : void 0;
+      return {
+        kind: "tool_execution_end",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        isError: ev.isError,
+        text: extractText(ev.result),
+        ...details !== void 0 ? { details } : {}
+      };
+    }
+    case "queue_update":
+      return {
+        kind: "queue_update",
+        steering: [...ev.steering],
+        followUp: [...ev.followUp]
+      };
+    case "auto_retry_start":
+      return {
+        kind: "auto_retry_start",
+        attempt: ev.attempt,
+        maxAttempts: ev.maxAttempts,
+        delayMs: ev.delayMs,
+        errorMessage: ev.errorMessage
+      };
+    case "auto_retry_end":
+      return {
+        kind: "auto_retry_end",
+        success: ev.success,
+        attempt: ev.attempt,
+        finalError: ev.finalError
+      };
+    case "compaction_start":
+      return { kind: "compaction_start", reason: ev.reason };
+    case "compaction_end":
+      return {
+        kind: "compaction_end",
+        reason: ev.reason,
+        aborted: ev.aborted,
+        willRetry: ev.willRetry,
+        errorMessage: ev.errorMessage
+      };
+    case "session_info_changed":
+      return { kind: "session_info_changed", name: ev.name };
+    case "thinking_level_changed":
+      return { kind: "thinking_level_changed", level: ev.level };
+    default:
+      return void 0;
+  }
+}
+var warnedUnknownRoles = /* @__PURE__ */ new Set();
+function roleOf(message) {
+  const role = message?.role;
+  if (role === "user" || role === "assistant" || role === "toolResult" || role === "bashExecution") {
+    return role;
+  }
+  const key = typeof role === "string" ? role : `<${role === void 0 ? "missing" : typeof role}>`;
+  if (!warnedUnknownRoles.has(key)) {
+    warnedUnknownRoles.add(key);
+    console.warn(
+      `[bridge] unknown message role "${key}" \u2014 treating as assistant. Pi SDK may have added a role bridge.ts and chat.ts don't handle yet.`
+    );
+  }
+  return "assistant";
+}
+function extractUserText(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  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.length === 0 ? void 0 : parts.join("");
+}
+function inFlightAssistantSnapshot(streamingMessage) {
+  if (!streamingMessage || typeof streamingMessage !== "object") return void 0;
+  const m = streamingMessage;
+  if (m.role !== "assistant" || !Array.isArray(m.content)) return void 0;
+  let textAccum = "";
+  let thinkingAccum = "";
+  for (const block of m.content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      textAccum += b.text;
+    } else if (b.type === "thinking" && typeof b.thinking === "string") {
+      thinkingAccum += b.thinking;
+    }
+  }
+  if (!textAccum && !thinkingAccum) return void 0;
+  const events = [
+    { kind: "message_start", role: "assistant" }
+  ];
+  if (thinkingAccum) {
+    events.push({
+      kind: "message_update",
+      delta: { kind: "thinking", contentIndex: 0, text: thinkingAccum }
+    });
+  }
+  if (textAccum) {
+    events.push({
+      kind: "message_update",
+      delta: { kind: "text", contentIndex: 0, text: textAccum }
+    });
+  }
+  return events;
+}
+function inFlightToolCallsSnapshot(sessionFile) {
+  const pending2 = snapshotForSession(sessionFile);
+  return pending2.map((p) => ({
+    kind: "tool_execution_start",
+    toolCallId: p.toolCallId,
+    toolName: "ask_user",
+    args: p.args
+  }));
+}
+var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set(["ask_user"]);
+function shouldForwardDetails(toolName) {
+  return DETAILS_FORWARD_WHITELIST.has(toolName);
+}
+function extractText(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const content = result.content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const c of content) {
+    if (c && typeof c === "object" && c.type === "text") {
+      const text = c.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.length === 0 ? void 0 : parts.join("");
+}
 
 // src/ws/extension-ui.ts
 var ExtensionUIBridge = class {
@@ -709,8 +1230,11 @@ ${err.stack}` : "")
       );
     };
     await runtime.session.bindExtensions({ uiContext: bridge, onError });
+    safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
     runtime.setRebindSession(async () => {
       await runtime.session.bindExtensions({ uiContext: bridge, onError });
+      cancelPendingExcept(runtime.session.sessionFile ?? null);
+      safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
       this.notifySessionReplaced(workspaceId);
     });
     return { runtime, bridge };
@@ -796,7 +1320,7 @@ ${err.stack}` : "")
       const msg = entry.message;
       const role = msg.role;
       if (role === "user") {
-        const text = extractUserText(msg);
+        const text = extractUserText2(msg);
         if (text) items.push({ kind: "user", text });
       } else if (role === "assistant") {
         const { text, thinking, toolCalls } = extractAssistantContent(
@@ -814,7 +1338,11 @@ ${err.stack}` : "")
           toolName: tr.toolName,
           args: argsByCallId.get(tr.toolCallId) ?? "",
           text: extractContentText(tr.content),
-          isError: tr.isError
+          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;
@@ -900,6 +1428,7 @@ ${err.stack}` : "")
     this.states.delete(workspaceId);
     this.rebindListeners.delete(workspaceId);
     this.subscribers.delete(workspaceId);
+    cancelPendingForSession(state.runtime.session.sessionFile ?? null);
     try {
       state.bridge.dispose();
     } catch (e) {
@@ -912,10 +1441,18 @@ ${err.stack}` : "")
     }
   }
   async disposeAll() {
+    await Promise.allSettled([...this.pending.values()]);
     const ids = [...this.states.keys()];
     await Promise.all(ids.map((id) => this.dispose(id)));
   }
 };
+function safeReconcileAskUser(workspaceId, sm) {
+  try {
+    reconcileAfterRestart(sm);
+  } catch (e) {
+    console.error(`[wm] ask_user cleanup for ${workspaceId} failed:`, e);
+  }
+}
 function toSessionSummary(info) {
   const preview = info.firstMessage.replace(/\s+/g, " ").trim();
   return {
@@ -925,7 +1462,7 @@ function toSessionSummary(info) {
     preview: preview ? preview.slice(0, 160) : void 0
   };
 }
-function extractUserText(msg) {
+function extractUserText2(msg) {
   if (typeof msg.content === "string") return msg.content;
   return extractContentText(msg.content);
 }
@@ -1127,7 +1664,7 @@ function mountConfigRoutes(app2) {
 // src/api/files.ts
 import { execFile as execFile2 } from "child_process";
 import { readdir } from "fs/promises";
-import { join as join4, relative, sep as sep2 } from "path";
+import { join as join5, relative, sep as sep2 } from "path";
 import { promisify as promisify2 } from "util";
 var exec2 = promisify2(execFile2);
 var LIST_TTL_MS = 1e4;
@@ -1159,8 +1696,8 @@ async function getFileList(workspacePath) {
   const now = Date.now();
   const cached = listCache.get(workspacePath);
   if (cached && cached.expiresAt > now) return cached.files;
-  const pending = inflight2.get(workspacePath);
-  if (pending) return (await pending).files;
+  const pending2 = inflight2.get(workspacePath);
+  if (pending2) return (await pending2).files;
   const probe = probeFileList(workspacePath).then((files) => {
     const entry = {
       files,
@@ -1216,7 +1753,7 @@ async function walkDir(root, dir, depth, out) {
   for (const d of dirents) {
     if (out.length >= MAX_FILES_TRACKED) return;
     if (WALK_IGNORES.has(d.name)) continue;
-    const abs = join4(dir, d.name);
+    const abs = join5(dir, d.name);
     if (d.isDirectory()) {
       await walkDir(root, abs, depth + 1, out);
     } else if (d.isFile()) {
@@ -1256,7 +1793,7 @@ function mountFilesRoute(app2) {
       if (!qRaw) {
         const slice = all.slice(0, limit);
         entries = slice.map((relPath) => ({
-          path: join4(workspacePath, relPath),
+          path: join5(workspacePath, relPath),
           relPath
         }));
         truncated = all.length > limit;
@@ -1273,7 +1810,7 @@ function mountFilesRoute(app2) {
         scored.sort((a, b) => b.score - a.score);
         const top = scored.slice(0, limit);
         entries = top.map((e) => ({
-          path: join4(workspacePath, e.relPath),
+          path: join5(workspacePath, e.relPath),
           relPath: e.relPath
         }));
         truncated = matchCount > limit;
@@ -1290,7 +1827,7 @@ function mountFilesRoute(app2) {
 
 // src/api/resources.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
 function toResourceSource(info) {
   return {
@@ -1300,16 +1837,16 @@ function toResourceSource(info) {
   };
 }
 async function scanExtensionDirs(workspaceCwd) {
-  const dirs = [join5(getAgentDir2(), "extensions"), join5(workspaceCwd, ".pi", "extensions")];
+  const dirs = [join6(getAgentDir2(), "extensions"), join6(workspaceCwd, ".pi", "extensions")];
   const found = [];
   for (const dir of dirs) {
     try {
       const entries = await readdir2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-          found.push(join5(dir, entry.name));
+          found.push(join6(dir, entry.name));
         } else if (entry.isDirectory()) {
-          found.push(join5(dir, entry.name));
+          found.push(join6(dir, entry.name));
         }
       }
     } catch {
@@ -1369,13 +1906,23 @@ async function snapshot(workspaceId, roots, workspaceCwd) {
     error: err.error
   }));
   const disabledExtensions = EXTENSIONS_ENABLED ? [] : await scanExtensionDirs(workspaceCwd);
+  const disabledBuiltins = new Set(getDisabledBuiltins());
+  const builtinExtensions = BUILTIN_EXTENSIONS.map((d) => ({
+    id: d.id,
+    name: d.name,
+    description: d.description,
+    enabled: !disabledBuiltins.has(d.id),
+    tools: d.tools,
+    commands: d.commands
+  }));
   return {
     skills: skillsOut,
     prompts: promptsOut,
     extensionsEnabled: EXTENSIONS_ENABLED,
     extensions: extensionsOut,
     extensionErrors,
-    disabledExtensions
+    disabledExtensions,
+    builtinExtensions
   };
 }
 async function rootsFor(workspaceId) {
@@ -1607,6 +2154,33 @@ function mountResourcesRoute(app2) {
       return respondError(c, err);
     }
   });
+  app2.put("/:id/resources/builtin-extensions", 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 body = await c.req.json().catch(() => null);
+    if (!body || typeof body.id !== "string" || typeof body.enabled !== "boolean") {
+      return c.json({ ok: false, error: "id and enabled are required" }, 400);
+    }
+    if (!BUILTIN_EXTENSIONS.some((d) => d.id === body.id)) {
+      return c.json({ ok: false, error: `unknown builtin extension: ${body.id}` }, 400);
+    }
+    try {
+      const runtime = await workspaceManager.getOrCreate(id);
+      if (runtime.session.isStreaming) {
+        return c.json(
+          { ok: false, error: "Stop the current turn before changing extensions" },
+          409
+        );
+      }
+      await setBuiltinEnabled(body.id, body.enabled);
+      await runtime.session.reload();
+      const { roots, workspaceCwd } = await rootsFor(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err) {
+      return respondError(c, err);
+    }
+  });
 }
 function isScope(value) {
   return value === "user" || value === "project";
@@ -1733,7 +2307,7 @@ mountFilesRoute(workspacesRoute);
 // src/api/fs.ts
 import { readdir as readdir3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "path";
 import { Hono as Hono2 } from "hono";
 var fsRoute = new Hono2();
 fsRoute.get("/browse", async (c) => {
@@ -1750,11 +2324,11 @@ fsRoute.get("/browse", async (c) => {
   }
   const entries = dirents.filter((d) => d.isDirectory()).filter((d) => showHidden || !d.name.startsWith(".")).map((d) => ({
     name: d.name,
-    path: join6(target, d.name),
+    path: join7(target, d.name),
     type: "dir"
   })).sort((a, b) => a.name.localeCompare(b.name));
   const parent = (() => {
-    const p = dirname3(target);
+    const p = dirname4(target);
     return p === target ? null : p;
   })();
   const body = { path: target, parent, entries };
@@ -1762,8 +2336,8 @@ fsRoute.get("/browse", async (c) => {
 });
 
 // src/api/model-configs.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname4, join as join7 } from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname5, join as join8 } from "path";
 import { Hono as Hono3 } from "hono";
 import {
   getAgentDir as getAgentDir3
@@ -1778,11 +2352,11 @@ function withWriteLock(fn) {
   return next;
 }
 function modelsPath() {
-  return join7(getAgentDir3(), "models.json");
+  return join8(getAgentDir3(), "models.json");
 }
 async function readModelsJson() {
   try {
-    const raw = await readFile3(modelsPath(), "utf-8");
+    const raw = await readFile4(modelsPath(), "utf-8");
     return JSON.parse(raw);
   } catch (err) {
     if (err?.code === "ENOENT") {
@@ -1793,8 +2367,8 @@ async function readModelsJson() {
 }
 async function writeModelsJson(config2) {
   const p = modelsPath();
-  await mkdir3(dirname4(p), { recursive: true });
-  await writeFile3(p, JSON.stringify(config2, null, 2), "utf-8");
+  await mkdir4(dirname5(p), { recursive: true });
+  await writeFile4(p, JSON.stringify(config2, null, 2), "utf-8");
 }
 var ValidationError = class extends Error {
   constructor(message, status) {
@@ -1996,138 +2570,6 @@ modelConfigsRoute.delete("/providers/:provider/models/:modelId", async (c) => {
 
 // src/ws/hub.ts
 import { WebSocketServer } from "ws";
-
-// src/ws/bridge.ts
-function translatePiEvent(ev) {
-  switch (ev.type) {
-    case "agent_start":
-      return { kind: "agent_start" };
-    case "agent_end":
-      return { kind: "agent_end", willRetry: ev.willRetry };
-    case "turn_start":
-      return { kind: "turn_start" };
-    case "turn_end":
-      return { kind: "turn_end" };
-    case "message_start": {
-      const role = roleOf(ev.message);
-      const text = role === "user" ? extractUserText2(ev.message) : void 0;
-      return { kind: "message_start", role, text };
-    }
-    case "message_end":
-      return { kind: "message_end", role: roleOf(ev.message) };
-    case "message_update": {
-      const ame = ev.assistantMessageEvent;
-      if (ame.type === "text_delta") {
-        return {
-          kind: "message_update",
-          delta: { kind: "text", contentIndex: ame.contentIndex, text: ame.delta }
-        };
-      }
-      if (ame.type === "thinking_delta") {
-        return {
-          kind: "message_update",
-          delta: { kind: "thinking", contentIndex: ame.contentIndex, text: ame.delta }
-        };
-      }
-      return { kind: "message_update", delta: { kind: "other" } };
-    }
-    case "tool_execution_start":
-      return {
-        kind: "tool_execution_start",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        args: ev.args
-      };
-    case "tool_execution_update":
-      return {
-        kind: "tool_execution_update",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        partialText: extractText(ev.partialResult)
-      };
-    case "tool_execution_end":
-      return {
-        kind: "tool_execution_end",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        isError: ev.isError,
-        text: extractText(ev.result)
-      };
-    case "queue_update":
-      return {
-        kind: "queue_update",
-        steering: [...ev.steering],
-        followUp: [...ev.followUp]
-      };
-    case "auto_retry_start":
-      return {
-        kind: "auto_retry_start",
-        attempt: ev.attempt,
-        maxAttempts: ev.maxAttempts,
-        delayMs: ev.delayMs,
-        errorMessage: ev.errorMessage
-      };
-    case "auto_retry_end":
-      return {
-        kind: "auto_retry_end",
-        success: ev.success,
-        attempt: ev.attempt,
-        finalError: ev.finalError
-      };
-    case "compaction_start":
-      return { kind: "compaction_start", reason: ev.reason };
-    case "compaction_end":
-      return {
-        kind: "compaction_end",
-        reason: ev.reason,
-        aborted: ev.aborted,
-        willRetry: ev.willRetry,
-        errorMessage: ev.errorMessage
-      };
-    case "session_info_changed":
-      return { kind: "session_info_changed", name: ev.name };
-    case "thinking_level_changed":
-      return { kind: "thinking_level_changed", level: ev.level };
-    default:
-      return void 0;
-  }
-}
-function roleOf(message) {
-  const role = message?.role;
-  if (role === "user" || role === "assistant" || role === "toolResult" || role === "bashExecution") {
-    return role;
-  }
-  return "assistant";
-}
-function extractUserText2(message) {
-  if (!message || typeof message !== "object") return void 0;
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return void 0;
-  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.length === 0 ? void 0 : parts.join("");
-}
-function extractText(result) {
-  if (!result || typeof result !== "object") return void 0;
-  const content = result.content;
-  if (!Array.isArray(content)) return void 0;
-  const parts = [];
-  for (const c of content) {
-    if (c && typeof c === "object" && c.type === "text") {
-      const text = c.text;
-      if (typeof text === "string") parts.push(text);
-    }
-  }
-  return parts.length === 0 ? void 0 : parts.join("");
-}
-
-// src/ws/hub.ts
 var replacementLocks = /* @__PURE__ */ new Map();
 function withReplacementLock(workspaceId, fn) {
   const prev = replacementLocks.get(workspaceId) ?? Promise.resolve();
@@ -2276,6 +2718,19 @@ async function handle(ws, state, msg) {
       });
       return;
     }
+    case "answer_question": {
+      const wsId = state.workspaceId;
+      if (!wsId) {
+        send(ws, { type: "error", message: "not subscribed", command: "answer_question" });
+        return;
+      }
+      if (replacementLocks.has(wsId)) return;
+      const runtime = workspaceManager.get(wsId);
+      if (!runtime) return;
+      const activeFile = runtime.session.sessionFile ?? null;
+      resolveAnswer(msg.toolCallId, msg.answer, activeFile);
+      return;
+    }
     default: {
       const _ = msg;
       void _;
@@ -2345,6 +2800,25 @@ function bindCurrentSession(ws, state, workspaceId) {
     sessionPath,
     sessionId: session.sessionId
   });
+  const inFlight = inFlightAssistantSnapshot(runtime.session.state.streamingMessage);
+  if (inFlight) {
+    for (const payload of inFlight) {
+      send(ws, {
+        type: "event",
+        workspaceId,
+        sessionPath,
+        payload
+      });
+    }
+  }
+  for (const payload of inFlightToolCallsSnapshot(sessionPath)) {
+    send(ws, {
+      type: "event",
+      workspaceId,
+      sessionPath,
+      payload
+    });
+  }
   sendContextUsage(ws, runtime, workspaceId, sessionPath);
 }
 function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
@@ -2379,10 +2853,11 @@ function send(ws, msg) {
 }
 
 // src/index.ts
+configureHttpProxy();
 var app = new Hono4();
-var distDir = dirname5(fileURLToPath(import.meta.url));
-var webRoot = resolve5(process.env.PI_PILOT_WEB_ROOT ?? join8(distDir, "..", "public"));
-var webIndexPath = join8(webRoot, "index.html");
+var distDir = dirname6(fileURLToPath(import.meta.url));
+var webRoot = resolve5(process.env.PI_PILOT_WEB_ROOT ?? join9(distDir, "..", "public"));
+var webIndexPath = join9(webRoot, "index.html");
 var mimeTypes = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -2416,7 +2891,7 @@ function safeResolveWebPath(pathname) {
 }
 async function readWebFile(path) {
   try {
-    return await readFile4(path);
+    return await readFile5(path);
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "EISDIR") return void 0;
@@ -2429,7 +2904,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 readFile4(webIndexPath);
+  const body = asset ?? await readFile5(webIndexPath);
   const filePath = asset ? assetPath : webIndexPath;
   const headers = {
     "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",
@@ -2459,6 +2934,7 @@ if (existsSync(webIndexPath)) {
     )
   );
 }
+await loadBuiltinPrefs();
 var server = serve(
   {
     fetch: app.fetch,