billion-context-pi 0.1.27 → 0.1.28

package/dist/delegate-events.d.ts

@@ -0,0 +1,69 @@
+export interface ToolStartEvent {
+    kind: "tool-start";
+    toolName: string;
+    argsText: string;
+}
+export interface ToolUpdateEvent {
+    kind: "tool-update";
+    toolCallId: string;
+    text: string;
+}
+export interface ToolEndEvent {
+    kind: "tool-end";
+    toolName: string;
+    isError: boolean;
+}
+export interface ReplyDeltaEvent {
+    kind: "reply-delta";
+    delta: string;
+}
+export interface ReplyCompleteEvent {
+    kind: "reply-complete";
+    content: string;
+}
+export interface ThinkingDeltaEvent {
+    kind: "thinking-delta";
+    delta: string;
+}
+export type ParsedEvent = ToolStartEvent | ToolUpdateEvent | ToolEndEvent | ReplyDeltaEvent | ReplyCompleteEvent | ThinkingDeltaEvent | ThinkingEndEvent | RetryStartEvent | RetryEndEvent;
+export interface ThinkingEndEvent {
+    kind: "thinking-end";
+}
+/**
+ * Accumulates thinking_delta tokens and emits one human-readable line per
+ * thinking segment (a segment ends at thinking_end / text_start). Nothing is
+ * emitted when showThinking is off.
+ */
+export declare class ThinkingCollector {
+    private readonly showThinking;
+    private buf;
+    constructor(showThinking: boolean);
+    push(delta: string): void;
+    /** Return the segment line to write ("" when empty or disabled), resetting. */
+    flush(): string;
+}
+export interface RetryStartEvent {
+    kind: "retry-start";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+}
+export interface RetryEndEvent {
+    kind: "retry-end";
+    success: boolean;
+    attempt: number;
+}
+export declare function parseEventLine(line: string): ParsedEvent | null;
+/** Join `content[].text` blocks from a tool result / partialResult payload. */
+export declare function extractContentText(payload: unknown): string;
+/** Format a parsed event as human-readable activity file lines (each with a
+ *  trailing newline; empty when none). */
+export declare function activityLines(ev: ParsedEvent, opts: {
+    showThinking: boolean;
+}): string[];
+/**
+ * partialResult is an accumulated snapshot (not a delta), so each update
+ * carries everything so far. Return only the newly-appended portion.
+ */
+export declare function newPortion(text: string, prev: string): string;

package/dist/delegate-tool.d.ts

@@ -13,6 +13,7 @@ declare const DelegateParams: Type.TObject<{
     cwd: Type.TOptional<Type.TString>;
     model: Type.TOptional<Type.TString>;
     async: Type.TOptional<Type.TBoolean>;
+    showThinking: Type.TOptional<Type.TBoolean>;
 }>;
 type DelegateArgs = Static<typeof DelegateParams>;
 declare const CancelParams: Type.TObject<{
@@ -40,5 +41,7 @@ export declare function makeDelegateCancelTool(_pi: ExtensionAPI): ToolDefinitio
 export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, ctx: ExtensionContext): Promise<{
     cliArgs: string[];
     tmpDir: string;
+    isAsync: boolean;
+    useJsonStream: boolean;
 }>;
 export {};

package/dist/delegate-watchdog.d.ts

@@ -0,0 +1,31 @@
+import type { Readable } from "node:stream";
+export interface WatchdogOptions {
+    eofGraceMs: number;
+    idleMs: number;
+    timeoutMs: number;
+    killGraceMs: number;
+}
+export interface WatchdogHooks {
+    /** True once the run is finalized; watchdogs stop firing. */
+    isSettled(): boolean;
+    /** The child is about to be killed (SIGTERM). reason explains why. */
+    onKill(reason: string): void;
+    /** stdout EOF passed without the process exiting; force-finalize now. */
+    onEofGrace(): void;
+}
+export interface WatchdogHandle {
+    /** Re-arm the idle timer (call on every stdout data). */
+    poke(): void;
+    /** Stop all timers (call on finalize). */
+    dispose(): void;
+}
+/**
+ * Guarantees a hung child process gets killed. A stuck child holds its stdout
+ * fd open, so stdout EOF never fires — hence the idle timer (no output for
+ * idleMs) is the main defense; the hard time limit and the EOF grace period
+ * cover the rest. Kill is SIGTERM, escalated to SIGKILL after killGraceMs.
+ */
+export declare function attachWatchdogs(child: {
+    kill(signal: NodeJS.Signals): boolean;
+    stdout: Readable | null;
+}, hooks: WatchdogHooks, opts: WatchdogOptions): WatchdogHandle;

package/dist/index.js

@@ -2635,6 +2635,10 @@ function readContextEntries(sm) {
   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();
@@ -7566,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";
 
@@ -7658,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"];
@@ -7728,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({
@@ -7785,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) {
@@ -7924,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,
@@ -7941,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");
     });
@@ -7961,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();
@@ -8016,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");
@@ -8034,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])];
@@ -8047,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) => {
@@ -8093,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" });
@@ -8102,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" });
@@ -8246,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.27" ? `billion-context-pi@${"0.1.27"}` : "";
+  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");
@@ -8606,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.27";
+    const current = runtimeVersion ?? "0.1.28";
     debug.event("update-check", {
       current,
       latest,