billion-context-pi 0.1.34 → 0.1.36

package/dist/index.js

@@ -263,7 +263,7 @@ function defaultConfig(modelContextLimit, overrides = {}) {
   const base = {
     tiers: { enabled: true, tier2Trigger: 5, tier3Trigger: 10 },
     nudge: {
-      maxContextLimitPct: 0.55,
+      maxContextLimitPct: 0.75,
       minContextLimitPct: 0.45,
       frequency: 5,
       iterationThreshold: 15,
@@ -273,10 +273,10 @@ function defaultConfig(modelContextLimit, overrides = {}) {
       growthCap: 5e4,
       minGrowthFloor: 2e4,
       minGrowthRatio: 0.45,
-      emergencyThresholdPct: 0.8
+      emergencyThresholdPct: 0.95
     },
     promotionThreshold: 5,
-    truncate: { threshold: 1 },
+    truncate: { threshold: 0.95 },
     compress: {
       minCompressRange: 5e3,
       maxSummaryLength: 2e4,
@@ -306,6 +306,11 @@ function validateConfig(config) {
       "nudge.minContextLimitPct must not exceed nudge.maxContextLimitPct"
     );
   }
+  if (config.nudge.maxContextLimitPct > config.nudge.emergencyThresholdPct) {
+    errors.push(
+      "nudge.maxContextLimitPct must not exceed nudge.emergencyThresholdPct"
+    );
+  }
   if (config.promotionThreshold < 1) {
     errors.push("promotionThreshold must be >= 1");
   }
@@ -1466,6 +1471,7 @@ function decideNudge(input) {
   const limit = config.modelContextLimit;
   const usage = limit > 0 ? tokenCount / limit : 0;
   const nudgeGrowthTokens = resolveAdaptiveGrowth(limit, config.nudge);
+  const overLimit = usage >= config.nudge.maxContextLimitPct;
   const emergencyOverride = usage >= config.nudge.emergencyThresholdPct;
   const baseline = state.nudge.lastPerMessageNudgeTokens;
   const hadPendingNudge = state.nudge.lastNudgeShownTokens > 0;
@@ -1482,7 +1488,7 @@ function decideNudge(input) {
   let injectedTier = null;
   let injectedReason = "";
   const growthReady = growthSinceReference >= growthFloor;
-  if (!emergencyOverride && growthReady) {
+  if (!overLimit && growthReady) {
     for (const tier of [1, 2, 3]) {
       if (!config.tiers.enabled && tier > 1) break;
       const info = tiers[tier];
@@ -1494,11 +1500,26 @@ function decideNudge(input) {
       injectedReason = tier === 1 ? `T1 compressible ${info.pending} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%` : `T${tier} distill ready: ${info.targetBlocks.length} tier-${tier - 1} blocks (${info.pending} tokens) >= ${nudgeGrowthTokens}, usage ${Math.round(usage * 100)}%`;
       break;
     }
+  } else if (overLimit) {
+    for (const tier of [1, 2, 3]) {
+      if (!config.tiers.enabled && tier > 1) break;
+      const info = tiers[tier];
+      if (!info || info.pending < config.compress.minCompressRange) continue;
+      injectedTier = tier;
+      injectedReason = emergencyOverride ? `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%, T${tier} pending ${info.pending}` : `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}%, T${tier} pending ${info.pending}`;
+      break;
+    }
   }
-  const shouldInject = emergencyOverride || injectedTier !== null;
+  const shouldInject = injectedTier !== null || overLimit && (rec?.recommendedRanges?.length ?? 0) > 0;
   let reason;
-  if (emergencyOverride) {
-    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%`;
+  if (emergencyOverride && injectedTier !== null) {
+    reason = injectedReason;
+  } else if (emergencyOverride) {
+    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}% (no compressible content)`;
+  } else if (overLimit && injectedTier !== null) {
+    reason = injectedReason;
+  } else if (overLimit) {
+    reason = `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}% (no compressible content)`;
   } else if (injectedTier !== null) {
     reason = injectedReason;
   } else {
@@ -1534,6 +1555,7 @@ function decideNudge(input) {
       nudgeGrowthTokens,
       growthFloor,
       hasPendingNudge: hasPendingNudge ? 1 : 0,
+      overLimit: overLimit ? 1 : 0,
       emergencyOverride: emergencyOverride ? 1 : 0,
       pendingT1: tiers[1].pending,
       pendingT2: tiers[2].pending,
@@ -1845,7 +1867,7 @@ function renderNudgeText(decision) {
       ].join("\n")
     };
   }
-  const isEmergency = !!decision.breakdown?.emergencyOverride;
+  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (isEmergency) {
     return {
       voice: "emergency",
@@ -2403,20 +2425,53 @@ function makePreview(text, query, len) {
 // src/config.ts
 var DEFAULT_TOOL_BASH_TIMEOUT = 60;
 var DEFAULT_TOOL_OUTPUT_MAX_BYTES = 2e5;
+function resolveDelegate(adapter) {
+  const d = adapter.delegate;
+  if (typeof d === "object" && d !== null) {
+    return {
+      enabled: d.enabled !== false,
+      displayUsage: d.displayUsage ?? adapter.displayUsage ?? "separate"
+    };
+  }
+  return {
+    enabled: d !== false,
+    displayUsage: adapter.displayUsage ?? "separate"
+  };
+}
 function resolveConfig(adapter, liveContextLimit) {
   const envLimit = process.env.ACP_MODEL_CONTEXT_LIMIT;
   const envLimitNum = envLimit ? Number(envLimit) : NaN;
   const FALLBACK_LIMIT = 15e4;
   const limit = !Number.isNaN(envLimitNum) && envLimitNum > 0 ? envLimitNum : adapter.modelContextLimit && adapter.modelContextLimit > 0 ? adapter.modelContextLimit : liveContextLimit > 0 ? liveContextLimit : FALLBACK_LIMIT;
-  return defaultConfig(limit, {
+  const config = defaultConfig(limit, {
     protectedTools: adapter.protectedTools ?? [],
     preserveRecentMessages: adapter.preserveRecentMessages ?? 5,
     ...adapter.coreOverrides
   });
+  const c = adapter.compress;
+  if (c?.maxContextLimit !== void 0) config.nudge.maxContextLimitPct = parsePercent(c.maxContextLimit);
+  if (c?.emergencyThresholdPercent !== void 0) {
+    const pct2 = parsePercent(c.emergencyThresholdPercent);
+    config.nudge.emergencyThresholdPct = pct2;
+    config.truncate.threshold = pct2;
+  }
+  if (c?.nudgeGrowthTokens !== void 0) {
+    config.nudge.growthFloor = c.nudgeGrowthTokens;
+    config.nudge.growthCap = c.nudgeGrowthTokens;
+  }
+  return config;
+}
+function parsePercent(v) {
+  if (typeof v === "number") return v;
+  const s = v.trim();
+  if (s.endsWith("%")) return Number(s.slice(0, -1)) / 100;
+  return Number(s);
 }
 
 // src/messages.ts
-var REF_TAG = new RegExp("^(?:<acp\\s[^>]*>m\\d{5}</acp>|\\[m\\d{1,5}\\])\\s?\\n?");
+var REF_TAG_SOURCE = "(?:<acp\\s[^>]*>m\\d{5}</acp>|\\[m\\d{1,5}\\])";
+var REF_TAG = new RegExp(`^${REF_TAG_SOURCE}\\s?\\n?`);
+var TRAILING_REF_TAG = new RegExp(`\\n*${REF_TAG_SOURCE}\\s*$`);
 function entriesToCoreMessages(entries) {
   const out = [];
   for (const entry of entries) {
@@ -2494,17 +2549,74 @@ function stringifyArgs(args) {
   return safeStringify(args);
 }
 function extractText(content) {
-  if (typeof content === "string") return content.replace(REF_TAG, "");
+  if (typeof content === "string") return stripRefTag(content);
   if (!Array.isArray(content)) return "";
   const parts = [];
   for (const block of content) {
     const b = block;
-    if (b.type === "text" && typeof b.text === "string") {
-      parts.push(b.text.replace(REF_TAG, ""));
-    }
+    if (b.type === "text" && typeof b.text === "string") parts.push(stripRefTag(b.text));
   }
   return parts.join("\n");
 }
+function stripRefTag(text) {
+  return text.replace(REF_TAG, "").replace(TRAILING_REF_TAG, "");
+}
+function messageIdentity(message) {
+  return JSON.stringify(normalizeIdentityValue(message, true));
+}
+function messageRef(message) {
+  if (message === null || typeof message !== "object" || !("content" in message)) return void 0;
+  const content = message.content;
+  const texts = typeof content === "string" ? [content] : Array.isArray(content) ? content.flatMap((block) => {
+    const value = block;
+    return value.type === "text" && typeof value.text === "string" ? [value.text] : [];
+  }) : [];
+  for (const text of texts) {
+    const tag = text.match(REF_TAG)?.[0] ?? text.match(TRAILING_REF_TAG)?.[0];
+    const ref = tag?.match(/m\d{1,5}/)?.[0];
+    if (ref) return ref;
+  }
+  return void 0;
+}
+function normalizeIdentityValue(value, message = false) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => {
+      if (!item || typeof item !== "object") return [normalizeIdentityValue(item)];
+      const block = item;
+      if (block.type === "text" && typeof block.text === "string") {
+        const stripped = stripRefTag(block.text);
+        if (block.text !== stripped && stripped === "") return [];
+      }
+      return [normalizeIdentityValue(item)];
+    });
+  }
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    if (message && key === "timestamp") continue;
+    const item = value[key];
+    if (message && key === "content" && typeof item === "string") {
+      out[key] = [{ text: stripRefTag(item), type: "text" }];
+    } else if (key === "text" && typeof item === "string" && value.type === "text") {
+      out[key] = stripRefTag(item);
+    } else {
+      out[key] = normalizeIdentityValue(item);
+    }
+  }
+  return out;
+}
+var TRUNCATION_MARKER2 = "[truncated for context space]";
+function matchesStoredText(stored, visible) {
+  const marker = `...${TRUNCATION_MARKER2} \u2014 original ~`;
+  const markerStart = visible.indexOf(marker);
+  if (markerStart < 2 || visible.slice(markerStart - 2, markerStart) !== "\n\n") return false;
+  const suffixMarker = " tokens]...\n\n";
+  const suffixStart = visible.indexOf(suffixMarker, markerStart + marker.length);
+  if (suffixStart < 0 || !/^\d+$/.test(visible.slice(markerStart + marker.length, suffixStart))) return false;
+  const prefix = visible.slice(0, markerStart - 2);
+  const suffix = visible.slice(suffixStart + suffixMarker.length);
+  return prefix.length > 0 && suffix.length > 0 && stored.startsWith(prefix) && stored.endsWith(suffix);
+}
 function allToolCalls(content) {
   if (!Array.isArray(content)) return [];
   const calls = [];
@@ -2598,11 +2710,11 @@ function patchRefTag(original, core) {
   let injected = false;
   for (let i = newBlocks.length - 1; i >= 0; i--) {
     const b = newBlocks[i];
-    if (b?.type === "text" && typeof b.text === "string") {
+    if (b?.type === "text" && typeof b.text === "string" && b.text.length > 0) {
       const baseText = b.text.replace(/\n*$/, "");
-      newBlocks[i] = { ...b, text: baseText.length > 0 ? `${baseText}
+      newBlocks[i] = { ...b, text: `${baseText}
 
-${tag}` : tag };
+${tag}` };
       injected = true;
       break;
     }
@@ -2637,8 +2749,8 @@ function peelRefTagBlocks(blocks) {
   for (const block of blocks) {
     const b = block;
     if (b?.type === "text" && typeof b.text === "string") {
-      const stripped = b.text.replace(REF_TAG, "");
-      if (stripped.length > 0) out.push({ ...b, text: stripped });
+      const stripped = stripRefTag(b.text);
+      if (stripped.length > 0 || b.text.length === 0) out.push({ ...b, text: stripped });
     } else {
       out.push(block);
     }
@@ -2735,51 +2847,127 @@ function stateFileFor(sessionFile) {
   if (sessionFile) return sessionFile + STATE_SUFFIX;
   return null;
 }
+async function readParentSessionPath(sessionFile) {
+  try {
+    const handle = await fs.open(sessionFile, "r");
+    try {
+      const buf = Buffer.alloc(65536);
+      const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+      if (bytesRead === 0) return void 0;
+      const firstLine = buf.subarray(0, bytesRead).toString("utf8").split("\n")[0] ?? "";
+      if (!firstLine.startsWith("{")) return void 0;
+      const header = JSON.parse(firstLine);
+      return typeof header.parentSession === "string" ? header.parentSession : void 0;
+    } finally {
+      await handle.close();
+    }
+  } catch (e) {
+    const code = e.code;
+    if (code !== "ENOENT") {
+      logWarn("state", { event: "read-parent-header-failed", file: sessionFile, error: e instanceof Error ? e.message : String(e) });
+    }
+    return void 0;
+  }
+}
+function cacheKey(sessionFile, sessionId) {
+  return sessionFile ? `file:${sessionFile}` : `session:${sessionId}`;
+}
 var SessionStateStore = class {
-  cache = null;
-  loadedKey = null;
-  async load(sessionFile, _sessionId) {
+  cache = /* @__PURE__ */ new Map();
+  async load(sessionFile, sessionId) {
     const file = stateFileFor(sessionFile);
-    if (file && this.loadedKey === file && this.cache) return this.cache;
+    const key = cacheKey(sessionFile, sessionId);
+    const cached = this.cache.get(key);
+    if (cached) return cached.state;
     let state = createInitialState();
+    let liveRefOrigins = [];
     if (file) {
       try {
         const raw = await fs.readFile(file, "utf8");
         const parsed = JSON.parse(raw);
-        if (parsed && Array.isArray(parsed.blocks)) state = mergeInitialState(parsed);
+        if (parsed && Array.isArray(parsed.blocks)) {
+          state = mergeInitialState(parsed);
+          liveRefOrigins = parseLiveRefOrigins(parsed.liveRefOrigins);
+        }
       } catch (e) {
         const code = e.code;
         if (code !== "ENOENT") {
           logWarn("state", { event: "load-failed", file, error: e instanceof Error ? e.message : String(e) });
         }
       }
+      if (state.blocks.length === 0 && sessionFile) {
+        const parentState = await this.tryLoadParentState(sessionFile);
+        if (parentState) state = parentState;
+      }
     }
-    this.cache = state;
-    this.loadedKey = file;
+    this.cache.set(key, { state, liveRefOrigins });
     return state;
   }
-  async save(state, sessionFile, _sessionId) {
+  async save(state, sessionFile, sessionId) {
     const file = stateFileFor(sessionFile);
     if (!file) return;
-    this.cache = state;
-    this.loadedKey = file;
+    const key = cacheKey(sessionFile, sessionId);
+    const liveRefOrigins = this.cache.get(key)?.liveRefOrigins ?? [];
+    this.cache.set(key, { state, liveRefOrigins });
     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 = path2.join(dir, `.acp-tmp-${path2.basename(file)}`);
     try {
-      await fs.writeFile(tmp, JSON.stringify(state), "utf8");
+      await fs.writeFile(tmp, JSON.stringify({ ...state, liveRefOrigins }), "utf8");
       await fs.rename(tmp, file);
     } catch (e) {
       logError("state", { event: "save-failed", file, error: e instanceof Error ? e.message : String(e) });
     }
   }
+  getLiveRefOrigins(sessionFile, sessionId) {
+    return [...this.cache.get(cacheKey(sessionFile, sessionId))?.liveRefOrigins ?? []];
+  }
+  setLiveRefOrigins(sessionFile, sessionId, origins) {
+    const key = cacheKey(sessionFile, sessionId);
+    const slot = this.cache.get(key);
+    if (slot) this.cache.set(key, { state: slot.state, liveRefOrigins: [...origins] });
+  }
   invalidate() {
-    this.cache = null;
-    this.loadedKey = null;
+    this.cache.clear();
+  }
+  async tryLoadParentState(sessionFile) {
+    const MAX_CHAIN_DEPTH = 8;
+    let current = sessionFile;
+    for (let depth = 0; depth < MAX_CHAIN_DEPTH; depth++) {
+      const parentJsonl = await readParentSessionPath(current);
+      if (!parentJsonl) return void 0;
+      const parentAcp = stateFileFor(parentJsonl);
+      if (!parentAcp) return void 0;
+      try {
+        const raw = await fs.readFile(parentAcp, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && Array.isArray(parsed.blocks) && parsed.blocks.length > 0) {
+          logInfo("state", { event: "inherited-parent-state", file: parentAcp, depth, blocks: parsed.blocks.length, tokensCompressed: parsed.stats?.tokensCompressed ?? 0 });
+          return mergeInitialState(parsed);
+        }
+      } catch (e) {
+        const code = e.code;
+        if (code !== "ENOENT") {
+          logWarn("state", { event: "parent-state-load-failed", file: parentAcp, error: e instanceof Error ? e.message : String(e) });
+          return void 0;
+        }
+      }
+      current = parentJsonl;
+    }
+    logWarn("state", { event: "parent-chain-exhausted", file: sessionFile, maxDepth: MAX_CHAIN_DEPTH });
+    return void 0;
   }
 };
+function parseLiveRefOrigins(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => {
+    if (!item || typeof item !== "object") return false;
+    const origin = item;
+    return typeof origin.rawId === "string" && typeof origin.identity === "string";
+  });
+}
 function mergeInitialState(parsed) {
   const fresh = createInitialState();
   return {
@@ -2803,50 +2991,116 @@ function isPiHost(sm) {
   const source = sm;
   return typeof source.buildContextEntries === "function";
 }
-function mergeLiveEntries(entries, live) {
+function mergeLiveEntries(entries, live, state, origins) {
   const persisted = entries.filter((e) => e.type === "message");
+  const matched = matchPersistedSuffix(persisted, live);
+  const prior = matchOrigins(origins, live);
   const out = [];
-  let p = 0;
-  let unmatched = 0;
+  const nextOrigins = [];
+  const usedIds = /* @__PURE__ */ new Set();
   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
-      });
+    const entry = matched[i];
+    const origin = prior[i];
+    if (entry) {
+      if (origin) migrateLiveRefs(state, origin.rawId, entry.id);
+      else migrateTaggedRef(state, msg, entry.id);
+      out.push(entry);
+      continue;
     }
+    const id = origin?.rawId ?? nextLiveId(state, usedIds, i);
+    usedIds.add(id);
+    out.push({ type: "message", id, parentId: null, timestamp: String(msg.timestamp ?? Date.now()), message: msg });
+    nextOrigins.push({ rawId: id, identity: messageIdentity(msg) });
   }
+  origins.splice(0, origins.length, ...nextOrigins);
+  const unmatched = live.length - matched.length;
   if (unmatched > 0) logInfo("runtime", { event: "merge-live-entries", live: live.length, unmatched });
   return out;
 }
+function matchOrigins(origins, live) {
+  for (let start = 0; start < origins.length; start++) {
+    const count = origins.length - start;
+    if (count > live.length) continue;
+    if (origins.slice(start).every((origin, index) => origin.identity === messageIdentity(live[index]))) {
+      return [...origins.slice(start), ...Array(live.length - count)];
+    }
+  }
+  return Array(live.length);
+}
+function nextLiveId(state, used, index) {
+  let id = `live-${index}`;
+  let suffix = index;
+  while (used.has(id) || state.messageRefs.byRaw[id] !== void 0) id = `live-${++suffix}`;
+  return id;
+}
+function migrateTaggedRef(state, message, stableId) {
+  const ref = messageRef(message);
+  const rawId = ref ? state.messageRefs.byRef[ref] : void 0;
+  if (rawId?.startsWith("live-")) migrateLiveRefs(state, rawId, stableId);
+}
+function migrateLiveRefs(state, liveId, stableId) {
+  const rootId = liveId.split("#", 1)[0];
+  if (!rootId.startsWith("live-")) return;
+  for (const [rawId, ref] of Object.entries(state.messageRefs.byRaw)) {
+    if (rawId !== rootId && !rawId.startsWith(`${rootId}#`)) continue;
+    const stableRawId = `${stableId}${rawId.slice(rootId.length)}`;
+    if (state.messageRefs.byRaw[stableRawId] === void 0) {
+      state.messageRefs.byRaw[stableRawId] = ref;
+      state.messageRefs.byRef[ref] = stableRawId;
+    } else if (state.messageRefs.byRef[ref] === rawId) {
+      delete state.messageRefs.byRef[ref];
+    }
+    delete state.messageRefs.byRaw[rawId];
+  }
+}
+function matchPersistedSuffix(persisted, live) {
+  for (let start = 0; start < persisted.length; start++) {
+    const count = persisted.length - start;
+    if (count > live.length) continue;
+    const suffix = persisted.slice(start);
+    if (suffix.every((entry, index) => sameMessage(entry.message, live[index]))) return suffix;
+  }
+  return [];
+}
 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);
+    if (messageIdentity(a) === messageIdentity(b)) return true;
+    const ra = a.role;
+    const rb = b.role;
+    if (ra !== rb || ra !== "toolResult") return false;
+    const ca = a.content;
+    const cb = b.content;
+    return sameNonTextBlocks(ca, cb) && matchesStoredText(extractText(ca), extractText(cb));
   } catch (e) {
     logWarn("runtime", { event: "message-compare-failed", error: e instanceof Error ? e.message : String(e) });
     return a === b;
   }
 }
+function sameNonTextBlocks(a, b) {
+  const nonText = (blocks) => blocks.filter((block) => block.type !== "text");
+  try {
+    const na = Array.isArray(a) ? nonText(a) : [];
+    const nb = Array.isArray(b) ? nonText(b) : [];
+    return JSON.stringify(na) === JSON.stringify(nb);
+  } catch {
+    return false;
+  }
+}
+function pruneOrphanRefs(state, messages) {
+  const retainedRawIds = new Set(messages.map((message) => message.id));
+  for (const block of state.blocks) {
+    for (const rawId of [...block.directMessageIds, ...block.effectiveMessageIds]) retainedRawIds.add(rawId);
+  }
+  for (const [rawId, ref] of Object.entries(state.messageRefs.byRaw)) {
+    if (retainedRawIds.has(rawId)) continue;
+    delete state.messageRefs.byRaw[rawId];
+    if (state.messageRefs.byRef[ref] === rawId) delete state.messageRefs.byRef[ref];
+  }
+  for (const [ref, rawId] of Object.entries(state.messageRefs.byRef)) {
+    if (!retainedRawIds.has(rawId)) delete state.messageRefs.byRef[ref];
+  }
+}
 function createRuntime(adapter) {
   const core = createCore({ countTokens: defaultCountTokens });
   const store = new SessionStateStore();
@@ -2877,10 +3131,20 @@ function createRuntime(adapter) {
   }
   async function stateFor(ctx, liveMessages) {
     const sm = ctx.sessionManager;
-    const state = await store.load(sm.getSessionFile() ?? void 0, sm.getSessionId());
+    const sessionFile = sm.getSessionFile() ?? void 0;
+    const sessionId = sm.getSessionId();
+    const state = await store.load(sessionFile, sessionId);
     const entries = readContextEntries(sm);
-    const merged = isPiHost(sm) || !liveMessages || liveMessages.length === 0 ? entries : mergeLiveEntries(entries, liveMessages);
-    return { state, coreMessages: entriesToCoreMessages(merged), entries: merged };
+    if (!isPiHost(sm) && liveMessages && liveMessages.length > 0) {
+      const origins = store.getLiveRefOrigins(sessionFile, sessionId);
+      const merged = mergeLiveEntries(entries, liveMessages, state, origins);
+      store.setLiveRefOrigins(sessionFile, sessionId, origins);
+      const coreMessages2 = entriesToCoreMessages(merged);
+      return { state, coreMessages: coreMessages2, entries: merged };
+    }
+    const coreMessages = entriesToCoreMessages(entries);
+    if (liveMessages === void 0) pruneOrphanRefs(state, coreMessages);
+    return { state, coreMessages, entries };
   }
   async function save(state, ctx) {
     const sm = ctx.sessionManager;
@@ -7360,9 +7624,19 @@ function makeCompressTool(runtime) {
 async function handleCompress(args, runtime, ctx, toolCallId) {
   const ranges = args.content ?? [];
   if (ranges.length === 0) return "No ranges provided.";
-  const { state, coreMessages } = await runtime.stateFor(ctx);
+  const { state: initialState, coreMessages } = await runtime.stateFor(ctx);
   const config = runtime.configFor(ctx);
-  const beforeTokens = estimateTokens(coreMessages, collectCoveredMessageIds(state));
+  const estimatedTokens = estimateTokens(coreMessages, collectCoveredMessageIds(initialState));
+  const realUsage = ctx.getContextUsage?.();
+  const turn = runtime.core.processTurn({
+    messages: coreMessages,
+    state: initialState,
+    config,
+    tokenCount: realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : estimatedTokens
+  });
+  const state = turn.state;
+  const messages = turn.messages;
+  const beforeTokens = estimateTokens(messages, collectCoveredMessageIds(state));
   const summaryMaxChars = args.summaryMaxChars;
   const topLevelTopic = args.topic;
   debug.event("compress-in", {
@@ -7371,12 +7645,12 @@ async function handleCompress(args, runtime, ctx, toolCallId) {
     spans: ranges.map((r) => ({ span: `${r.startId}..${r.endId}`, summaryLen: r.summary.length, summary: r.summary, topic: r.topic ?? topLevelTopic ?? null })),
     blocksBefore: state.blocks.length,
     activeBefore: state.blocks.filter((b) => b.active).length,
-    beforeMsgCount: coreMessages.length,
+    beforeMsgCount: messages.length,
     beforeTokens
   });
   const applied = runtime.core.applyCompression({
     ranges: ranges.map((r) => ({ startRef: r.startId, endRef: r.endId, summary: r.summary, topic: r.topic ?? topLevelTopic, summaryMaxChars, compressCallId: toolCallId })),
-    messages: coreMessages,
+    messages,
     state,
     config
   });
@@ -7699,76 +7973,6 @@ function formatSize(tokens) {
   return `${(tokens / 1e6).toFixed(1)}M`;
 }
 
-// src/status-tool.ts
-var StatusParams = typebox_exports.Object({
-  scope: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("compressed"), typebox_exports.Literal("uncompressed")], { description: '"compressed" = drill into blocks; "uncompressed" = show visible messages/ranges. Default: overview.' })),
-  view: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("ranges"), typebox_exports.Literal("messages")], { description: 'For uncompressed scope: "ranges" (default) or "messages" (per-message listing).' })),
-  tool: typebox_exports.Optional(typebox_exports.String({ description: 'Filter by tool name (e.g. "bash", "read"). Only for uncompressed+messages.' })),
-  sort: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("size"), typebox_exports.Literal("time"), typebox_exports.Literal("tool"), typebox_exports.Literal("age")], { description: "Sort order. Default: size." })),
-  limit: typebox_exports.Optional(typebox_exports.Number({ description: "Max items to show (default: 30)." }))
-});
-function makeStatusTool(runtime) {
-  return {
-    name: "acp_status",
-    label: "ACP Status",
-    description: "Context status: overview, compressed blocks, or uncompressed ranges/messages. No args = overview + totals + compressible ranges. scope:'uncompressed' + view:'messages' for per-message listing. scope:'compressed' for block drilldown.",
-    promptSnippet: 'acp_status({}) or acp_status({ scope: "uncompressed", view: "messages" })',
-    promptGuidelines: [
-      "Call with no args for a quick overview of context usage.",
-      "Use scope:'uncompressed' to find the largest compressible ranges.",
-      "Use scope:'compressed' to inspect existing compression blocks."
-    ],
-    parameters: StatusParams,
-    async execute(_toolCallId, params, _signal, _onUpdate, 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 }] };
-    }
-  };
-}
-async function handleStatus(args, runtime, ctx) {
-  const { state, coreMessages } = await runtime.stateFor(ctx);
-  const config = runtime.configFor(ctx);
-  const tokenCount = estimateTokens(coreMessages, collectCoveredMessageIds(state));
-  const realUsage = ctx.getContextUsage?.();
-  const turn = runtime.core.processTurn({
-    messages: coreMessages,
-    state,
-    config,
-    tokenCount: realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : tokenCount
-  });
-  const processed = turn.messages;
-  const base = buildStatusReport(turn.state, processed, defaultCountTokens, {
-    scope: args.scope,
-    view: args.view,
-    tool: args.tool,
-    sort: args.sort,
-    limit: args.limit
-  });
-  if (args.scope) return base;
-  const nudge = turn.nudge;
-  const ranges = nudge?.compressibleRanges ?? [];
-  const protectedRanges = nudge?.protectedRanges ?? [];
-  const extra = [];
-  if (nudge) {
-    extra.push("");
-    extra.push(
-      nudge.shouldInject ? `Nudge: ACTIVE \u2014 ${nudge.reason}` : `Nudge: idle \u2014 ${nudge.reason}`
-    );
-  }
-  if (ranges.length > 0 || protectedRanges.length > 0) {
-    extra.push("");
-    extra.push(formatRanges(ranges, protectedRanges));
-  }
-  return extra.length > 0 ? `${base}
-${extra.join("\n")}` : base;
-}
-
 // src/delegate-tool.ts
 import {
   spawn
@@ -7778,11 +7982,52 @@ import { mkdir as mkdir2, mkdtemp, writeFile as writeFile2, rm, appendFile } fro
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4 } from "path";
 
+// src/footer-status.ts
+var FOOTER_STATUS_KEY = "billion-context-pi";
+var ui;
+var lastFooterText = "";
+function formatCompactTokens(count) {
+  if (count < 1e3) return count.toString();
+  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+  return `${Math.round(count / 1e6)}M`;
+}
+function initFooterStatus(ctx) {
+  ui = ctx.ui;
+  lastFooterText = void 0;
+}
+function updateFooterStatus() {
+  if (!ui) return;
+  const usage = getDelegateUsage();
+  let text;
+  if (usage && usage.totalTokens > 0) {
+    const costStr = usage.cost.total > 0 ? ` ($${usage.cost.total.toFixed(4)})` : "";
+    text = `sub-agents \u2191${formatCompactTokens(usage.input)} \u2193${formatCompactTokens(usage.output)}${costStr}`;
+  }
+  if ((text ?? "") === lastFooterText) return;
+  lastFooterText = text ?? "";
+  try {
+    ui.setStatus(FOOTER_STATUS_KEY, text);
+  } catch {
+  }
+}
+function disposeFooterStatus() {
+  if (ui) {
+    try {
+      ui.setStatus(FOOTER_STATUS_KEY, void 0);
+    } catch {
+    }
+  }
+  ui = void 0;
+  lastFooterText = "";
+}
+
 // src/fleet-widget.ts
 var DELEGATE_WIDGET_KEY = "billion-context-pi-delegates";
 var REFRESH_MS = 500;
 var MAX_TASK_LEN = 48;
-var ui;
+var ui2;
 var timer;
 var lastRenderKey = "";
 var runsSnapshot;
@@ -7811,20 +8056,21 @@ function stopTimer() {
   }
 }
 function clearWidget() {
-  if (!ui) return;
+  if (!ui2) return;
   try {
-    ui.setWidget(DELEGATE_WIDGET_KEY, void 0);
+    ui2.setWidget(DELEGATE_WIDGET_KEY, void 0);
   } catch {
   }
 }
 function refresh() {
-  if (!ui) return;
+  if (!ui2) return;
   const runs2 = runsSnapshot ? runsSnapshot() : [];
   if (runs2.length === 0) {
     if (lastRenderKey !== "") {
       lastRenderKey = "";
       clearWidget();
     }
+    updateFooterStatus();
     stopTimer();
     return;
   }
@@ -7834,16 +8080,18 @@ function refresh() {
   lastRenderKey = renderKey;
   const lines = renderLines(sorted);
   try {
-    ui.setWidget(DELEGATE_WIDGET_KEY, lines, { placement: "belowEditor" });
+    ui2.setWidget(DELEGATE_WIDGET_KEY, lines, { placement: "belowEditor" });
   } catch {
-    ui = void 0;
+    ui2 = void 0;
     stopTimer();
   }
+  updateFooterStatus();
 }
 var delegateStatusWidget = {
   setContext(ctx, snapshot) {
     if (ctx.mode !== "tui") return;
-    ui = ctx.ui;
+    initFooterStatus(ctx);
+    ui2 = ctx.ui;
     runsSnapshot = snapshot;
     if (!timer) {
       timer = setInterval(refresh, REFRESH_MS);
@@ -7854,11 +8102,12 @@ var delegateStatusWidget = {
   dispose() {
     stopTimer();
     clearWidget();
-    ui = void 0;
+    disposeFooterStatus();
+    ui2 = void 0;
     lastRenderKey = "";
   },
   poke() {
-    if (ui && !timer) {
+    if (ui2 && !timer) {
       timer = setInterval(refresh, REFRESH_MS);
       timer.unref?.();
     }
@@ -7872,11 +8121,13 @@ function attachWatchdogs(child, hooks, opts) {
   let eofTimer;
   let killGraceTimer;
   let timeoutTimer;
+  let settledGraceTimer;
   const clearTimers = () => {
     if (idleTimer) clearTimeout(idleTimer);
     if (eofTimer) clearTimeout(eofTimer);
     if (killGraceTimer) clearTimeout(killGraceTimer);
     if (timeoutTimer) clearTimeout(timeoutTimer);
+    if (settledGraceTimer) clearTimeout(settledGraceTimer);
   };
   const killByWatchdog = (reason) => {
     if (hooks.isSettled()) return;
@@ -7894,6 +8145,14 @@ function attachWatchdogs(child, hooks, opts) {
     }, opts.killGraceMs);
     killGraceTimer.unref?.();
   };
+  const settledGrace = (graceMs, _killGraceMs, reason) => {
+    if (hooks.isSettled() || settledGraceTimer) return;
+    settledGraceTimer = setTimeout(() => {
+      settledGraceTimer = void 0;
+      killByWatchdog(reason);
+    }, graceMs);
+    settledGraceTimer.unref?.();
+  };
   const poke = () => {
     if (idleTimer) clearTimeout(idleTimer);
     idleTimer = setTimeout(() => killByWatchdog(`no output for ${opts.idleMs / 6e4}m`), opts.idleMs);
@@ -7917,6 +8176,7 @@ function attachWatchdogs(child, hooks, opts) {
   child.stdout?.once("end", onStdoutEnd);
   return {
     poke,
+    settledGrace,
     dispose: () => {
       clearTimers();
       child.stdout?.removeListener("end", onStdoutEnd);
@@ -7925,16 +8185,66 @@ function attachWatchdogs(child, hooks, opts) {
 }
 
 // src/delegate-events.ts
+function safeNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function handleMessageEnd(event) {
+  const msg = event.message;
+  if (!msg || msg.role !== "assistant") return null;
+  const u = msg.usage;
+  if (!u || typeof u !== "object") return null;
+  const raw = u;
+  const input = safeNumber(raw.input);
+  const output = safeNumber(raw.output);
+  const cacheRead = safeNumber(raw.cacheRead);
+  const cacheWrite = safeNumber(raw.cacheWrite);
+  if (input === void 0 && output === void 0 && cacheRead === void 0 && cacheWrite === void 0) return null;
+  const cost = raw.cost;
+  let parsedCost;
+  if (cost && typeof cost === "object") {
+    const c = cost;
+    parsedCost = {
+      input: typeof c.input === "number" ? c.input : 0,
+      output: typeof c.output === "number" ? c.output : 0,
+      cacheRead: typeof c.cacheRead === "number" ? c.cacheRead : 0,
+      cacheWrite: typeof c.cacheWrite === "number" ? c.cacheWrite : 0,
+      total: typeof c.total === "number" ? c.total : 0
+    };
+  } else {
+    parsedCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+  }
+  return {
+    kind: "usage-update",
+    usage: {
+      input: input ?? 0,
+      output: output ?? 0,
+      cacheRead: cacheRead ?? 0,
+      cacheWrite: cacheWrite ?? 0,
+      cacheWrite1h: safeNumber(raw.cacheWrite1h),
+      reasoning: safeNumber(raw.reasoning),
+      totalTokens: typeof raw.totalTokens === "number" ? raw.totalTokens : 0,
+      cost: parsedCost
+    }
+  };
+}
 var ThinkingCollector = class {
   constructor(showThinking) {
     this.showThinking = showThinking;
   }
   showThinking;
   buf = "";
+  usage;
   push(delta) {
     this.buf += delta;
   }
-  /** Return the segment line to write ("" when empty or disabled), resetting. */
+  process(ev) {
+    if (ev.kind === "thinking-delta") {
+      this.push(ev.delta);
+    }
+    if (ev.kind === "usage-update") {
+      this.usage = ev.usage;
+    }
+  }
   flush() {
     const text = this.buf.trim();
     this.buf = "";
@@ -7942,6 +8252,9 @@ var ThinkingCollector = class {
     return `[thinking] ${text}
 `;
   }
+  getUsage() {
+    return this.usage;
+  }
 };
 function parseEventLine(line) {
   let ev;
@@ -8006,6 +8319,12 @@ function parseEventLine(line) {
       attempt: Number(e.attempt ?? 0)
     };
   }
+  if (e.type === "message_end") {
+    return handleMessageEnd(e);
+  }
+  if (e.type === "agent_settled") {
+    return { kind: "agent-settled" };
+  }
   return null;
 }
 function formatArgs(args) {
@@ -8060,6 +8379,7 @@ function newPortion(text, prev) {
 var MAX_DEPTH = 2;
 var SYNC_TIMEOUT_MS = 5 * 6e4;
 var EOF_GRACE_MS = 1e4;
+var SETTLED_GRACE_MS = 1e4;
 var IDLE_GRACE_MS = 5 * 6e4;
 var ASYNC_TIMEOUT_MS = 30 * 6e4;
 var KILL_GRACE_MS = 1e4;
@@ -8112,6 +8432,20 @@ Answer the question concisely with clear reasoning. Cite file:line when referenc
 };
 var AGENT_NAMES = Object.keys(AGENTS);
 var runs = /* @__PURE__ */ new Map();
+var delegateUsageTotal;
+function addDelegateUsage(u) {
+  delegateUsageTotal = delegateUsageTotal ? accumulateUsage(delegateUsageTotal, u) : u;
+}
+function getDelegateUsage() {
+  return delegateUsageTotal;
+}
+function resetDelegateUsage() {
+  delegateUsageTotal = void 0;
+}
+var delegateDisplayUsage = "separate";
+function setDelegateDisplayUsage(mode) {
+  delegateDisplayUsage = mode;
+}
 function runningRunsSnapshot() {
   const out = [];
   for (const r of runs.values()) {
@@ -8131,6 +8465,10 @@ function makeEventApplier(opts, writers) {
   const handleEventLine = (line) => {
     const ev = parseEventLine(line);
     if (!ev) return;
+    if (ev.kind === "usage-update") {
+      opts.onUsage?.(ev.usage);
+      return;
+    }
     if (ev.kind === "thinking-delta") {
       thinking.push(ev.delta);
       return;
@@ -8139,6 +8477,11 @@ function makeEventApplier(opts, writers) {
       flushThinking();
       return;
     }
+    if (ev.kind === "agent-settled") {
+      flushThinking();
+      opts.onSettled?.();
+      return;
+    }
     if (ev.kind === "reply-delta") {
       flushThinking();
       replyText += ev.delta;
@@ -8219,6 +8562,37 @@ var WaitParams = typebox_exports.Object({
     })
   )
 });
+function safeCost(u) {
+  if (u.cost.input > 0 || u.cost.output > 0 || u.cost.cacheRead > 0 || u.cost.cacheWrite > 0 || u.cost.total > 0) {
+    return {
+      input: u.cost.input > 0 ? u.cost.input : 0,
+      output: u.cost.output > 0 ? u.cost.output : 0,
+      cacheRead: u.cost.cacheRead > 0 ? u.cost.cacheRead : 0,
+      cacheWrite: u.cost.cacheWrite > 0 ? u.cost.cacheWrite : 0,
+      total: u.cost.total > 0 ? u.cost.total : 0
+    };
+  }
+  return void 0;
+}
+function accumulateUsage(a, b) {
+  if (!a) return b;
+  return {
+    input: a.input + b.input,
+    output: a.output + b.output,
+    cacheRead: a.cacheRead + b.cacheRead,
+    cacheWrite: a.cacheWrite + b.cacheWrite,
+    cacheWrite1h: (a.cacheWrite1h ?? 0) + (b.cacheWrite1h ?? 0),
+    reasoning: (a.reasoning ?? 0) + (b.reasoning ?? 0),
+    totalTokens: a.totalTokens + b.totalTokens,
+    cost: {
+      input: a.cost.input + b.cost.input,
+      output: a.cost.output + b.cost.output,
+      cacheRead: a.cost.cacheRead + b.cost.cacheRead,
+      cacheWrite: a.cost.cacheWrite + b.cost.cacheWrite,
+      total: a.cost.total + b.cost.total
+    }
+  };
+}
 var agentListLine = (name) => {
   const def = AGENTS[name];
   if (!def) return "";
@@ -8277,6 +8651,38 @@ function injectedWaitMessage(run, runId, remainingLine) {
   const fileLine = file ? ` If you need details, read the result file: \`${file}\`.` : "";
   return `Delegate \`${runId}\` already delivered its result via a system notification when it finished \u2014 no need to wait on it again.${remainingLine}${fileLine}`;
 }
+function buildWaitResult(run, content, mode = "separate", contentType = "text") {
+  if (run.usage && !run.usageReported) {
+    run.usageReported = true;
+    if (mode === "merged") {
+      const cost = safeCost(run.usage);
+      return {
+        details: void 0,
+        content: [{ type: contentType, text: content }],
+        usage: { ...run.usage, cost: cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }
+      };
+    } else {
+      addDelegateUsage(run.usage);
+    }
+  }
+  return { details: void 0, content: [{ type: contentType, text: content }] };
+}
+function buildCancelResult(run, content, mode = "separate") {
+  if (run.usage && !run.usageReported) {
+    run.usageReported = true;
+    if (mode === "merged") {
+      const cost = safeCost(run.usage);
+      return {
+        details: void 0,
+        content: [{ type: "text", text: content }],
+        usage: { ...run.usage, cost: cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }
+      };
+    } else {
+      addDelegateUsage(run.usage);
+    }
+  }
+  return { details: void 0, content: [{ type: "text", text: content }] };
+}
 function makeDelegateWaitTool(_pi) {
   return {
     name: "acp_delegate_wait",
@@ -8294,21 +8700,22 @@ function makeDelegateWaitTool(_pi) {
       if (!run) {
         return { details: void 0, content: [{ type: "text", text: `No delegate run with runId \`${args.runId}\`. It may have already been reported or never existed.` }] };
       }
+      const displayMode = delegateDisplayUsage;
       if (run.status === "cancelled") {
         run.consumed = true;
-        return { details: void 0, content: [{ type: "text", text: `Delegate \`${args.runId}\` was cancelled (no result).${remainingLineForWait(args.runId)}` }] };
+        return buildWaitResult(run, `Delegate \`${args.runId}\` was cancelled (no result).${remainingLineForWait(args.runId)}`, displayMode);
       }
       if (run.status !== "running") {
         const dedup = injectedWaitMessage(run, args.runId, remainingLineForWait(args.runId));
         if (dedup) {
           run.consumed = true;
-          return { details: void 0, content: [{ type: "text", text: dedup }] };
+          return buildWaitResult(run, dedup, displayMode);
         }
         run.consumed = true;
         if (!run.result) {
-          return { details: void 0, content: [{ type: "text", text: `Delegate \`${args.runId}\` finished but no result is available (persist error).` }] };
+          return buildWaitResult(run, `Delegate \`${args.runId}\` finished but no result is available (persist error).`, displayMode);
         }
-        return { details: void 0, content: [{ type: "text", text: formatRunResult(run) }] };
+        return buildWaitResult(run, formatRunResult(run), displayMode);
       }
       const timeoutMs = Math.min(
         Math.max(args.timeout ?? WAIT_TIMEOUT_MS_DEFAULT, 1e3),
@@ -8320,28 +8727,28 @@ function makeDelegateWaitTool(_pi) {
       return new Promise((resolve2) => {
         let settled = false;
         let timer2;
-        const finish = (text) => {
+        const finish = (result) => {
           if (settled) return;
           settled = true;
           run.waiter = void 0;
           if (timer2) clearTimeout(timer2);
           signal?.removeEventListener("abort", onAbort);
-          resolve2({ details: void 0, content: [{ type: "text", text }] });
+          resolve2(result);
         };
         const onAbort = () => {
-          finish(`Aborted; delegate \`${args.runId}\` is still running in the background. A notification will be injected when it finishes.`);
+          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.` }] });
         };
         run.waiter = () => {
           run.consumed = true;
           if (run.status === "cancelled") {
-            finish(`Delegate \`${run.runId}\` was cancelled (no result).${remainingLineForWait(run.runId)}`);
+            finish(buildWaitResult(run, `Delegate \`${run.runId}\` was cancelled (no result).${remainingLineForWait(run.runId)}`, displayMode));
             return;
           }
-          finish(formatRunResult(run));
+          finish(buildWaitResult(run, formatRunResult(run), displayMode));
         };
         signal?.addEventListener("abort", onAbort);
         timer2 = setTimeout(
-          () => finish(`Failed: delegate \`${args.runId}\` result not ready after ${Math.round(timeoutMs / 1e3)}s. Do NOT keep waiting or retry \u2014 go do other work now. The run continues in the background and a completion notification (with the result file path) will be injected into the chat when it finishes.`),
+          () => finish({ details: void 0, content: [{ type: "text", text: `Failed: delegate \`${args.runId}\` result not ready after ${Math.round(timeoutMs / 1e3)}s. Do NOT keep waiting or retry \u2014 go do other work now. The run continues in the background and a completion notification (with the result file path) will be injected into the chat when it finishes.` }] }),
           timeoutMs
         );
       });
@@ -8360,16 +8767,10 @@ function makeDelegateCancelTool(_pi) {
       const { runId } = params;
       const run = runs.get(runId);
       if (!run) {
-        return {
-          details: void 0,
-          content: [{ type: "text", text: `Unknown runId "${runId}".` }]
-        };
+        return { details: void 0, content: [{ type: "text", text: `Unknown runId "${runId}".` }] };
       }
       if (run.status !== "running") {
-        return {
-          details: void 0,
-          content: [{ type: "text", text: `Run ${runId} already ${run.status} (no action).` }]
-        };
+        return buildCancelResult(run, `Run ${runId} already ${run.status} (no action).`);
       }
       run.status = "cancelled";
       run.consumed = true;
@@ -8380,10 +8781,8 @@ function makeDelegateCancelTool(_pi) {
         logError("delegate", { event: "cancel-kill-error", runId, error: String(err) });
       }
       delegateStatusWidget.poke();
-      return {
-        details: void 0,
-        content: [{ type: "text", text: `Cancelled ${runId} (${run.agent}).` }]
-      };
+      const displayMode = delegateDisplayUsage;
+      return buildCancelResult(run, `Cancelled ${runId} (${run.agent}).`, displayMode);
     }
   };
 }
@@ -8432,11 +8831,11 @@ async function runDelegate(pi, args, ctx, signal) {
       {
         isSettled: () => settled || run.status !== "running",
         onKill: (reason) => {
-          run.timedOut = reason;
+          if (!run.agentSettled) run.timedOut = reason;
           debug.event("delegate-watchdog", { runId, reason });
         },
         onEofGrace: () => {
-          run.timedOut = "output ended but process did not exit";
+          if (!run.agentSettled) run.timedOut = "output ended but process did not exit";
           debug.event("delegate-eof-grace", { runId, ms: EOF_GRACE_MS });
         }
       },
@@ -8453,7 +8852,16 @@ async function runDelegate(pi, args, ctx, signal) {
     });
     let stdoutBuf = "";
     const applier = makeEventApplier(
-      { showThinking: args.showThinking === true },
+      {
+        showThinking: args.showThinking === true,
+        onUsage: (u) => {
+          run.usage = accumulateUsage(run.usage, u);
+        },
+        onSettled: () => {
+          run.agentSettled = true;
+          watchdog.settledGrace(SETTLED_GRACE_MS, KILL_GRACE_MS, "agent settled but process did not exit");
+        }
+      },
       { reply: replyStream, activity: activityStream }
     );
     child.stdout?.on("data", (c) => {
@@ -8527,7 +8935,11 @@ async function runDelegate(pi, args, ctx, signal) {
             delegateStatusWidget.poke();
             return;
           }
-          const injected = injectResult(pi, args.agent, runId, args.task, code, file2, run.timedOut);
+          const mode = delegateDisplayUsage;
+          const injected = injectResult(pi, args.agent, runId, args.task, code, file2, run.timedOut, run.usage, mode, run.usageReported);
+          if (run.usage && !run.usageReported && (mode === "separate" || injected)) {
+            run.usageReported = true;
+          }
           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 });
@@ -8648,7 +9060,7 @@ function formatSyncResult(agent, runId, task, r, file) {
   const body = r.timedOut ? "(timed out)" : r.stderr.trim() || "(no stderr)";
   return formatPayload(header, file, task, body);
 }
-function injectResult(pi, agent, runId, task, code, file, timedOut) {
+function injectResult(pi, agent, runId, task, code, file, timedOut, usage, mode = "separate", usageAlreadyReported) {
   const send = pi.sendUserMessage;
   if (typeof send !== "function") {
     debug.event("delegate-inject-skipped", { runId, reason: "sendUserMessage unavailable" });
@@ -8659,7 +9071,37 @@ function injectResult(pi, agent, runId, task, code, file, timedOut) {
   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 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.`;
+  let usageNote = "";
+  if (mode === "separate") {
+    if (usage && !usageAlreadyReported) {
+      addDelegateUsage(usage);
+    }
+    const totalUsage = getDelegateUsage();
+    if (totalUsage) {
+      const cost = totalUsage.cost.total;
+      const costStr = cost > 0 ? ` ($${cost.toFixed(4)})` : "";
+      usageNote = `
+
+\u2500\u2500 Session delegate usage (excluded from main totals) \u2500\u2500
+Tokens: ${totalUsage.input.toLocaleString()} in, ${totalUsage.output.toLocaleString()} out (${totalUsage.totalTokens.toLocaleString()} total)${costStr}`;
+    }
+  } else if (usage) {
+    const lines = [];
+    if (usage.totalTokens) lines.push(`tokens=${usage.totalTokens.toLocaleString()}`);
+    if (usage.input || usage.output) lines.push(`in=${usage.input.toLocaleString()} out=${usage.output.toLocaleString()}`);
+    if (usage.cacheRead) lines.push(`cache_read=${usage.cacheRead.toLocaleString()}`);
+    if (usage.cacheWrite) lines.push(`cache_write=${usage.cacheWrite.toLocaleString()}`);
+    if (usage.cost && typeof usage.cost === "object") {
+      const c = usage.cost;
+      if (typeof c.total === "number" && c.total > 0) {
+        lines.push(`cost=$${c.total.toFixed(4)}`);
+      } else if (typeof c.input === "number" && c.input > 0 || typeof c.output === "number" && c.output > 0) {
+        lines.push(`cost=${JSON.stringify(c)}`);
+      }
+    }
+    if (lines.length) usageNote = ` Usage: ${lines.join(", ")}.`;
+  }
+  const header = `[acp_delegate ${status}] **${agent}** (runId \`${runId}\`, exit ${code ?? "?"})${timeoutNote}${remainingLine}${usageNote} 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" });
@@ -8710,6 +9152,90 @@ function truncate2(s, n) {
   return s.slice(0, n - 1) + "\u2026";
 }
 
+// src/status-tool.ts
+var StatusParams = typebox_exports.Object({
+  scope: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("compressed"), typebox_exports.Literal("uncompressed")], { description: '"compressed" = drill into blocks; "uncompressed" = show visible messages/ranges. Default: overview.' })),
+  view: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("ranges"), typebox_exports.Literal("messages")], { description: 'For uncompressed scope: "ranges" (default) or "messages" (per-message listing).' })),
+  tool: typebox_exports.Optional(typebox_exports.String({ description: 'Filter by tool name (e.g. "bash", "read"). Only for uncompressed+messages.' })),
+  sort: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("size"), typebox_exports.Literal("time"), typebox_exports.Literal("tool"), typebox_exports.Literal("age")], { description: "Sort order. Default: size." })),
+  limit: typebox_exports.Optional(typebox_exports.Number({ description: "Max items to show (default: 30)." }))
+});
+function makeStatusTool(runtime) {
+  return {
+    name: "acp_status",
+    label: "ACP Status",
+    description: "Context status: overview, compressed blocks, or uncompressed ranges/messages. No args = overview + totals + compressible ranges. scope:'uncompressed' + view:'messages' for per-message listing. scope:'compressed' for block drilldown.",
+    promptSnippet: 'acp_status({}) or acp_status({ scope: "uncompressed", view: "messages" })',
+    promptGuidelines: [
+      "Call with no args for a quick overview of context usage.",
+      "Use scope:'uncompressed' to find the largest compressible ranges.",
+      "Use scope:'compressed' to inspect existing compression blocks."
+    ],
+    parameters: StatusParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, 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 }] };
+    }
+  };
+}
+async function handleStatus(args, runtime, ctx) {
+  const { state, coreMessages } = await runtime.stateFor(ctx);
+  const config = runtime.configFor(ctx);
+  const tokenCount = estimateTokens(coreMessages, collectCoveredMessageIds(state));
+  const realUsage = ctx.getContextUsage?.();
+  const turn = runtime.core.processTurn({
+    messages: coreMessages,
+    state,
+    config,
+    tokenCount: realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : tokenCount
+  });
+  const processed = turn.messages;
+  const base = buildStatusReport(turn.state, processed, defaultCountTokens, {
+    scope: args.scope,
+    view: args.view,
+    tool: args.tool,
+    sort: args.sort,
+    limit: args.limit
+  });
+  if (args.scope) return base;
+  const nudge = turn.nudge;
+  const ranges = nudge?.compressibleRanges ?? [];
+  const protectedRanges = nudge?.protectedRanges ?? [];
+  const extra = [];
+  if (nudge) {
+    extra.push("");
+    extra.push(
+      nudge.shouldInject ? `Nudge: ACTIVE \u2014 ${nudge.reason}` : `Nudge: idle \u2014 ${nudge.reason}`
+    );
+  }
+  if (ranges.length > 0 || protectedRanges.length > 0) {
+    extra.push("");
+    extra.push(formatRanges(ranges, protectedRanges));
+  }
+  const delegateUsage = getDelegateUsage();
+  if (delegateUsage && delegateUsage.totalTokens > 0) {
+    extra.push("");
+    const cost = delegateUsage.cost.total;
+    const costStr = cost > 0 ? ` ($${cost.toFixed(4)})` : "";
+    extra.push("\u2500\u2500 Session delegate usage (excluded from main totals) \u2500\u2500");
+    extra.push(`Tokens: ${delegateUsage.input.toLocaleString()} in, ${delegateUsage.output.toLocaleString()} out (${delegateUsage.totalTokens.toLocaleString()} total)${costStr}`);
+  } else if (resolveDelegate(runtime.adapter).displayUsage === "merged") {
+    extra.push("");
+    extra.push("merged mode: delegate usage is included in main session totals.");
+  } else {
+    extra.push("");
+    extra.push("Delegate usage: none this session.");
+  }
+  return extra.length > 0 ? `${base}
+${extra.join("\n")}` : base;
+}
+
 // src/compat.ts
 function normalizeSystemPrompt(input) {
   if (input === void 0) return "";
@@ -8740,7 +9266,7 @@ function makeCommands(runtime) {
     {
       name: "acp-status",
       options: {
-        description: "Detailed ACP status (block tiers, token breakdown).",
+        description: "Detailed ACP status (block tiers, token breakdown, delegate usage).",
         handler: async (_args, ctx) => ctx.ui.notify(await statusReport(runtime, ctx))
       }
     },
@@ -8795,9 +9321,7 @@ ${text}`);
   ];
 }
 function fmtTokens(n) {
-  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
-  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
-  return String(n);
+  return formatCompactTokens(n);
 }
 function bar(value, total, width = 20) {
   if (total === 0) return "";
@@ -8822,7 +9346,7 @@ async function statusReport(runtime, ctx) {
   const activeBlocksList = state.blocks.filter((b) => b.active);
   const totalBlocksList = state.blocks;
   const lines = [];
-  const versionStr = "0.1.34" ? `billion-context-pi@${"0.1.34"}` : "";
+  const versionStr = "0.1.36" ? `billion-context-pi@${"0.1.36"}` : "";
   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");
@@ -8885,6 +9409,15 @@ async function statusReport(runtime, ctx) {
     lines.push("Blocks: none (nothing compressed yet)");
   }
   lines.push("");
+  const delegateUsage = getDelegateUsage();
+  if (delegateUsage && delegateUsage.totalTokens > 0) {
+    lines.push("");
+    const cost = delegateUsage.cost.total;
+    const costStr = cost > 0 ? ` ($${cost.toFixed(4)})` : "";
+    lines.push("\u2500\u2500 Session delegate usage (excluded from main totals) \u2500\u2500");
+    lines.push(`Tokens: ${delegateUsage.input.toLocaleString()} in, ${delegateUsage.output.toLocaleString()} out (${delegateUsage.totalTokens.toLocaleString()} total)${costStr}`);
+  }
+  lines.push("");
   lines.push("Tag visibility: tags injected to LLM only (deep copy), not persisted in session, not shown in terminal.");
   return lines.join("\n");
 }
@@ -9189,7 +9722,7 @@ async function checkForUpdate(autoUpdate, notify) {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.34";
+    const current = runtimeVersion ?? "0.1.36";
     const hasUpdate = isNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -9382,7 +9915,16 @@ async function loadUserConfig(cwd) {
 function join8(...parts) {
   return path3.join(...parts);
 }
-var KNOWN = /* @__PURE__ */ new Set(["debug", "autoUpdate", "modelContextLimit", "delegate", "toolBashDefaultTimeout", "toolOutputMaxBytes"]);
+var KNOWN = /* @__PURE__ */ new Set([
+  "debug",
+  "autoUpdate",
+  "modelContextLimit",
+  "toolBashDefaultTimeout",
+  "toolOutputMaxBytes",
+  "delegate",
+  "compress",
+  "displayUsage"
+]);
 function pickKnown(parsed) {
   const out = {};
   for (const [k, v] of Object.entries(parsed)) {
@@ -9394,8 +9936,6 @@ function applyUserConfig(adapter, user) {
   return {
     ...adapter,
     ...user,
-    // coreOverrides / protectedTools / preserveRecentMessages are not overridable
-    // from acp.json (keep them from the factory config).
     coreOverrides: adapter.coreOverrides,
     protectedTools: adapter.protectedTools,
     preserveRecentMessages: adapter.preserveRecentMessages
@@ -9428,16 +9968,19 @@ function wireSessionLifecycle(pi, runtime) {
   pi.on("session_start", async (_event, ctx) => {
     runtime.store.invalidate();
     runtime.clearNudgeTracking();
+    resetDelegateUsage();
+    setDelegateDisplayUsage("separate");
     const sid = ctx.sessionManager.getSessionId();
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.34" : null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.36" : null });
     try {
       const user = await loadUserConfig(ctx.cwd);
       runtime.setAdapter(applyUserConfig(runtime.adapter, user));
+      setDelegateDisplayUsage(resolveDelegate(runtime.adapter).displayUsage);
       if (runtime.adapter.debug !== void 0) setDebugEnabled(runtime.adapter.debug);
     } catch (e) {
       logThrow("config", e, { sid, phase: "session_start" });
     }
-    if (runtime.adapter.delegate !== false) {
+    if (resolveDelegate(runtime.adapter).enabled) {
       pi.registerTool(makeDelegateTool(pi));
       pi.registerTool(makeDelegateWaitTool(pi));
       pi.registerTool(makeDelegateCancelTool(pi));