billion-context-pi 0.1.27 → 0.1.29

package/dist/index.js

@@ -2411,9 +2411,9 @@ function projectMessage(message, id) {
       if (calls.length === 1) {
         const call = calls[0];
         const argStr = stringifyArgs(call.arguments);
-        const text = argStr && textParts ? `${textParts}
+        const text2 = argStr && textParts ? `${textParts}
 ${argStr}` : argStr || textParts;
-        return [{ id, role: "assistant", contentType: "tool-call", toolName: call.name, toolCallId: call.id, text }];
+        return [{ id, role: "assistant", contentType: "tool-call", toolName: call.name, toolCallId: call.id, text: text2 }];
       }
       return calls.map((call) => {
         const argStr = stringifyArgs(call.arguments);
@@ -2427,7 +2427,9 @@ ${argStr}` : argStr || textParts;
         };
       });
     }
-    return [{ id, role: "assistant", contentType: "text", text: extractText(msg.content) }];
+    const text = extractText(msg.content);
+    if (!text.trim()) return [];
+    return [{ id, role: "assistant", contentType: "text", text }];
   }
   const customText = extractText(msg.content) || fallbackText(msg);
   return customText.length > 0 ? [{ id, role: "user", contentType: "text", text: customText }] : [];
@@ -2574,7 +2576,87 @@ function peelRefTagBlocks(blocks) {
 
 // src/state.ts
 import { promises as fs } from "fs";
+import * as path2 from "path";
+
+// src/log.ts
+import { appendFileSync, mkdirSync, statSync, renameSync, existsSync } from "fs";
 import * as path from "path";
+import { homedir } from "os";
+var MAX_BYTES = 10 * 1024 * 1024;
+var ENV_DEBUG = process.env.ACP_DEBUG === "1" || process.env.ACP_DEBUG === "true";
+function resolveLogFile() {
+  return process.env.ACP_LOG_FILE ?? path.join(homedir(), ".pi", "acp.log");
+}
+var runtimeDebug = null;
+function setDebugEnabled(enabled) {
+  runtimeDebug = enabled;
+}
+function debugOn() {
+  return runtimeDebug ?? ENV_DEBUG;
+}
+function fmt(v) {
+  if (typeof v === "string") return v;
+  if (v instanceof Error) return v.stack || String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function writeLine(level, scope, fields) {
+  const file = resolveLogFile();
+  try {
+    if (existsSync(file) && statSync(file).size >= MAX_BYTES) {
+      renameSync(file, file + ".old");
+    }
+  } catch {
+  }
+  const body = Object.keys(fields).map((k) => `${k}=${fmt(fields[k])}`).join(" ");
+  const line = `${ts()} [${level}] [${scope}] ${body}
+`;
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    appendFileSync(file, line);
+  } catch {
+  }
+}
+function closeLogStream() {
+}
+function logError(scope, fields) {
+  writeLine("error", scope, fields);
+}
+function logWarn(scope, fields) {
+  writeLine("warn", scope, fields);
+}
+function logInfo(scope, fields) {
+  writeLine("info", scope, fields);
+}
+function logThrow(scope, err, extra = {}) {
+  const fields = { ...extra };
+  if (err instanceof Error) {
+    fields.error = err.message;
+    fields.stack = err.stack ?? "";
+  } else {
+    fields.error = String(err);
+  }
+  writeLine("error", scope, fields);
+}
+var debug = {
+  get enabled() {
+    return debugOn();
+  },
+  get logFile() {
+    return resolveLogFile();
+  },
+  event(scope, fields) {
+    if (debugOn()) writeLine("debug", scope, fields);
+  }
+};
+
+// src/state.ts
 var STATE_SUFFIX = ".acp.json";
 function stateFileFor(sessionFile) {
   if (sessionFile) return sessionFile + STATE_SUFFIX;
@@ -2592,7 +2674,11 @@ var SessionStateStore = class {
         const raw = await fs.readFile(file, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed && Array.isArray(parsed.blocks)) state = mergeInitialState(parsed);
-      } catch {
+      } catch (e) {
+        const code = e.code;
+        if (code !== "ENOENT") {
+          logWarn("state", { event: "load-failed", file, error: e instanceof Error ? e.message : String(e) });
+        }
       }
     }
     this.cache = state;
@@ -2604,12 +2690,17 @@ var SessionStateStore = class {
     if (!file) return;
     this.cache = state;
     this.loadedKey = file;
-    const dir = path.dirname(file);
-    await fs.mkdir(dir, { recursive: true }).catch(() => {
+    const dir = path2.dirname(file);
+    await fs.mkdir(dir, { recursive: true }).catch((e) => {
+      logError("state", { event: "save-mkdir-failed", dir, error: e instanceof Error ? e.message : String(e) });
     });
-    const tmp = path.join(dir, `.acp-tmp-${path.basename(file)}`);
-    await fs.writeFile(tmp, JSON.stringify(state), "utf8");
-    await fs.rename(tmp, file);
+    const tmp = path2.join(dir, `.acp-tmp-${path2.basename(file)}`);
+    try {
+      await fs.writeFile(tmp, JSON.stringify(state), "utf8");
+      await fs.rename(tmp, file);
+    } catch (e) {
+      logError("state", { event: "save-failed", file, error: e instanceof Error ? e.message : String(e) });
+    }
   }
   invalidate() {
     this.cache = null;
@@ -2635,6 +2726,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();
@@ -7078,64 +7173,6 @@ __export(typebox_exports, {
   With: () => With2
 });
 
-// src/log.ts
-import { promises as fs2 } from "fs";
-import * as path2 from "path";
-import { homedir } from "os";
-var ENV_DEBUG = process.env.ACP_DEBUG === "1" || process.env.ACP_DEBUG === "true";
-var LOG_FILE = process.env.ACP_LOG_FILE ?? path2.join(homedir(), ".pi", "acp-debug.log");
-var runtimeDebug = null;
-var initialized = false;
-function setDebugEnabled(enabled) {
-  runtimeDebug = enabled;
-}
-function debugOn() {
-  return runtimeDebug ?? ENV_DEBUG;
-}
-async function write(line) {
-  if (!debugOn()) return;
-  if (!initialized) {
-    initialized = true;
-    await fs2.mkdir(path2.dirname(LOG_FILE), { recursive: true }).catch(() => {
-    });
-  }
-  await fs2.appendFile(LOG_FILE, line, "utf8").catch(() => {
-  });
-}
-var debug = {
-  get enabled() {
-    return debugOn();
-  },
-  get logFile() {
-    return LOG_FILE;
-  },
-  event(scope, fields) {
-    if (!debugOn()) return;
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    const body = Object.entries(fields).map(([k, v]) => `${k}=${fmt(v)}`).join(" ");
-    void write(`${ts} [${scope}] ${body}
-`);
-  }
-};
-function fmt(v) {
-  if (typeof v === "string") return v;
-  if (Array.isArray(v)) {
-    try {
-      return JSON.stringify(v);
-    } catch {
-      return `[${v.length}]`;
-    }
-  }
-  if (v && typeof v === "object") {
-    try {
-      return JSON.stringify(v);
-    } catch {
-      return String(v);
-    }
-  }
-  return String(v);
-}
-
 // src/tokens.ts
 function collectCoveredMessageIds(state) {
   const ids = /* @__PURE__ */ new Set();
@@ -7191,7 +7228,13 @@ function makeCompressTool(runtime) {
     ],
     parameters: CompressParams,
     async execute(toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await handleCompress(params, runtime, ctx, toolCallId);
+      let result;
+      try {
+        result = await handleCompress(params, runtime, ctx, toolCallId);
+      } catch (e) {
+        logThrow("compress", e, { sid: ctx.sessionManager.getSessionId(), ranges: params.content?.length ?? 0 });
+        throw e;
+      }
       return { details: void 0, content: [{ type: "text", text: result }] };
     }
   };
@@ -7236,6 +7279,24 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     activeAfter: applied.state.blocks.filter((b) => b.active).length,
     newBlocks: newBlocks.map((b) => ({ blockId: b.blockId, tier: b.tier, summaryLen: b.summary.length, directMsgCount: b.directMessageIds.length, effectiveMsgCount: b.effectiveMessageIds.length, summary: b.summary }))
   });
+  logInfo("compress", {
+    sid: ctx.sessionManager.getSessionId(),
+    event: "applied",
+    ranges: ranges.length,
+    blocksCreated,
+    tokensCompressed,
+    beforeTokens,
+    afterTokens,
+    warnings: warnings.length,
+    errors: errors.length,
+    newBlockIds: newBlocks.map((b) => b.blockId)
+  });
+  if (errors.length > 0) {
+    logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "errors", count: errors.length, errors: errors.slice(0, 5) });
+  }
+  if (warnings.length > 0) {
+    logError("compress", { sid: ctx.sessionManager.getSessionId(), event: "warnings", count: warnings.length, warnings: warnings.slice(0, 5) });
+  }
   const lines = [`\u25A3 ACP | ${formatK2(beforeTokens)} \u2192 ${formatK2(afterTokens)} tokens (~${formatK2(tokensCompressed)} reclaimed, ${blocksCreated} block${blocksCreated > 1 ? "s" : ""})`];
   if (warnings.length > 0) lines.push("\u26A0\uFE0F " + warnings.join("; "));
   if (errors.length > 0) lines.push("Errors: " + errors.join("; "));
@@ -7269,7 +7330,13 @@ function makeDecompressTool(runtime) {
     ],
     parameters: DecompressParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await handleDecompress(params, runtime, ctx);
+      let result;
+      try {
+        result = await handleDecompress(params, runtime, ctx);
+      } catch (e) {
+        logThrow("decompress", e, { sid: ctx.sessionManager.getSessionId(), blockId: params.blockId });
+        throw e;
+      }
       return { details: void 0, content: [{ type: "text", text: result }] };
     }
   };
@@ -7318,16 +7385,21 @@ async function handleMessageRef(ref, ownerBlockId, args, ctx) {
   const wantFile = args.toFile !== void 0 || args.inline === false || text.length >= MESSAGE_INLINE_THRESHOLD;
   if (!wantFile) {
     debug.event("decompress-message", { ref, ownerBlockId, mode: "inline", chars: text.length });
+    logInfo("decompress", { sid: ctx.sessionManager.getSessionId(), event: "message", mode: "inline", ref, ownerBlockId, chars: text.length });
     return `Message ${ref} (${role}, block ${ownerBlockId}, ${text.length} chars) restored inline:
 
 ${text}`;
   }
   const targetPath = args.toFile ? resolveToFilePath(args.toFile) : autoFilePath(`msg-${ref}`);
-  if (typeof targetPath === "object" && "error" in targetPath) return targetPath.error;
+  if (typeof targetPath === "object" && "error" in targetPath) {
+    logError("decompress", { sid: ctx.sessionManager.getSessionId(), event: "message-path-rejected", ref, toFile: args.toFile });
+    return targetPath.error;
+  }
   await mkdir(AUTO_DIR, { recursive: true }).catch(() => {
   });
   await writeFile(targetPath, text, "utf8");
   debug.event("decompress-message", { ref, ownerBlockId, mode: "file", path: targetPath, chars: text.length });
+  logInfo("decompress", { sid: ctx.sessionManager.getSessionId(), event: "message", mode: "file", ref, ownerBlockId, path: targetPath, chars: text.length });
   return [
     `Message ${ref} (${role}, block ${ownerBlockId}, ${text.length} chars) written to ${targetPath}.`,
     "Block stays compressed \u2014 context unchanged. Use the read tool to access the content.",
@@ -7355,16 +7427,21 @@ async function handleDecompress(args, runtime, ctx) {
   if (count === 0) return `Block ${blockId} has no restorable message content.`;
   if (args.inline === true && !args.toFile) {
     debug.event("decompress", { blockId, full, count, mode: "inline" });
+    logInfo("decompress", { sid: ctx.sessionManager.getSessionId(), event: "block", mode: "inline", blockId, full, count });
     return `Restored block ${blockId} (${count} item${count === 1 ? "" : "s"}) inline:
 
 ${text}`;
   }
   const targetPath = args.toFile ? resolveToFilePath(args.toFile) : autoFilePath(blockId);
-  if (typeof targetPath === "object" && "error" in targetPath) return targetPath.error;
+  if (typeof targetPath === "object" && "error" in targetPath) {
+    logError("decompress", { sid: ctx.sessionManager.getSessionId(), event: "block-path-rejected", blockId, toFile: args.toFile });
+    return targetPath.error;
+  }
   await mkdir(AUTO_DIR, { recursive: true }).catch(() => {
   });
   await writeFile(targetPath, text, "utf8");
   debug.event("decompress", { blockId, full, count, mode: "file", path: targetPath, chars: text.length });
+  logInfo("decompress", { sid: ctx.sessionManager.getSessionId(), event: "block", mode: "file", blockId, full, count, path: targetPath, chars: text.length });
   const itemWord = count === 1 ? "item" : "items";
   const lines = [
     `Block ${blockId} (${count} ${itemWord}, ${text.length} chars) written to ${targetPath}.`,
@@ -7454,7 +7531,13 @@ function makeSearchTool(runtime) {
     ],
     parameters: SearchParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await handleSearch(params, runtime, ctx);
+      let result;
+      try {
+        result = await handleSearch(params, runtime, ctx);
+      } catch (e) {
+        logThrow("search", e, { sid: ctx.sessionManager.getSessionId(), query: params.query });
+        throw e;
+      }
       return { details: void 0, content: [{ type: "text", text: result }] };
     }
   };
@@ -7519,7 +7602,13 @@ function makeStatusTool(runtime) {
     ],
     parameters: StatusParams,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await handleStatus(params, runtime, ctx);
+      let result;
+      try {
+        result = await handleStatus(params, runtime, ctx);
+      } catch (e) {
+        logThrow("status", e, { sid: ctx.sessionManager.getSessionId(), scope: params.scope ?? null });
+        throw e;
+      }
       return { details: void 0, content: [{ type: "text", text: result }] };
     }
   };
@@ -7566,7 +7655,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 +7748,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 +8012,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 +8074,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) {
@@ -7898,6 +8188,7 @@ function makeDelegateCancelTool(_pi) {
         run.child?.kill("SIGTERM");
       } catch (err) {
         debug.event("delegate-cancel-kill-error", { runId, error: String(err) });
+        logError("delegate", { event: "cancel-kill-error", runId, error: String(err) });
       }
       delegateStatusWidget.poke();
       return {
@@ -7924,13 +8215,15 @@ 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}` });
+    logInfo("delegate", { event: "async-downgraded", reason: `mode=${ctx.mode}` });
   }
-  debug.event("delegate-spawn", { agent: args.agent, cwd, async: isAsync, cliArgs });
+  const runId = `del_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  debug.event("delegate-spawn", { agent: args.agent, runId, cwd, async: isAsync, useJsonStream, cliArgs });
+  logInfo("delegate", { event: "spawn", agent: args.agent, runId, cwd, async: isAsync, useJsonStream, mode: ctx.mode, parentDepth });
   const child = spawn(process.execPath, [process.argv[1], ...cliArgs], {
     cwd,
     env: childEnv,
@@ -7939,14 +8232,96 @@ async function runDelegate(pi, args, ctx, signal) {
   });
   child.stdin?.once("error", (e) => {
     debug.event("delegate-stdin-error", { runId: "pre-spawn", error: String(e) });
+    logError("delegate", { event: "stdin-error", runId, 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,52 +8336,79 @@ 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 });
+            logInfo("delegate", { event: "done", runId, agent: args.agent, 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 });
+            logInfo("delegate", { event: "done", runId, agent: args.agent, 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 });
+          logInfo("delegate", { event: "done", runId, agent: args.agent, 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) });
+          logError("delegate", { event: "done-error", runId, agent: args.agent, 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();
         run.result = { code: null, file: "", body: `spawn error: ${String(err)}` };
         debug.event("delegate-spawn-error", { runId, error: String(err) });
+        logError("delegate", { event: "spawn-error", runId, agent: args.agent, error: String(err) });
         run.waiter?.();
         delegateStatusWidget.poke();
       }
@@ -8016,6 +8418,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 +8438,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 +8453,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,22 +8499,25 @@ 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" });
+    logWarn("delegate", { event: "inject-skipped", runId, reason: "sendUserMessage unavailable" });
     return false;
   }
   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" });
     return true;
   } catch (err) {
     debug.event("delegate-inject-error", { runId, error: String(err) });
+    logError("delegate", { event: "inject-error", runId, agent, error: String(err) });
     return false;
   }
 }
@@ -8136,6 +8545,7 @@ async function persistResult(runId, body) {
     return file;
   } catch (err) {
     debug.event("delegate-persist-error", { runId, file, error: String(err) });
+    logError("delegate", { event: "persist-error", runId, file, error: String(err) });
     return "";
   }
 }
@@ -8246,7 +8656,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.29" ? `billion-context-pi@${"0.1.29"}` : "";
   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");
@@ -8490,11 +8900,13 @@ function wireToolGuardrails(pi, runtime) {
       if (next) {
         modified = next;
         debug.event("guardrail-output-cap", { max, hadPath: !!fullPath });
+        logWarn("guardrail", { event: "output-cap", max, hadPath: !!fullPath });
       }
     }
     if (timeoutSecs !== void 0) {
       modified = appendTimeoutNotice(modified ?? event.content, timeoutSecs);
       debug.event("guardrail-bash-timeout-notice", { secs: timeoutSecs });
+      logInfo("guardrail", { event: "bash-timeout-notice", secs: timeoutSecs });
     }
     if (modified) return { content: modified };
   });
@@ -8602,29 +9014,36 @@ async function checkForUpdate(autoUpdate, notify) {
       signal: AbortSignal.timeout(5e3),
       headers: { Accept: "application/json" }
     });
-    if (!res.ok) return;
+    if (!res.ok) {
+      logWarn("update", { event: "check-http", status: res.status });
+      return;
+    }
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.27";
+    const current = runtimeVersion ?? "0.1.29";
+    const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
       latest,
-      hasUpdate: isNewer(latest, current)
+      hasUpdate
     });
-    if (isNewer(latest, current)) {
+    logInfo("update", { event: "check", current, latest, hasUpdate });
+    if (hasUpdate) {
       const installed = await autoInstallLatest(latest);
       if (installed && notify) {
         notify(
           `\x1B[32m\u2714 ACP auto-updated ${current} \u2192 ${latest}. Restart Pi to finish.\x1B[0m`
         );
+        logInfo("update", { event: "auto-installed", from: current, to: latest });
       } else if (!installed && notify) {
         notify(
           `${PACKAGE_NAME} ${latest} available (you have ${current}). Run: pi update --extension npm:${PACKAGE_NAME}`
         );
       }
     }
-  } catch {
+  } catch (e) {
+    logWarn("update", { event: "check-error", error: e instanceof Error ? e.message : String(e) });
   } finally {
     updateInFlight = false;
   }
@@ -8638,7 +9057,7 @@ async function getRuntimeVersion() {
 
 // src/setup-subagent-tools.ts
 import { readFile as readFile2, writeFile as writeFile4, stat, copyFile, rename } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 var ACP_TOOLS2 = ["compress", "decompress", "search_context", "acp_status"];
@@ -8702,7 +9121,7 @@ async function ensureSubagentAcpTools(settingsPath) {
     return { path: path4, action: "skipped", reason: "all builtin agents already have ACP tools" };
   }
   const backupPath = `${path4}.acp-bak`;
-  if (!existsSync(backupPath)) {
+  if (!existsSync2(backupPath)) {
     try {
       await copyFile(path4, backupPath);
     } catch {
@@ -8754,15 +9173,19 @@ async function runSetupAndNotify(notify) {
     if (result.action === "updated" && notify) {
       notify(`ACP: enabled context tools (compress/decompress/search_context/acp_status) for subagents`);
     }
+    if (result.action === "failed") {
+      logWarn("setup", { event: "subagent-tools", action: result.action, reason: result.reason });
+    }
     return result;
   } catch (e) {
     debug.event("setup-subagent-tools-error", { msg: String(e) });
+    logError("setup", { event: "subagent-tools-error", error: e instanceof Error ? e.message : String(e), stack: e instanceof Error ? e.stack ?? "" : "" });
     return { path: "", action: "failed", reason: String(e) };
   }
 }
 
 // src/user-config.ts
-import { promises as fs3 } from "fs";
+import { promises as fs2 } from "fs";
 import * as path3 from "path";
 import { homedir as homedir5 } from "os";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
@@ -8772,13 +9195,17 @@ async function loadUserConfig(cwd) {
   for (const base of [join8(home, CONFIG_DIR_NAME), join8(cwd, CONFIG_DIR_NAME)]) {
     const file = join8(base, "acp.json");
     try {
-      const raw = await fs3.readFile(file, "utf8");
+      const raw = await fs2.readFile(file, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
         Object.assign(merged, pickKnown(parsed));
         debug.event("config-loaded", { file });
       }
-    } catch {
+    } catch (e) {
+      const code = e.code;
+      if (code !== "ENOENT") {
+        logWarn("config", { event: "load-failed", file, error: e instanceof Error ? e.message : String(e) });
+      }
     }
   }
   return merged;
@@ -8832,11 +9259,14 @@ function wireSessionLifecycle(pi, runtime) {
   pi.on("session_start", async (_event, ctx) => {
     runtime.store.invalidate();
     runtime.clearNudgeTracking();
+    const sid = ctx.sessionManager.getSessionId();
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.29" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
       if (runtime.adapter.debug !== void 0) setDebugEnabled(runtime.adapter.debug);
-    } catch {
+    } catch (e) {
+      logThrow("config", e, { sid, phase: "session_start" });
     }
     if (runtime.adapter.delegate !== false) {
       pi.registerTool(makeDelegateTool(pi));
@@ -8851,6 +9281,7 @@ function wireSessionLifecycle(pi, runtime) {
   });
   pi.on("session_shutdown", () => {
     delegateStatusWidget.dispose();
+    closeLogStream();
   });
 }
 function wireContextTransform(pi, runtime) {
@@ -8879,6 +9310,18 @@ function wireContextTransform(pi, runtime) {
       });
       const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount });
       await runtime.save(turn.state, ctx);
+      logInfo("turn", {
+        sid,
+        inMsgs: coreMessages.length,
+        outMsgs: turn.messages.length,
+        tokens: tokenCount,
+        pct: realUsage?.percent ?? (config.modelContextLimit > 0 ? Math.round(tokenCount / config.modelContextLimit * 100) : null),
+        limit: config.modelContextLimit,
+        nudge: turn.nudge?.shouldInject ? turn.nudge.breakdown?.emergencyOverride === 1 ? "emergency" : "active" : "idle",
+        nudgeReason: turn.nudge?.reason ?? null,
+        blocks: turn.state.blocks.length,
+        activeBlocks: turn.state.blocks.filter((b) => b.active).length
+      });
       debug.event("processTurn", {
         outMsgs: turn.messages.length,
         summaryMsgs: turn.messages.filter((m) => m.id.startsWith("acp_summary")).length,
@@ -8908,6 +9351,9 @@ function wireContextTransform(pi, runtime) {
           const example = top ? `
 
 Example: compress({ content: [{ startId: "${top.startRef}", endId: "${top.endRef}", summary: "..." }] })` : "";
+          if (emergency) {
+            logWarn("nudge", { sid: ctx.sessionManager.getSessionId(), event: "emergency-inject", pct: Math.round(turn.nudge.contextUsage * 100), voice: rendered.voice, compressible: turn.nudge.compressibleRanges.length });
+          }
           if (debugOn2 && ctx.hasUI) {
             ctx.ui.notify(`[ACP nudge \u2192 context]${emergency ? " [EMERGENCY]" : ""}
 ${rendered.text}${example}`);
@@ -8923,6 +9369,9 @@ ${rendered.text}${example}`);
         if (ctx.hasUI) ctx.ui.notify(msg);
       });
       return { messages: rebuilt };
+    } catch (e) {
+      logThrow("context", e, { sid, phase: "transform" });
+      throw e;
     } finally {
       release();
     }