billion-context-pi 0.1.26 → 0.1.28

package/dist/index.js

@@ -2429,9 +2429,17 @@ ${argStr}` : argStr || textParts;
     }
     return [{ id, role: "assistant", contentType: "text", text: extractText(msg.content) }];
   }
-  const customText = extractText(msg.content);
+  const customText = extractText(msg.content) || fallbackText(msg);
   return customText.length > 0 ? [{ id, role: "user", contentType: "text", text: customText }] : [];
 }
+function fallbackText(msg) {
+  const parts = [];
+  if (msg.command) parts.push(`$ ${msg.command}`);
+  const out = extractText(msg.output);
+  if (out) parts.push(out);
+  if (msg.summary) parts.push(msg.summary);
+  return parts.join("\n").trim();
+}
 function stringifyArgs(args) {
   if (!args) return "";
   if (typeof args === "string") return args;
@@ -2621,6 +2629,16 @@ function mergeInitialState(parsed) {
 }
 
 // src/runtime.ts
+function readContextEntries(sm) {
+  const source = sm;
+  if (typeof source.buildContextEntries === "function") return source.buildContextEntries();
+  if (typeof source.getBranch === "function") return source.getBranch();
+  return [];
+}
+function isPiHost(sm) {
+  const source = sm;
+  return typeof source.buildContextEntries === "function";
+}
 function createRuntime(adapter) {
   const core = createCore({ countTokens: defaultCountTokens });
   const store = new SessionStateStore();
@@ -2652,7 +2670,7 @@ function createRuntime(adapter) {
   async function stateFor(ctx) {
     const sm = ctx.sessionManager;
     const state = await store.load(sm.getSessionFile() ?? void 0, sm.getSessionId());
-    const entries = sm.buildContextEntries();
+    const entries = readContextEntries(sm);
     return { state, coreMessages: entriesToCoreMessages(entries), entries };
   }
   async function save(state, ctx) {
@@ -7552,7 +7570,8 @@ ${extra.join("\n")}` : base;
 import {
   spawn
 } from "child_process";
-import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm } from "fs/promises";
+import { createWriteStream } from "fs";
+import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm, appendFile } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4 } from "path";
 
@@ -7644,9 +7663,203 @@ var delegateStatusWidget = {
   }
 };
 
+// src/delegate-watchdog.ts
+function attachWatchdogs(child, hooks, opts) {
+  let idleTimer;
+  let eofTimer;
+  let killGraceTimer;
+  let timeoutTimer;
+  const clearTimers = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (eofTimer) clearTimeout(eofTimer);
+    if (killGraceTimer) clearTimeout(killGraceTimer);
+    if (timeoutTimer) clearTimeout(timeoutTimer);
+  };
+  const killByWatchdog = (reason) => {
+    if (hooks.isSettled()) return;
+    hooks.onKill(reason);
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    killGraceTimer = setTimeout(() => {
+      if (hooks.isSettled()) return;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, opts.killGraceMs);
+    killGraceTimer.unref?.();
+  };
+  const poke = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => killByWatchdog(`no output for ${opts.idleMs / 6e4}m`), opts.idleMs);
+    idleTimer.unref?.();
+  };
+  poke();
+  timeoutTimer = setTimeout(() => killByWatchdog(`${opts.timeoutMs / 6e4}m limit`), opts.timeoutMs);
+  timeoutTimer.unref?.();
+  const onStdoutEnd = () => {
+    if (hooks.isSettled()) return;
+    eofTimer = setTimeout(() => {
+      if (hooks.isSettled()) return;
+      hooks.onEofGrace();
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }, opts.eofGraceMs);
+    eofTimer.unref?.();
+  };
+  child.stdout?.once("end", onStdoutEnd);
+  return {
+    poke,
+    dispose: () => {
+      clearTimers();
+      child.stdout?.removeListener("end", onStdoutEnd);
+    }
+  };
+}
+
+// src/delegate-events.ts
+var ThinkingCollector = class {
+  constructor(showThinking) {
+    this.showThinking = showThinking;
+  }
+  showThinking;
+  buf = "";
+  push(delta) {
+    this.buf += delta;
+  }
+  /** Return the segment line to write ("" when empty or disabled), resetting. */
+  flush() {
+    const text = this.buf.trim();
+    this.buf = "";
+    if (!this.showThinking || !text) return "";
+    return `[thinking] ${text}
+`;
+  }
+};
+function parseEventLine(line) {
+  let ev;
+  try {
+    ev = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof ev !== "object" || ev === null) return null;
+  const e = ev;
+  if (e.type === "message_update") {
+    const am = e.assistantMessageEvent;
+    if (typeof am !== "object" || am === null) return null;
+    const msg = am;
+    switch (msg.type) {
+      case "text_delta":
+        return { kind: "reply-delta", delta: String(msg.delta ?? "") };
+      case "text_end":
+        return { kind: "reply-complete", content: String(msg.content ?? "") };
+      case "thinking_delta":
+        return { kind: "thinking-delta", delta: String(msg.delta ?? "") };
+      case "thinking_end":
+        return { kind: "thinking-end" };
+      default:
+        return null;
+    }
+  }
+  if (e.type === "tool_execution_start") {
+    return {
+      kind: "tool-start",
+      toolName: String(e.toolName ?? ""),
+      argsText: formatArgs(e.args)
+    };
+  }
+  if (e.type === "tool_execution_update") {
+    return {
+      kind: "tool-update",
+      toolCallId: String(e.toolCallId ?? ""),
+      text: extractContentText(e.partialResult)
+    };
+  }
+  if (e.type === "tool_execution_end") {
+    return {
+      kind: "tool-end",
+      toolName: String(e.toolName ?? ""),
+      isError: Boolean(e.isError)
+    };
+  }
+  if (e.type === "auto_retry_start") {
+    return {
+      kind: "retry-start",
+      attempt: Number(e.attempt ?? 0),
+      maxAttempts: Number(e.maxAttempts ?? 0),
+      delayMs: Number(e.delayMs ?? 0),
+      errorMessage: String(e.errorMessage ?? "")
+    };
+  }
+  if (e.type === "auto_retry_end") {
+    return {
+      kind: "retry-end",
+      success: Boolean(e.success),
+      attempt: Number(e.attempt ?? 0)
+    };
+  }
+  return null;
+}
+function formatArgs(args) {
+  if (args && typeof args === "object") {
+    const a = args;
+    if (typeof a.command === "string") return a.command;
+  }
+  try {
+    return JSON.stringify(args);
+  } catch {
+    return String(args);
+  }
+}
+function extractContentText(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const content = payload.content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c && typeof c === "object" ? String(c.text ?? "") : "").join("");
+}
+function activityLines(ev, opts) {
+  switch (ev.kind) {
+    case "tool-start":
+      return [`[tool] ${ev.toolName}${ev.argsText ? ` ${ev.argsText}` : ""}
+`];
+    case "tool-update": {
+      if (!ev.text) return [];
+      return [ev.text.endsWith("\n") ? ev.text : `${ev.text}
+`];
+    }
+    case "tool-end":
+      return [`[done] ${ev.toolName}${ev.isError ? " (error)" : ""}
+`];
+    case "thinking-delta":
+      return opts.showThinking ? [`[thinking] ${ev.delta}
+`] : [];
+    case "retry-start":
+      return [`[retry] attempt ${ev.attempt}/${ev.maxAttempts}, backoff ${ev.delayMs}ms${ev.errorMessage ? ` \u2014 ${ev.errorMessage}` : ""}
+`];
+    case "retry-end":
+      return [`[retry] attempt ${ev.attempt} ${ev.success ? "succeeded" : "failed"}
+`];
+    default:
+      return [];
+  }
+}
+function newPortion(text, prev) {
+  if (text.startsWith(prev)) return text.slice(prev.length);
+  return text;
+}
+
 // src/delegate-tool.ts
 var MAX_DEPTH = 2;
 var SYNC_TIMEOUT_MS = 5 * 6e4;
+var EOF_GRACE_MS = 1e4;
+var IDLE_GRACE_MS = 5 * 6e4;
+var ASYNC_TIMEOUT_MS = 30 * 6e4;
+var KILL_GRACE_MS = 1e4;
 var RESULT_SUMMARY_CHARS = 500;
 var OUT_DIR = join4(tmpdir2(), "acp-delegate");
 var ACP_TOOLS = ["compress", "decompress", "search_context", "acp_status"];
@@ -7714,6 +7927,11 @@ var DelegateParams = typebox_exports.Object({
     typebox_exports.Boolean({
       description: "If true (default), return immediately with a runId. In long-lived sessions (interactive/rpc) a short notification is injected into chat when the delegate finishes; in one-shot sessions (print/json, e.g. `pi -p` / SDK) async auto-downgrades to sync and the result is returned here. If false, always block and return the output here."
     })
+  ),
+  showThinking: typebox_exports.Optional(
+    typebox_exports.Boolean({
+      description: "If true, the delegate's thinking deltas are also written to the live activity file (default: false \u2014 only tool activity is shown)."
+    })
   )
 });
 var CancelParams = typebox_exports.Object({
@@ -7771,7 +7989,8 @@ The delegate runs in its own clean pi process \u2014 it does NOT see this conver
   };
 }
 function formatRunResult(run) {
-  const header = run.status === "completed" ? `Delegate **${run.agent}** (runId \`${run.runId}\`) completed (exit ${run.exitCode ?? "?"})${remainingLineForWait(run.runId)}` : `Delegate **${run.agent}** (runId \`${run.runId}\`) ${run.status} (exit ${run.exitCode ?? "?"})${remainingLineForWait(run.runId)}`;
+  const timeoutNote = run.timedOut ? ` (timed out: ${run.timedOut})` : "";
+  const header = run.status === "completed" ? `Delegate **${run.agent}** (runId \`${run.runId}\`) completed (exit ${run.exitCode ?? "?"})${timeoutNote}${remainingLineForWait(run.runId)}` : `Delegate **${run.agent}** (runId \`${run.runId}\`) ${run.status} (exit ${run.exitCode ?? "?"})${timeoutNote}${remainingLineForWait(run.runId)}`;
   return formatPayload(header, run.result?.file ?? "", run.task, run.result?.body);
 }
 function remainingLineForWait(selfRunId) {
@@ -7910,13 +8129,12 @@ async function runDelegate(pi, args, ctx, signal) {
     ...process.env,
     PI_ACP_DELEGATE_DEPTH: String(parentDepth + 1)
   };
-  const { cliArgs, tmpDir } = await buildChildArgs(args, agent.prompt, ctx);
+  const { cliArgs, tmpDir, isAsync, useJsonStream } = await buildChildArgs(args, agent.prompt, ctx);
   const requestedAsync = args.async !== false;
-  const isAsync = requestedAsync && ctx.mode !== "print" && ctx.mode !== "json";
   if (requestedAsync && !isAsync) {
     debug.event("delegate-async-downgraded", { reason: `mode=${ctx.mode}` });
   }
-  debug.event("delegate-spawn", { agent: args.agent, cwd, async: isAsync, cliArgs });
+  debug.event("delegate-spawn", { agent: args.agent, cwd, async: isAsync, useJsonStream, cliArgs });
   const child = spawn(process.execPath, [process.argv[1], ...cliArgs], {
     cwd,
     env: childEnv,
@@ -7927,12 +8145,94 @@ async function runDelegate(pi, args, ctx, signal) {
     debug.event("delegate-stdin-error", { runId: "pre-spawn", error: String(e) });
   });
   child.stdin?.end(args.task);
-  let stdoutChunks = [];
   let stderrText = "";
   const runId = `del_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
   const startedAt = Date.now();
   if (isAsync) {
-    child.stdout?.on("data", (c) => stdoutChunks.push(c));
+    let settled = false;
+    const watchdog = attachWatchdogs(
+      child,
+      {
+        isSettled: () => settled || run.status !== "running",
+        onKill: (reason) => {
+          run.timedOut = reason;
+          debug.event("delegate-watchdog", { runId, reason });
+        },
+        onEofGrace: () => {
+          run.timedOut = "output ended but process did not exit";
+          debug.event("delegate-eof-grace", { runId, ms: EOF_GRACE_MS });
+        }
+      },
+      { eofGraceMs: EOF_GRACE_MS, idleMs: IDLE_GRACE_MS, timeoutMs: ASYNC_TIMEOUT_MS, killGraceMs: KILL_GRACE_MS }
+    );
+    const replyFile = join4(OUT_DIR, `${runId}.out`);
+    const activityFile = join4(OUT_DIR, `${runId}.activity`);
+    await mkdir2(OUT_DIR, { recursive: true });
+    const replyStream = createWriteStream(replyFile, { flags: "a" });
+    const activityStream = useJsonStream ? createWriteStream(activityFile, { flags: "a" }) : null;
+    const endStream = (s) => new Promise((resolve2) => {
+      if (!s || s.destroyed || s.closed) return resolve2();
+      s.end(() => resolve2());
+    });
+    let replyText = "";
+    let stdoutBuf = "";
+    const lastToolText = /* @__PURE__ */ new Map();
+    const thinking = new ThinkingCollector(args.showThinking === true);
+    const flushThinking = () => {
+      const line = thinking.flush();
+      if (line) activityStream?.write(line);
+    };
+    const handleEventLine = (line) => {
+      const ev = parseEventLine(line);
+      if (!ev) return;
+      if (ev.kind === "thinking-delta") {
+        thinking.push(ev.delta);
+        return;
+      }
+      if (ev.kind === "thinking-end") {
+        flushThinking();
+        return;
+      }
+      if (ev.kind === "reply-delta") {
+        flushThinking();
+        replyText += ev.delta;
+        replyStream.write(ev.delta);
+        return;
+      }
+      if (ev.kind === "reply-complete") {
+        flushThinking();
+        replyText = ev.content;
+        return;
+      }
+      if (ev.kind === "tool-update") {
+        flushThinking();
+        const prev = lastToolText.get(ev.toolCallId) ?? "";
+        const add = newPortion(ev.text, prev);
+        lastToolText.set(ev.toolCallId, ev.text);
+        if (add) activityStream?.write(add.endsWith("\n") ? add : `${add}
+`);
+        return;
+      }
+      flushThinking();
+      const lines = activityLines(ev, { showThinking: args.showThinking === true });
+      if (lines.length) activityStream?.write(lines.join(""));
+    };
+    child.stdout?.on("data", (c) => {
+      watchdog.poke();
+      if (useJsonStream) {
+        stdoutBuf += c.toString("utf8");
+        let nl;
+        while ((nl = stdoutBuf.indexOf("\n")) >= 0) {
+          const line = stdoutBuf.slice(0, nl);
+          stdoutBuf = stdoutBuf.slice(nl + 1);
+          handleEventLine(line);
+        }
+      } else {
+        const text = c.toString("utf8");
+        replyText += text;
+        replyStream.write(text);
+      }
+    });
     child.stderr?.on("data", (c) => {
       stderrText += c.toString("utf8");
     });
@@ -7947,47 +8247,69 @@ async function runDelegate(pi, args, ctx, signal) {
     };
     runs.set(runId, run);
     delegateStatusWidget.poke();
-    child.on("close", (code) => {
-      void cleanupTmp(tmpDir);
-      const output = Buffer.concat(stdoutChunks).toString("utf8").trim();
-      run.exitCode = code;
-      const body2 = code === 0 ? output || "(no output)" : stderrText.trim() || output || "(no output)";
-      if (run.status === "cancelled") {
-        run.finishedAt = Date.now();
-        debug.event("delegate-done", { runId, code, status: run.status, injected: false, outLen: output.length });
-        run.waiter?.();
-        delegateStatusWidget.poke();
-        return;
-      }
-      void persistResult(runId, body2).then((file2) => {
-        run.result = { code, file: file2, body: body2 };
-        run.status = code === 0 ? "completed" : "failed";
-        run.finishedAt = Date.now();
-        if (run.waiter) {
-          debug.event("delegate-done", { runId, code, status: run.status, injected: false, via: "wait", outLen: output.length, file: file2 });
-          run.waiter();
+    const finalize = (code) => {
+      void (async () => {
+        if (settled) return;
+        settled = true;
+        watchdog.dispose();
+        void cleanupTmp(tmpDir);
+        await Promise.all([endStream(replyStream), endStream(activityStream)]);
+        run.exitCode = code;
+        const output = replyText.trim();
+        const body2 = code === 0 ? output || "(no output)" : stderrText.trim() || output || "(no output)";
+        if (run.status === "cancelled") {
+          await Promise.all([rm(replyFile, { force: true }), rm(activityFile, { force: true })]);
+          run.finishedAt = Date.now();
+          debug.event("delegate-done", { runId, code, status: run.status, injected: false, outLen: output.length });
+          run.waiter?.();
           delegateStatusWidget.poke();
           return;
         }
-        if (run.consumed) {
-          debug.event("delegate-done", { runId, code, status: run.status, injected: false, via: "consumed", outLen: output.length, file: file2 });
+        try {
+          const file2 = replyFile;
+          if (output === "") {
+            const fallback = stderrText.trim();
+            await appendFile(file2, fallback ? `${fallback}
+` : "(no output)\n");
+          }
+          const effectiveCode = code ?? (output || stderrText ? 0 : null);
+          run.result = { code, file: file2, body: body2 };
+          run.status = effectiveCode === 0 ? "completed" : "failed";
+          run.finishedAt = Date.now();
+          if (run.waiter) {
+            debug.event("delegate-done", { runId, code, status: run.status, injected: false, via: "wait", outLen: output.length, file: file2 });
+            run.waiter();
+            delegateStatusWidget.poke();
+            return;
+          }
+          if (run.consumed) {
+            debug.event("delegate-done", { runId, code, status: run.status, injected: false, via: "consumed", outLen: output.length, file: file2 });
+            delegateStatusWidget.poke();
+            return;
+          }
+          const injected = injectResult(pi, args.agent, runId, args.task, code, file2, run.timedOut);
+          run.injected = injected;
+          debug.event("delegate-done", { runId, code, status: run.status, injected, outLen: output.length, file: file2 });
+          delegateStatusWidget.poke();
+        } catch (err) {
+          run.status = "failed";
+          run.finishedAt = Date.now();
+          debug.event("delegate-done-error", { runId, error: String(err) });
+          run.waiter?.();
           delegateStatusWidget.poke();
-          return;
         }
-        const injected = injectResult(pi, args.agent, runId, args.task, code, file2);
-        run.injected = injected;
-        debug.event("delegate-done", { runId, code, status: run.status, injected, outLen: output.length, file: file2 });
-        delegateStatusWidget.poke();
-      }).catch((err) => {
-        run.status = "failed";
-        run.finishedAt = Date.now();
-        debug.event("delegate-done-error", { runId, error: String(err) });
-        run.waiter?.();
-        delegateStatusWidget.poke();
-      });
-    });
+      })();
+    };
+    child.on("close", (code) => finalize(code));
     child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      watchdog.dispose();
       void cleanupTmp(tmpDir);
+      void replyStream.destroy();
+      void activityStream?.destroy();
+      void rm(replyFile, { force: true });
+      void rm(activityFile, { force: true });
       if (run.status === "running" || run.status === "cancelled") {
         run.status = run.status === "cancelled" ? "cancelled" : "failed";
         run.finishedAt = Date.now();
@@ -8002,6 +8324,8 @@ async function runDelegate(pi, args, ctx, signal) {
       `Delegated to **${args.agent}** (runId \`${runId}\`).`,
       `Task: ${truncate2(args.task, 160)}`,
       `Running in the background at \`${cwd}\`.`,
+      useJsonStream ? `Live activity is streaming to \`${activityFile}\` \u2014 read it anytime to watch the delegate work (tool calls and their output${args.showThinking ? ", plus thinking" : ""}).` : `The reply is streaming to \`${replyFile}\` \u2014 read it anytime to see partial output (this host has no json event mode, so tool activity is not visible).`,
+      `A watchdog force-finishes a hung run: no output for ${IDLE_GRACE_MS / 6e4}m, 10s after output ends, or a ${ASYNC_TIMEOUT_MS / 6e4}m hard limit \u2014 the result reflects whatever was produced.`,
       ``,
       `Call acp_delegate_wait({ runId: "${runId}" }) to block for the result (default 10s timeout). If the wait times out, or you skip it, a completion notification (with the result file path) is still injected here automatically when the delegate finishes \u2014 so you may also just continue other work now and let the result find you.`
     ].join("\n");
@@ -8020,7 +8344,9 @@ async function buildChildArgs(args, rolePrompt, ctx) {
 ---
 
 Complete the task below.`, "utf8");
-  const cliArgs = ["-p", "--no-session", "--append-system-prompt", promptFile];
+  const isAsync = args.async !== false && ctx.mode !== "print" && ctx.mode !== "json";
+  const useJsonStream = isAsync && isPiHost(ctx.sessionManager);
+  const cliArgs = useJsonStream ? ["--mode", "json", "--no-session", "--append-system-prompt", promptFile] : ["-p", "--no-session", "--append-system-prompt", promptFile];
   const agentDef = AGENTS[args.agent];
   if (agentDef?.restricted) {
     const merged = [.../* @__PURE__ */ new Set([...agentDef.tools.split(",").map((s) => s.trim()), ...ACP_TOOLS])];
@@ -8033,7 +8359,7 @@ Complete the task below.`, "utf8");
   } else if (ctx.model) {
     cliArgs.push("--provider", ctx.model.provider, "--model", ctx.model.id);
   }
-  return { cliArgs, tmpDir };
+  return { cliArgs, tmpDir, isAsync, useJsonStream };
 }
 function waitForChild(child, signal) {
   return new Promise((resolve2) => {
@@ -8079,7 +8405,7 @@ function formatSyncResult(agent, runId, task, r, file) {
   const body = r.timedOut ? "(timed out)" : r.stderr.trim() || "(no stderr)";
   return formatPayload(header, file, task, body);
 }
-function injectResult(pi, agent, runId, task, code, file) {
+function injectResult(pi, agent, runId, task, code, file, timedOut) {
   const send = pi.sendUserMessage;
   if (typeof send !== "function") {
     debug.event("delegate-inject-skipped", { runId, reason: "sendUserMessage unavailable" });
@@ -8088,7 +8414,8 @@ function injectResult(pi, agent, runId, task, code, file) {
   const status = code === 0 ? "completed" : "failed";
   const remaining = Array.from(runs.values()).filter((r) => r.status === "running").length;
   const remainingLine = remaining > 0 ? ` ${remaining} delegate${remaining === 1 ? " is" : "s are"} still running; keep doing other work and their notifications will arrive as they finish.` : " No delegates are currently running.";
-  const header = `[acp_delegate ${status}] **${agent}** (runId \`${runId}\`, exit ${code ?? "?"})${remainingLine} This is an automated system notification, NOT a user message. Read the result file if you need the details, then continue your original task; do not treat this as a new user request.`;
+  const timeoutNote = timedOut ? ` (timed out: ${timedOut})` : "";
+  const header = `[acp_delegate ${status}] **${agent}** (runId \`${runId}\`, exit ${code ?? "?"})${timeoutNote}${remainingLine} This is an automated system notification, NOT a user message. Read the result file if you need the details, then continue your original task; do not treat this as a new user request.`;
   const text = formatPayload(header, file, task);
   try {
     send.call(pi, text, { deliverAs: "followUp" });
@@ -8232,7 +8559,7 @@ async function statusReport(runtime, ctx) {
   const activeBlocksList = state.blocks.filter((b) => b.active);
   const totalBlocksList = state.blocks;
   const lines = [];
-  const versionStr = "0.1.26" ? `billion-context-pi@${"0.1.26"}` : "";
+  const versionStr = "0.1.28" ? `billion-context-pi@${"0.1.28"}` : "";
   lines.push("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E");
   lines.push("\u2502           ACP Context Analysis              \u2502");
   lines.push("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F");
@@ -8376,9 +8703,11 @@ When a background delegate finishes, an automated completion notification is inj
 
 // src/tool-guardrails.ts
 import {
-  isBashToolResult,
   isToolCallEventType
 } from "@earendil-works/pi-coding-agent";
+function isBashToolResult(e) {
+  return e.toolName === "bash";
+}
 function resolveBashTimeout(input, defaultTimeout) {
   if (input.timeout !== void 0) return void 0;
   const d = defaultTimeout ?? DEFAULT_TOOL_BASH_TIMEOUT;
@@ -8590,7 +8919,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.26";
+    const current = runtimeVersion ?? "0.1.28";
     debug.event("update-check", {
       current,
       latest,