billion-context-pi 0.1.28 → 0.1.30

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;
@@ -2639,6 +2730,50 @@ function isPiHost(sm) {
   const source = sm;
   return typeof source.buildContextEntries === "function";
 }
+function mergeLiveEntries(entries, live) {
+  const persisted = entries.filter((e) => e.type === "message");
+  const out = [];
+  let p = 0;
+  let unmatched = 0;
+  for (let i = 0; i < live.length; i++) {
+    const msg = live[i];
+    let matched;
+    let j = p;
+    while (j < persisted.length && persisted[j].message.role !== msg.role) j++;
+    if (j < persisted.length && sameMessage(persisted[j].message, msg)) {
+      matched = persisted[j];
+      p = j + 1;
+    }
+    if (matched) {
+      out.push(matched);
+    } else {
+      unmatched++;
+      out.push({
+        type: "message",
+        id: `live-${i}`,
+        parentId: null,
+        timestamp: String(msg.timestamp ?? Date.now()),
+        message: msg
+      });
+    }
+  }
+  if (unmatched > 0) logInfo("runtime", { event: "merge-live-entries", live: live.length, unmatched });
+  return out;
+}
+function sameMessage(a, b) {
+  const ra = a.role;
+  const rb = b.role;
+  if (ra !== rb) return false;
+  const ca = a.content;
+  const cb = b.content;
+  if (ca === void 0 || cb === void 0) return false;
+  try {
+    return JSON.stringify(ca) === JSON.stringify(cb);
+  } catch (e) {
+    logWarn("runtime", { event: "message-compare-failed", error: e instanceof Error ? e.message : String(e) });
+    return a === b;
+  }
+}
 function createRuntime(adapter) {
   const core = createCore({ countTokens: defaultCountTokens });
   const store = new SessionStateStore();
@@ -2667,11 +2802,12 @@ function createRuntime(adapter) {
   function configFor(ctx) {
     return resolveConfig(adapterRef, liveContextLimit(ctx));
   }
-  async function stateFor(ctx) {
+  async function stateFor(ctx, liveMessages) {
     const sm = ctx.sessionManager;
     const state = await store.load(sm.getSessionFile() ?? void 0, sm.getSessionId());
     const entries = readContextEntries(sm);
-    return { state, coreMessages: entriesToCoreMessages(entries), entries };
+    const merged = isPiHost(sm) || !liveMessages || liveMessages.length === 0 ? entries : mergeLiveEntries(entries, liveMessages);
+    return { state, coreMessages: entriesToCoreMessages(merged), entries: merged };
   }
   async function save(state, ctx) {
     const sm = ctx.sessionManager;
@@ -7082,64 +7218,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();
@@ -7195,7 +7273,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 }] };
     }
   };
@@ -7240,6 +7324,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("; "));
@@ -7273,7 +7375,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 }] };
     }
   };
@@ -7322,16 +7430,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.",
@@ -7359,16 +7472,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}.`,
@@ -7396,7 +7514,7 @@ function buildMessageOwnerMap(state) {
   return m;
 }
 function estimateTokens2(text) {
-  if (!text) return 0;
+  if (typeof text !== "string" || !text) return 0;
   const cjk = text.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g);
   const cjkCount = cjk?.length ?? 0;
   return cjkCount + Math.ceil((text.length - cjkCount) / 4);
@@ -7458,7 +7576,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 }] };
     }
   };
@@ -7523,7 +7647,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 }] };
     }
   };
@@ -8103,6 +8233,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 {
@@ -8133,8 +8264,11 @@ async function runDelegate(pi, args, ctx, signal) {
   const requestedAsync = args.async !== false;
   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, useJsonStream, 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,
@@ -8143,10 +8277,10 @@ 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 stderrText = "";
-  const runId = `del_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
   const startedAt = Date.now();
   if (isAsync) {
     let settled = false;
@@ -8278,23 +8412,27 @@ async function runDelegate(pi, args, ctx, signal) {
           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();
         }
@@ -8315,6 +8453,7 @@ async function runDelegate(pi, args, ctx, signal) {
         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();
       }
@@ -8409,6 +8548,7 @@ 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";
@@ -8422,6 +8562,7 @@ function injectResult(pi, agent, runId, task, code, file, timedOut) {
     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;
   }
 }
@@ -8449,6 +8590,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 "";
   }
 }
@@ -8464,6 +8606,23 @@ function truncate2(s, n) {
   return s.slice(0, n - 1) + "\u2026";
 }
 
+// src/compat.ts
+function normalizeSystemPrompt(input) {
+  if (input === void 0) return "";
+  if (Array.isArray(input)) return input.join("\n");
+  return input;
+}
+function formatSystemPromptForEvent(base, append) {
+  const normalized = normalizeSystemPrompt(base);
+  return `${normalized}
+
+${append}`;
+}
+function getSystemPromptText(ctx) {
+  const result = ctx.getSystemPrompt?.();
+  return normalizeSystemPrompt(result);
+}
+
 // src/commands.ts
 function makeCommands(runtime) {
   return [
@@ -8551,7 +8710,7 @@ async function statusReport(runtime, ctx) {
   const bd = nudge?.contextBreakdown;
   const limit = config.modelContextLimit;
   const classified = bd ? bd.system + bd.tool + bd.summaries + bd.code + bd.text : 0;
-  const systemPromptText = ctx.getSystemPrompt?.() ?? "";
+  const systemPromptText = getSystemPromptText(ctx);
   const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
   const framework = bd ? Math.max(0, tokenCount - classified - systemPromptTokens) : 0;
   const displayTotal = tokenCount;
@@ -8559,7 +8718,7 @@ async function statusReport(runtime, ctx) {
   const activeBlocksList = state.blocks.filter((b) => b.active);
   const totalBlocksList = state.blocks;
   const lines = [];
-  const versionStr = "0.1.28" ? `billion-context-pi@${"0.1.28"}` : "";
+  const versionStr = "0.1.30" ? `billion-context-pi@${"0.1.30"}` : "";
   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");
@@ -8803,11 +8962,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 };
   });
@@ -8862,11 +9023,12 @@ async function readPackageJson(path4) {
 }
 function findNpmRoot(extDir) {
   let dir = dirname3(extDir);
-  while (dir !== "/" && dir !== ".") {
+  for (; ; ) {
     if (dir.endsWith("node_modules")) return dirname3(dir);
-    dir = dirname3(dir);
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
   }
-  return void 0;
 }
 async function findExtensionDir() {
   let dir = dirname3(fileURLToPath(import.meta.url));
@@ -8915,29 +9077,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.28";
+    const current = runtimeVersion ?? "0.1.30";
+    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;
   }
@@ -8951,7 +9120,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"];
@@ -9015,7 +9184,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 {
@@ -9067,15 +9236,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";
@@ -9085,13 +9258,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;
@@ -9145,11 +9322,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.30" : 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));
@@ -9164,6 +9344,7 @@ function wireSessionLifecycle(pi, runtime) {
   });
   pi.on("session_shutdown", () => {
     delegateStatusWidget.dispose();
+    closeLogStream();
   });
 }
 function wireContextTransform(pi, runtime) {
@@ -9171,7 +9352,7 @@ function wireContextTransform(pi, runtime) {
     const sid = ctx.sessionManager.getSessionId();
     const release = await runtime.acquireLock(sid);
     try {
-      const { state, coreMessages, entries } = await runtime.stateFor(ctx);
+      const { state, coreMessages, entries } = await runtime.stateFor(ctx, event.messages);
       const config = runtime.configFor(ctx);
       const coveredIds = collectCoveredMessageIds(state);
       const realUsage = ctx.getContextUsage?.();
@@ -9192,6 +9373,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,
@@ -9221,6 +9414,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}`);
@@ -9236,6 +9432,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();
     }
@@ -9246,15 +9445,13 @@ function wireSystemPrompt(pi, runtime) {
     const delegate = runtime.adapter.delegate !== false;
     const prompt = delegate ? `${ACP_SYSTEM_PROMPT}
 ${ACP_DELEGATE_PROMPT}` : ACP_SYSTEM_PROMPT;
-    return { systemPrompt: `${event.systemPrompt}
-
-${prompt}` };
+    return { systemPrompt: formatSystemPromptForEvent(event.systemPrompt, prompt) };
   });
 }
 function collectOriginals(entries) {
   const map = /* @__PURE__ */ new Map();
   for (const entry of entries) {
-    if (entry.type === "message") {
+    if (entry.type === "message" && entry.message) {
       map.set(entry.id, entry.message);
     } else if (entry.type === "custom_message") {
       const content = typeof entry.content === "string" ? [{ type: "text", text: entry.content }] : entry.content;