billion-context-pi 0.1.43 → 0.1.45

package/dist/index.js

@@ -580,7 +580,7 @@ function truncateLargeToolOutputs(messages, tokenCount, config, countTokens, opt
   );
   return { messages: updated, truncatedCount, savedTokens };
 }
-var KEEP_LAST_ORPHANED = 0;
+var KEEP_LAST_ORPHANED = 2;
 function rangeKey(startRef, endRef) {
   return `${startRef}::${endRef}`;
 }
@@ -3604,7 +3604,7 @@ async function abortableSleep(ms, signal) {
     if (signal.aborted) return "aborted";
     const remaining = end - Date.now();
     if (remaining <= 0) return "ok";
-    await new Promise((resolve2) => setTimeout(resolve2, Math.min(250, remaining)));
+    await new Promise((resolve3) => setTimeout(resolve3, Math.min(250, remaining)));
   }
 }
 
@@ -3930,17 +3930,20 @@ function createRuntime(adapter) {
     for (const o of outcomes) {
       if (compressOutcomeSeen.has(o.toolCallId)) continue;
       compressOutcomeSeen.add(o.toolCallId);
-      if (o.isError) {
+      if (o.isError || o.noop === true) {
         compressFailCount += 1;
       } else if (o.success) {
         compressFailCount = 0;
       }
     }
     const latest = outcomes.length > 0 ? outcomes[outcomes.length - 1] : void 0;
-    const retryFor = latest && latest.isError && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS ? latest.toolCallId : null;
+    const retryFor = latest && (latest.isError || latest.noop === true) && compressFailCount >= 1 && compressFailCount < MAX_COMPRESS_ATTEMPTS ? latest.toolCallId : null;
     const cappedNow = compressFailCount >= MAX_COMPRESS_ATTEMPTS && prevCount < MAX_COMPRESS_ATTEMPTS;
     return { count: compressFailCount, retryFor, cappedNow };
   }
+  function compressRetryCappedFor(turnKey) {
+    return compressFailTurnKey === turnKey && compressFailCount >= MAX_COMPRESS_ATTEMPTS;
+  }
   function clearCompressRetryTracking() {
     compressOutcomeSeen.clear();
     compressFailTurnKey = null;
@@ -3949,10 +3952,10 @@ function createRuntime(adapter) {
   async function acquireLock(sid) {
     const prev = locks.get(sid) ?? Promise.resolve();
     let release;
-    const next = new Promise((resolve2) => {
+    const next = new Promise((resolve3) => {
       release = () => {
         locks.delete(sid);
-        resolve2();
+        resolve3();
       };
     });
     locks.set(sid, prev.then(() => next));
@@ -4033,7 +4036,7 @@ function createRuntime(adapter) {
     nudgeShownTurns.add(k);
   }, nudgeShownFor: (k) => nudgeShownTurns.has(k), clearNudgeTracking: () => {
     nudgeShownTurns.clear();
-  }, noteCompressOutcomes, clearCompressRetryTracking, liveContextLimit, configFor, reloadConfig, stateFor, save, acquireLock, overflowFor, overflowDrop, throttleFor, throttleDrop };
+  }, noteCompressOutcomes, compressRetryCappedFor, clearCompressRetryTracking, liveContextLimit, configFor, reloadConfig, stateFor, save, acquireLock, overflowFor, overflowDrop, throttleFor, throttleDrop };
 }
 
 // node_modules/typebox/build/system/memory/memory.mjs
@@ -8545,8 +8548,16 @@ function normalizeRanges(content) {
   }
   return ranges;
 }
+function compressPanelBlocks(text) {
+  if (!text.trimStart().startsWith("\u25A3 ACP |")) return -1;
+  const m = text.match(/, (\d+) blocks?\)/);
+  return m ? Number(m[1]) : -1;
+}
 function isCompressSuccessText(text) {
-  return text.trimStart().startsWith("\u25A3 ACP |");
+  return compressPanelBlocks(text) > 0;
+}
+function isCompressNoopText(text) {
+  return compressPanelBlocks(text) === 0;
 }
 function tier3OnlyRewrite(newBlocks, allBlocks) {
   if (newBlocks.length === 0) return null;
@@ -9874,7 +9885,7 @@ function makeDelegateWaitTool(_pi) {
       if (run.waiter) {
         return { details: void 0, content: [{ type: "text", text: `Delegate \`${args.runId}\` already has a wait in progress; do not wait on it twice.` }] };
       }
-      return new Promise((resolve2) => {
+      return new Promise((resolve3) => {
         let settled = false;
         let timer2;
         const finish = (result) => {
@@ -9883,7 +9894,7 @@ function makeDelegateWaitTool(_pi) {
           run.waiter = void 0;
           if (timer2) clearTimeout(timer2);
           signal?.removeEventListener("abort", onAbort);
-          resolve2(result);
+          resolve3(result);
         };
         const onAbort = () => {
           finish({ details: void 0, content: [{ type: "text", text: `Aborted; delegate \`${args.runId}\` is still running in the background. A notification will be injected when it finishes.` }] });
@@ -9996,9 +10007,9 @@ async function runDelegate(pi, args, ctx, signal) {
     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());
+    const endStream = (s) => new Promise((resolve3) => {
+      if (!s || s.destroyed || s.closed) return resolve3();
+      s.end(() => resolve3());
     });
     let stdoutBuf = "";
     const applier = makeEventApplier(
@@ -10167,7 +10178,7 @@ Complete the task below.`, "utf8");
   return { cliArgs, tmpDir, isAsync, useJsonStream };
 }
 function waitForChild(child, signal) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const stdoutChunks = [];
     let stderrText = "";
     child.stdout?.on("data", (c) => stdoutChunks.push(c));
@@ -10186,7 +10197,7 @@ function waitForChild(child, signal) {
     function finish(r) {
       clearTimeout(timer2);
       signal?.removeEventListener("abort", onAbort);
-      resolve2(r);
+      resolve3(r);
     }
     child.on("close", (code) => {
       finish({
@@ -10389,6 +10400,199 @@ async function handleStatus(args, runtime, ctx) {
 ${extra.join("\n")}` : base;
 }
 
+// src/setup-subagent-tools.ts
+import * as fs3 from "fs";
+import * as os from "os";
+import * as path4 from "path";
+import { CONFIG_DIR_NAME as CONFIG_DIR_NAME3 } from "@earendil-works/pi-coding-agent";
+var ACP_TOOLS2 = ["compress", "decompress", "search_context", "acp_status"];
+function resolveAgentDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) {
+    if (envDir === "~") return os.homedir();
+    if (envDir.startsWith("~/")) return path4.join(os.homedir(), envDir.slice(2));
+    return envDir;
+  }
+  return path4.join(os.homedir(), CONFIG_DIR_NAME3, "agent");
+}
+function parseFrontmatterTools(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const body = match[1];
+  if (!body) return null;
+  let name;
+  let tools;
+  for (const rawLine of body.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line.startsWith("name:")) {
+      name = line.slice(5).trim().replace(/^["']|["']$/g, "");
+    } else if (line.startsWith("tools:")) {
+      const value = line.slice(6).trim();
+      if (value) {
+        tools = value.split(",").map((t) => t.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+      }
+    }
+  }
+  if (!name) return null;
+  return tools ? { name, tools } : { name };
+}
+function findPiSubagentsInstall(agentDir, cwd) {
+  const candidates = [
+    path4.join(agentDir, "npm", "node_modules", "pi-subagents"),
+    path4.join(cwd, CONFIG_DIR_NAME3, "npm", "node_modules", "pi-subagents")
+  ];
+  const extensionRoots = [
+    path4.join(agentDir, "extensions"),
+    path4.join(cwd, CONFIG_DIR_NAME3, "extensions")
+  ];
+  for (const dir of candidates) {
+    if (fs3.existsSync(path4.join(dir, "package.json"))) return dir;
+  }
+  for (const root of extensionRoots) {
+    let entries;
+    try {
+      entries = fs3.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pkgPath = path4.join(root, entry.name, "package.json");
+      try {
+        if (JSON.parse(fs3.readFileSync(pkgPath, "utf-8")).name === "pi-subagents") {
+          return path4.join(root, entry.name);
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function discoverBuiltinAgents(installDir) {
+  const agentsDir = path4.join(installDir, "agents");
+  let entries;
+  try {
+    entries = fs3.readdirSync(agentsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const parsed = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    try {
+      const result = parseFrontmatterTools(fs3.readFileSync(path4.join(agentsDir, entry.name), "utf-8"));
+      if (result) parsed.push(result);
+    } catch {
+    }
+  }
+  return parsed;
+}
+function desiredTools(baseTools) {
+  const tools = baseTools ? [...baseTools] : [];
+  for (const tool of ACP_TOOLS2) {
+    if (!tools.includes(tool)) tools.push(tool);
+  }
+  return tools;
+}
+function ensureSubagentAcpTools(settingsPath, options) {
+  const agentDir = options?.agentDir ?? resolveAgentDir();
+  const cwd = options?.cwd ?? process.cwd();
+  const path_ = settingsPath ?? path4.join(agentDir, "settings.json");
+  let installDir;
+  if (options?.installDir) {
+    installDir = path4.resolve(options.installDir);
+    if (!fs3.existsSync(path4.join(installDir, "package.json"))) {
+      return { path: path_, action: "failed", reason: `not a package: ${installDir}` };
+    }
+  } else {
+    const detected = findPiSubagentsInstall(agentDir, cwd);
+    if (!detected) {
+      return { path: path_, action: "skipped", reason: "pi-subagents not installed" };
+    }
+    installDir = detected;
+  }
+  const builtins = discoverBuiltinAgents(installDir);
+  if (builtins.length === 0) {
+    return { path: path_, action: "skipped", reason: "pi-subagents ships no agents/*.md" };
+  }
+  let settingsRaw;
+  try {
+    settingsRaw = fs3.readFileSync(path_, "utf-8");
+  } catch {
+    return { path: path_, action: "skipped", reason: "not found" };
+  }
+  let settings2;
+  try {
+    settings2 = JSON.parse(settingsRaw);
+    if (typeof settings2 !== "object" || settings2 === null || Array.isArray(settings2)) {
+      return { path: path_, action: "failed", reason: "settings.json root is not an object" };
+    }
+  } catch {
+    return { path: path_, action: "failed", reason: "settings.json is not valid JSON" };
+  }
+  const subagents = typeof settings2.subagents === "object" && settings2.subagents !== null ? settings2.subagents : {};
+  const existingOverrides = typeof subagents.agentOverrides === "object" && subagents.agentOverrides !== null ? subagents.agentOverrides : {};
+  let changed = false;
+  const overrides = {};
+  for (const [name, existing] of Object.entries(existingOverrides)) overrides[name] = existing ?? {};
+  const frontmatterByName = new Map(builtins.map((b) => [b.name, b.tools]));
+  for (const name of builtins.map((b) => b.name)) {
+    const existing = overrides[name];
+    const baseTools = existing?.tools && Array.isArray(existing.tools) && existing.tools.length > 0 ? existing.tools : frontmatterByName.get(name);
+    if (baseTools === void 0) continue;
+    const wanted = desiredTools(baseTools);
+    const current = existing?.tools;
+    if (Array.isArray(current) && current.length > 0 && wanted.every((tool) => current.includes(tool))) {
+      continue;
+    }
+    overrides[name] = { ...existing, tools: wanted };
+    changed = true;
+  }
+  if (!changed) {
+    return { path: path_, action: "skipped", reason: "already have ACP tools" };
+  }
+  subagents.agentOverrides = overrides;
+  settings2.subagents = subagents;
+  const backupPath = `${path_}.acp-bak`;
+  try {
+    if (!fs3.existsSync(backupPath)) fs3.copyFileSync(path_, backupPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { path: path_, action: "failed", reason: `backup failed: ${message}` };
+  }
+  const expectedMtimeMs = fs3.statSync(path_).mtimeMs;
+  const tmpPath = `${path_}.tmp-${process.pid}`;
+  try {
+    fs3.writeFileSync(tmpPath, JSON.stringify(settings2, null, 2) + "\n", "utf-8");
+    if (fs3.statSync(path_).mtimeMs !== expectedMtimeMs) {
+      fs3.unlinkSync(tmpPath);
+      return { path: path_, action: "failed", reason: "settings.json changed during write" };
+    }
+    fs3.renameSync(tmpPath, path_);
+    const written = JSON.parse(fs3.readFileSync(path_, "utf-8"));
+    const writtenSub = written.subagents;
+    const writtenOverrides = writtenSub?.agentOverrides ?? {};
+    for (const b of builtins) {
+      const entry = writtenOverrides[b.name];
+      const tools = entry?.tools ?? [];
+      if (frontmatterByName.get(b.name) !== void 0 && !ACP_TOOLS2.every((t) => tools.includes(t))) {
+        fs3.copyFileSync(backupPath, path_);
+        return { path: path_, action: "failed", reason: "post-write verification failed" };
+      }
+    }
+    return { path: path_, action: "updated" };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (fs3.existsSync(backupPath)) {
+      try {
+        fs3.copyFileSync(backupPath, path_);
+      } catch {
+      }
+    }
+    return { path: path_, action: "failed", reason: message };
+  }
+}
+
 // src/commands.ts
 function makeCommands(runtime) {
   return [
@@ -10453,6 +10657,25 @@ ${text}`);
           ctx.ui.notify(lines.join("\n"));
         }
       }
+    },
+    {
+      name: "acp-subagents",
+      options: {
+        description: "Add ACP context tools (compress/decompress/search_context/acp_status) to pi-subagents' builtin agents. One-time setup \u2014 re-run after upgrading pi-subagents. Usage: /acp-subagents [installDir]",
+        handler: async (args, ctx) => {
+          const installDir = args.trim();
+          const result = ensureSubagentAcpTools(void 0, installDir ? { installDir } : void 0);
+          if (result.action === "updated") {
+            ctx.ui.notify(`ACP tools enabled for pi-subagents agents in ${result.path}`);
+          } else if (result.action === "skipped") {
+            ctx.ui.notify(
+              `Nothing to do: ${result.reason ?? ""}. Install pi-subagents (pi install npm:pi-subagents) or pass its directory: /acp-subagents <installDir>`
+            );
+          } else {
+            ctx.ui.notify(`Failed to update ${result.path}: ${result.reason ?? "unknown"}`);
+          }
+        }
+      }
     }
   ];
 }
@@ -10467,7 +10690,7 @@ async function statusReport(runtime, ctx) {
   const modelId = ctx.model?.id ?? "default";
   const sentTokens = estimateTokens(coreMessages, coveredIds) + systemPromptTokens;
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: calibrateTokens(sentTokens, runtime.density.densityFor(modelId)) });
-  const versionStr = "0.1.43" ? `billion-context-pi@${"0.1.43"}` : void 0;
+  const versionStr = "0.1.45" ? `billion-context-pi@${"0.1.45"}` : void 0;
   let text = buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -10685,18 +10908,48 @@ function wireToolGuardrails(pi, runtime) {
 }
 
 // src/update.ts
-import { readFile, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join7, dirname as dirname5 } from "path";
+import { readFile, writeFile as writeFile3, mkdir as mkdir3, access } from "fs/promises";
+import { join as join8, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
 import { execFile } from "child_process";
-import { homedir as homedir4 } from "os";
-import { CONFIG_DIR_NAME as CONFIG_DIR_NAME3 } from "@earendil-works/pi-coding-agent";
+import { homedir as homedir5 } from "os";
+import { CONFIG_DIR_NAME as CONFIG_DIR_NAME4 } from "@earendil-works/pi-coding-agent";
 var PACKAGE_NAME = "billion-context-pi";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/;
 var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
-var THROTTLE_FILE = join7(homedir4(), CONFIG_DIR_NAME3, "agent", ".billion-context-pi-update-check");
+var throttleFile = () => process.env.ACP_UPDATE_THROTTLE_FILE ?? join8(homedir5(), CONFIG_DIR_NAME4, "agent", ".billion-context-pi-update-check");
 var updateInFlight = false;
+var runNpm = async (args, opts) => {
+  return new Promise((resolve3) => {
+    execFile(
+      "npm",
+      args,
+      { ...opts, shell: process.platform === "win32", maxBuffer: 4 * 1024 * 1024 },
+      (err, stdout, stderr) => resolve3({
+        code: err ? 1 : 0,
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? "")
+      })
+    );
+  });
+};
+var runNpmImpl = runNpm;
+var runNode = (args, opts) => {
+  return new Promise((resolve3) => {
+    execFile(
+      process.execPath,
+      args,
+      { ...opts, maxBuffer: 4 * 1024 * 1024 },
+      (err, stdout, stderr) => resolve3({
+        code: err ? 1 : 0,
+        stdout: String(stdout ?? ""),
+        stderr: String(stderr ?? "")
+      })
+    );
+  });
+};
+var runNodeImpl = runNode;
 function parseVersion(v) {
   return v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
 }
@@ -10711,7 +10964,7 @@ function isNewer(latest, current) {
 }
 async function readLastCheck() {
   try {
-    const data = await readFile(THROTTLE_FILE, "utf-8");
+    const data = await readFile(throttleFile(), "utf-8");
     return parseInt(data.trim(), 10) || 0;
   } catch {
     return 0;
@@ -10719,14 +10972,14 @@ async function readLastCheck() {
 }
 async function writeLastCheck(timestamp) {
   try {
-    await mkdir3(dirname5(THROTTLE_FILE), { recursive: true });
-    await writeFile3(THROTTLE_FILE, String(timestamp), "utf-8");
+    await mkdir3(dirname5(throttleFile()), { recursive: true });
+    await writeFile3(throttleFile(), String(timestamp), "utf-8");
   } catch {
   }
 }
-async function readPackageJson(path4) {
+async function readPackageJson(path5) {
   try {
-    const data = JSON.parse(await readFile(path4, "utf-8"));
+    const data = JSON.parse(await readFile(path5, "utf-8"));
     return data && typeof data === "object" ? data : void 0;
   } catch {
     return void 0;
@@ -10744,31 +10997,118 @@ function findNpmRoot(extDir) {
 async function findExtensionDir() {
   let dir = dirname5(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const pkg = await readPackageJson(join7(dir, "package.json"));
+    const pkg = await readPackageJson(join8(dir, "package.json"));
     if (pkg?.name === PACKAGE_NAME) return dir;
     const parent = dirname5(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
-async function autoInstallLatest(latest) {
-  if (!SEMVER_RE.test(latest)) return false;
-  const extDir = await findExtensionDir();
-  if (!extDir) return false;
+function declaredEntries(pkg) {
+  const dot = pkg.exports?.["."];
+  const exportEntry = typeof dot === "string" ? dot : dot?.import;
+  return [.../* @__PURE__ */ new Set([pkg.pi?.extensions?.[0], exportEntry, pkg.main])].filter((v) => typeof v === "string" && v.length > 0);
+}
+async function verifyInstall(npmDir, latest) {
+  const dir = join8(npmDir, "node_modules", PACKAGE_NAME);
+  const pkg = await readPackageJson(join8(dir, "package.json"));
+  if (!pkg?.version) return { ok: false, reason: "package-json-missing" };
+  if (pkg.version !== latest) return { ok: false, reason: `version-mismatch:${pkg.version}` };
+  const entries = declaredEntries(pkg);
+  if (entries.length === 0) return { ok: false, reason: "no-entry-declared" };
+  for (const rel of entries) {
+    try {
+      await access(join8(dir, rel));
+    } catch {
+      return { ok: false, reason: `entry-missing:${rel}` };
+    }
+  }
+  const smokeEntry = pkg.pi?.extensions?.[0] ?? entries[0];
+  if (!smokeEntry) return { ok: false, reason: "no-entry-declared" };
+  const entry = join8(dir, smokeEntry);
+  const SMOKE = "const{pathToFileURL}=require('node:url');import(pathToFileURL(process.argv[1]).href).then(()=>{},(e)=>{console.error(e&&e.stack||e);process.exit(1)})";
+  const { code, stderr } = await runNodeImpl(["-e", SMOKE, entry], { timeout: 15e3 });
+  if (code !== 0) return { ok: false, reason: `entry-import-failed:${stderr.trim().slice(-500)}` };
+  return { ok: true };
+}
+async function autoInstallLatest(latest, extDirOverride) {
+  if (!SEMVER_RE.test(latest)) return "failed";
+  const extDir = extDirOverride ?? await findExtensionDir();
+  if (!extDir) {
+    logWarn("update", { event: "install-skip", reason: "extension-dir-not-found" });
+    return "failed";
+  }
   const npmDir = findNpmRoot(extDir);
-  if (!npmDir) return false;
+  if (!npmDir) {
+    logWarn("update", { event: "install-skip", reason: "not-under-node-modules", extDir });
+    return "failed";
+  }
   try {
-    const code = await new Promise((resolve2) => {
-      execFile(
-        "npm",
-        ["install", `${PACKAGE_NAME}@${latest}`, "--silent", "--no-audit", "--no-fund"],
-        { cwd: npmDir, timeout: 6e4, shell: process.platform === "win32" },
-        (err) => resolve2(err ? 1 : 0)
-      );
+    const installArgs = (v) => [
+      "install",
+      `${PACKAGE_NAME}@${v}`,
+      "--silent",
+      "--no-audit",
+      "--no-fund",
+      "--no-save"
+    ];
+    const prevVersion = (await readPackageJson(join8(extDir, "package.json")))?.version ?? "0.1.45";
+    const { code, stderr } = await runNpmImpl(installArgs(latest), { cwd: npmDir, timeout: 6e4 });
+    if (code !== 0) {
+      logWarn("update", {
+        event: "auto-install-failed",
+        latest,
+        npmDir,
+        stderr: stderr.trim().slice(-2e3)
+      });
+      return "failed";
+    }
+    const verify = await verifyInstall(npmDir, latest);
+    if (!verify.ok) {
+      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.45";
+      logWarn("update", { event: "auto-install-verify-failed", latest, reason: verify.reason, rollbackTo });
+      const rb = await runNpmImpl(installArgs(rollbackTo), { cwd: npmDir, timeout: 6e4 });
+      logInfo("update", { event: "rollback", from: latest, to: rollbackTo, ok: rb.code === 0 });
+      return "rolled-back";
+    }
+    return "ok";
+  } catch (e) {
+    logWarn("update", {
+      event: "auto-install-error",
+      latest,
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return "failed";
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const { code, stdout } = await runNpmImpl(["view", PACKAGE_NAME, "version"], {
+      timeout: 2e4
     });
-    return code === 0;
+    if (code === 0) {
+      const v = stdout.trim().split("\n").map((s) => s.trim()).filter(Boolean).pop();
+      if (v && SEMVER_RE.test(v)) return v;
+    }
   } catch {
-    return false;
+  }
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(1e4),
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok) {
+      logWarn("update", { event: "check-http", status: res.status });
+      return void 0;
+    }
+    const data = await res.json();
+    return data.version;
+  } catch (e) {
+    logWarn("update", {
+      event: "check-fetch-error",
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return void 0;
   }
 }
 async function checkForUpdate(autoUpdate, notify) {
@@ -10784,18 +11124,9 @@ async function checkForUpdate(autoUpdate, notify) {
     if (now - lastCheck < CHECK_INTERVAL_MS) return;
     await writeLastCheck(now);
     const runtimeVersion = await getRuntimeVersion();
-    const res = await fetch(REGISTRY_URL, {
-      signal: AbortSignal.timeout(5e3),
-      headers: { Accept: "application/json" }
-    });
-    if (!res.ok) {
-      logWarn("update", { event: "check-http", status: res.status });
-      return;
-    }
-    const data = await res.json();
-    const latest = data.version;
+    const latest = await fetchLatestVersion();
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.43";
+    const current = runtimeVersion ?? "0.1.45";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -10804,13 +11135,17 @@ async function checkForUpdate(autoUpdate, notify) {
     });
     logInfo("update", { event: "check", current, latest, hasUpdate });
     if (hasUpdate) {
-      const installed = await autoInstallLatest(latest);
-      if (installed && notify) {
+      const outcome = await autoInstallLatest(latest);
+      if (outcome === "ok" && 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) {
+      } else if (outcome === "rolled-back" && notify) {
+        notify(
+          `\x1B[33mACP ${latest} failed verification and was rolled back. Keeping ${current}. A later release will auto-update.\x1B[0m`
+        );
+      } else if (notify) {
         notify(
           `${PACKAGE_NAME} ${latest} available (you have ${current}). Run: pi update --extension npm:${PACKAGE_NAME}`
         );
@@ -10825,140 +11160,10 @@ async function checkForUpdate(autoUpdate, notify) {
 async function getRuntimeVersion() {
   const extDir = await findExtensionDir();
   if (!extDir) return void 0;
-  const pkg = await readPackageJson(join7(extDir, "package.json"));
+  const pkg = await readPackageJson(join8(extDir, "package.json"));
   return pkg?.version;
 }
 
-// src/setup-subagent-tools.ts
-import { readFile as readFile2, writeFile as writeFile4, stat, copyFile, rename } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
-import { CONFIG_DIR_NAME as CONFIG_DIR_NAME4 } from "@earendil-works/pi-coding-agent";
-var ACP_TOOLS2 = ["compress", "decompress", "search_context", "acp_status"];
-var BUILTIN_DEFAULT_TOOLS = {
-  advisor: ["read", "grep", "find", "ls", "bash", "intercom"],
-  "context-builder": ["read", "grep", "find", "ls", "bash", "write", "web_search", "intercom"],
-  delegate: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
-  oracle: ["read", "grep", "find", "ls", "bash", "intercom"],
-  planner: ["read", "grep", "find", "ls", "intercom"],
-  researcher: ["read", "write", "web_search", "fetch_content", "get_search_content", "intercom"],
-  reviewer: ["read", "grep", "find", "ls", "bash", "edit", "write", "intercom"],
-  scout: ["read", "grep", "find", "ls", "bash", "write", "intercom"],
-  worker: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"]
-};
-function resolveAgentDir() {
-  const configured = process.env.PI_CODING_AGENT_DIR;
-  if (configured === "~") return homedir5();
-  if (configured?.startsWith("~/")) return join8(homedir5(), configured.slice(2));
-  return configured || join8(homedir5(), CONFIG_DIR_NAME4, "agent");
-}
-function desiredTools(existing, name) {
-  const base = Array.isArray(existing?.tools) && existing.tools.length > 0 ? [...existing.tools] : [...BUILTIN_DEFAULT_TOOLS[name] ?? []];
-  const hasAll = ACP_TOOLS2.every((t) => base.includes(t));
-  if (hasAll) return { tools: base, changed: false };
-  for (const t of ACP_TOOLS2) if (!base.includes(t)) base.push(t);
-  return { tools: base, changed: true };
-}
-async function ensureSubagentAcpTools(settingsPath) {
-  const path4 = settingsPath ?? join8(resolveAgentDir(), "settings.json");
-  let raw;
-  let mtimeMs;
-  try {
-    raw = await readFile2(path4, "utf-8");
-    mtimeMs = (await stat(path4)).mtimeMs;
-  } catch {
-    return { path: path4, action: "skipped", reason: "settings.json not found; will retry next session" };
-  }
-  let settings2;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return { path: path4, action: "failed", reason: "settings.json root is not a JSON object" };
-    }
-    settings2 = parsed;
-  } catch (e) {
-    return { path: path4, action: "failed", reason: `settings.json is not valid JSON: ${e.message}` };
-  }
-  const subagents = typeof settings2.subagents === "object" && settings2.subagents !== null && !Array.isArray(settings2.subagents) ? { ...settings2.subagents } : {};
-  const overridesRaw = typeof subagents.agentOverrides === "object" && subagents.agentOverrides !== null && !Array.isArray(subagents.agentOverrides) ? { ...subagents.agentOverrides } : {};
-  const updatedOverrides = { ...overridesRaw };
-  let anyChanged = false;
-  for (const name of Object.keys(BUILTIN_DEFAULT_TOOLS)) {
-    const existing = overridesRaw[name] ?? void 0;
-    const { tools, changed } = desiredTools(existing, name);
-    if (changed) {
-      updatedOverrides[name] = { ...existing ?? {}, tools };
-      anyChanged = true;
-    }
-  }
-  if (!anyChanged) {
-    return { path: path4, action: "skipped", reason: "all builtin agents already have ACP tools" };
-  }
-  const backupPath = `${path4}.acp-bak`;
-  if (!existsSync4(backupPath)) {
-    try {
-      await copyFile(path4, backupPath);
-    } catch {
-    }
-  }
-  try {
-    if ((await stat(path4)).mtimeMs !== mtimeMs) {
-      return { path: path4, action: "skipped", reason: "settings.json changed during setup (concurrent write); will retry next session" };
-    }
-  } catch {
-    return { path: path4, action: "failed", reason: "settings.json disappeared during setup" };
-  }
-  const next = {
-    ...settings2,
-    subagents: { ...subagents, agentOverrides: updatedOverrides }
-  };
-  const tmpPath = `${path4}.tmp-${process.pid}`;
-  try {
-    await writeFile4(tmpPath, `${JSON.stringify(next, null, 2)}
-`, "utf-8");
-    await rename(tmpPath, path4);
-  } catch (e) {
-    return { path: path4, action: "failed", reason: `write failed: ${e.message}` };
-  }
-  try {
-    const verify = JSON.parse(await readFile2(path4, "utf-8"));
-    const sub = verify.subagents;
-    const v = sub?.agentOverrides;
-    if (typeof v !== "object" || v === null) throw new Error("agentOverrides missing after write");
-    for (const name of Object.keys(BUILTIN_DEFAULT_TOOLS)) {
-      const tools = v[name]?.tools;
-      if (!Array.isArray(tools) || !ACP_TOOLS2.every((t) => tools.includes(t))) {
-        throw new Error(`${name} missing ACP tools after write`);
-      }
-    }
-  } catch (e) {
-    try {
-      await copyFile(backupPath, path4);
-    } catch {
-    }
-    return { path: path4, action: "failed", reason: `verification failed; restored backup: ${e.message}` };
-  }
-  return { path: path4, action: "updated" };
-}
-async function runSetupAndNotify(notify) {
-  try {
-    const result = await ensureSubagentAcpTools();
-    debug.event("setup-subagent-tools", { action: result.action, reason: result.reason });
-    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/index.ts
 function createAcpExtension(adapter = {}) {
   return (pi) => {
@@ -10996,7 +11201,7 @@ function wireSessionLifecycle(pi, runtime) {
     const sid = ctx.sessionManager.getSessionId();
     runtime.clearSessionTracking(sid);
     const modelInfo = ctx.model;
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.43" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.45" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
     try {
       await runtime.reloadConfig(ctx.cwd);
       setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);
@@ -11014,10 +11219,10 @@ function wireSessionLifecycle(pi, runtime) {
       pi.registerTool(makeDelegateWaitTool(pi));
       pi.registerTool(makeDelegateCancelTool(pi));
     }
-    void checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+    const updateCheck = checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
       if (ctx.hasUI) ctx.ui.notify(msg);
     });
-    void runSetupAndNotify(ctx.hasUI ? (m) => ctx.ui.notify(m) : void 0);
+    if (!ctx.hasUI) await updateCheck;
     delegateStatusWidget.setContext(ctx, runningRunsSnapshot);
   });
   pi.on("session_shutdown", () => {
@@ -11119,10 +11324,13 @@ function wireContextTransform(pi, runtime) {
       const rebuilt = coreOutToAgentMessages(turn.messages, originalById);
       const debugOn2 = debug.enabled;
       const turnKey = lastUserMessageId(entries) ?? sid;
+      const compressOutcomes = collectCompressOutcomes(entries, turnStartIndex(entries));
+      const outcome = compressOutcomes.length > 0 ? runtime.noteCompressOutcomes(turnKey, compressOutcomes) : null;
       if (turn.nudge?.shouldInject) {
         const emergency = turn.nudge.breakdown?.emergencyOverride === 1;
         turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
-        const alreadyShown = !emergency && runtime.nudgeShownFor(turnKey);
+        const retryCapped = runtime.compressRetryCappedFor(turnKey);
+        const alreadyShown = retryCapped || !emergency && runtime.nudgeShownFor(turnKey);
         if (!alreadyShown) {
           rebuilt.push(nudgeMessage(turn.nudge, turn.state.blocks.filter((b) => b.active), runtime.prompts));
           const rendered = renderNudgeText(turn.nudge, runtime.prompts);
@@ -11143,9 +11351,7 @@ ${rendered.text}${example}`);
           debug.event("nudge-suppressed", { sid: ctx.sessionManager.getSessionId(), turnKey, reason: turn.nudge.reason });
         }
       }
-      const compressOutcomes = collectCompressOutcomes(entries, turnStartIndex(entries));
-      if (compressOutcomes.length > 0) {
-        const outcome = runtime.noteCompressOutcomes(turnKey, compressOutcomes);
+      if (outcome !== null) {
         const failed = outcome.retryFor !== null ? compressOutcomes.find((o) => o.toolCallId === outcome.retryFor) : void 0;
         if (failed) {
           rebuilt.push(compressRetryMessage(failed.text, outcome.count, MAX_COMPRESS_ATTEMPTS));
@@ -11160,9 +11366,10 @@ ${rendered.text}${example}`);
         }
       }
       debug.event("context-out", { outMsgs: rebuilt.length, injected: turn.nudge?.shouldInject ?? false, emergency: turn.nudge?.breakdown?.emergencyOverride === 1 });
-      void checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
+      const updateCheck = checkForUpdate(runtime.adapter.autoUpdate ?? true, (msg) => {
         if (ctx.hasUI) ctx.ui.notify(msg);
       });
+      if (!ctx.hasUI) await updateCheck;
       return { messages: rebuilt };
     } catch (e) {
       logThrow("context", e, { sid, phase: "transform" });
@@ -11288,7 +11495,7 @@ function collectCompressOutcomes(entries, startIndex) {
     const m = entry.message;
     if (m.role !== "toolResult" || m.toolName !== "compress" || !m.toolCallId) continue;
     const text = extractText(m.content);
-    out.push({ toolCallId: m.toolCallId, isError: m.isError === true, success: m.isError !== true && isCompressSuccessText(text), text });
+    out.push({ toolCallId: m.toolCallId, isError: m.isError === true, success: m.isError !== true && isCompressSuccessText(text), noop: m.isError !== true && isCompressNoopText(text), text });
   }
   return out;
 }
@@ -11304,7 +11511,8 @@ function compressRetryMessage(errorText, attempt, maxAttempts) {
     "- content must be an ARRAY of { startId, endId, summary } objects (topic optional) \u2014 not a JSON-encoded string.",
     '- Example: compress({ content: [{ startId: "m00005", endId: "m00080", summary: "..." }] })',
     '- startId/endId are the mNNNNN refs from the <acp> tags (or block ids like "b3").',
-    attempt >= maxAttempts - 1 ? "- This is your LAST retry for this turn \u2014 if it fails again, compression pauses until the next user message." : null
+    attempt >= maxAttempts - 1 ? "- This is your LAST retry for this turn \u2014 if it fails again, compression pauses until the next user message." : null,
+    "- If ranges were skipped (already compressed / too small), do NOT retry the same refs \u2014 run acp_status and use its CURRENT compressible ranges."
   ].filter((l) => l !== null).join("\n");
   return { role: "user", content: [{ type: "text", text }], timestamp: Date.now() };
 }