@letrquan/book 0.2.0 → 0.3.0

package/dist/{chunk-V4BOYR52.js → chunk-RFJ6Q6LE.js}

@@ -5,40 +5,73 @@ import {
   createAgentRunContext,
   createRunAmbientSnapshot,
   createTerminalOutcome,
+  isSpendlessUsage,
   isTerminalStatus,
   loadGitignore,
-  runAgentLoop,
-  runCompact,
-  runHooks,
-  runPostCompactHooks
-} from "./chunk-XIFFTATU.js";
+  runAgentLoop
+} from "./chunk-5YHTKWJN.js";
 import {
   DEFAULT_CONFIDENCE_THRESHOLD,
   REVIEW_LENSES,
+  addUsage,
+  applyCompactResult,
   buildReviewerPrompt,
   buildSingleReviewPrompt,
   clampConfidence,
   isReviewCategory,
   isReviewSeverity,
+  judgeCompaction,
+  judgedResult,
   loadReviewConfig,
   renderReviewConfigInstruction,
   renderReviewTarget,
-  resolveReviewTarget
-} from "./chunk-A7JLBK2Y.js";
+  resolveCompactBudgets,
+  resolveReviewTarget,
+  runCompact,
+  runHooks,
+  runPostCompactHooks
+} from "./chunk-IME7R2UI.js";
 import {
+  observationKey,
   onAbort,
   throwIfAborted,
+  workspaceIdentity,
   yieldToEventLoop
-} from "./chunk-MAQXCUR4.js";
+} from "./chunk-J62VZYOB.js";
 import {
-  normalizeToolResult,
-  observationKey,
-  workspaceIdentity
-} from "./chunk-5GDZ22YP.js";
+  globWalkIgnore
+} from "./chunk-JTPOI3KU.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
 import {
   createDebugLogger,
   createDebugLoggerWithCounter
-} from "./chunk-GTVB4HEM.js";
+} from "./chunk-62QL5QUP.js";
+import {
+  normalizeToolResult
+} from "./chunk-224FJZLH.js";
+
+// src/session-driver.ts
+var SESSION_DRIVERS = ["human", "agent"];
+function isSessionDriver(value) {
+  return SESSION_DRIVERS.includes(value);
+}
+function parseSessionDriver(value) {
+  const normalized = value?.trim().toLowerCase();
+  return isSessionDriver(normalized) ? normalized : void 0;
+}
+function resolveSessionDriver(input) {
+  const explicit = parseSessionDriver(input.explicit);
+  if (explicit) return { driver: explicit, signals: ["flag"] };
+  const fromEnv = parseSessionDriver(input.env.BOOK_SESSION_DRIVER);
+  if (fromEnv) return { driver: fromEnv, signals: ["BOOK_SESSION_DRIVER"] };
+  const signals = [];
+  const claudeCode = input.env.CLAUDECODE?.trim();
+  if (claudeCode && claudeCode !== "0") signals.push("CLAUDECODE");
+  if (input.env.AI_AGENT?.trim()) signals.push("AI_AGENT");
+  return { driver: signals.length > 0 ? "agent" : "human", signals };
+}
 
 // src/session/name.ts
 var UNTITLED_SESSION_NAME = "Untitled session";
@@ -274,7 +307,8 @@ var SessionStore = class {
         name: meta.name,
         createdAt: now,
         updatedAt: now,
-        messageCount: 0
+        messageCount: 0,
+        ...meta.driver ? { driver: meta.driver } : {}
       }
     };
     appendFileSync(this.path(id), JSON.stringify(header) + "\n", "utf-8");
@@ -286,10 +320,10 @@ var SessionStore = class {
     appendFileSync(this.path(id), serialized, "utf-8");
     const cached = this.parsedSessions.get(id);
     if (cached) {
-      const stat = statSync(this.path(id));
+      const stat2 = statSync(this.path(id));
       cached.records.push(record);
-      cached.size = stat.size;
-      cached.mtimeMs = stat.mtimeMs;
+      cached.size = stat2.size;
+      cached.mtimeMs = stat2.mtimeMs;
       cached.loaded = void 0;
       cached.activeEventIds = void 0;
       cached.activeRecords = void 0;
@@ -300,9 +334,9 @@ var SessionStore = class {
   readRecords(id) {
     const p = this.path(id);
     if (!existsSync(p)) throw new Error(`Session not found: ${id}`);
-    const stat = statSync(p);
+    const stat2 = statSync(p);
     const cached = this.parsedSessions.get(id);
-    if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+    if (cached && cached.size === stat2.size && cached.mtimeMs === stat2.mtimeMs) {
       return cached.records;
     }
     const records = [];
@@ -337,8 +371,8 @@ var SessionStore = class {
       closeSync(descriptor);
     }
     this.parsedSessions.set(id, {
-      size: stat.size,
-      mtimeMs: stat.mtimeMs,
+      size: stat2.size,
+      mtimeMs: stat2.mtimeMs,
       records
     });
     return records;
@@ -356,6 +390,9 @@ var SessionStore = class {
     entry.meta.updatedAt = record.timestamp;
     if (data.kind === "session_meta_patch") {
       if (Object.prototype.hasOwnProperty.call(data, "name")) entry.meta.name = data.name;
+      if (isSessionDriver(data.driver)) {
+        entry.meta.driver = data.driver;
+      }
     } else if (record.type === "user") {
       entry.meta.messageCount++;
       entry.lastMessageRole = "user";
@@ -406,7 +443,8 @@ var SessionStore = class {
       createdAt: storedMeta?.createdAt ?? 0,
       updatedAt: storedMeta?.updatedAt ?? 0,
       messageCount: 0,
-      ...storedMeta?.name === void 0 ? {} : { name: storedMeta.name }
+      ...storedMeta?.name === void 0 ? {} : { name: storedMeta.name },
+      ...isSessionDriver(storedMeta?.driver) ? { driver: storedMeta.driver } : {}
     };
     const transcript = [];
     let contextHistory = [];
@@ -427,21 +465,18 @@ var SessionStore = class {
       const data = record.data;
       if (data.kind === "session_meta_patch") {
         if (Object.prototype.hasOwnProperty.call(data, "name")) meta.name = data.name;
+        const driver = data.driver;
+        if (isSessionDriver(driver)) meta.driver = driver;
         continue;
       }
       if (data.kind === "session_meta" || data.kind === "session_touch") continue;
       if (record.type === "usage") {
         const entry = record.data;
         if (entry?.version === 1 && entry.usage) {
-          carriedUsage = {
-            promptTokens: (carriedUsage?.promptTokens ?? 0) + (entry.usage.promptTokens ?? 0),
-            completionTokens: (carriedUsage?.completionTokens ?? 0) + (entry.usage.completionTokens ?? 0),
-            totalTokens: (carriedUsage?.totalTokens ?? 0) + (entry.usage.totalTokens ?? 0),
-            cacheCreationInputTokens: (carriedUsage?.cacheCreationInputTokens ?? 0) + (entry.usage.cacheCreationInputTokens ?? 0),
-            cacheReadInputTokens: (carriedUsage?.cacheReadInputTokens ?? 0) + (entry.usage.cacheReadInputTokens ?? 0)
-          };
+          carriedUsage = addUsage(carriedUsage ?? null, entry.usage);
           const model = entry.responseModel ?? entry.requestedModel;
           if (model) carriedModels.add(model);
+          for (const spent of entry.models ?? []) carriedModels.add(spent);
         }
         continue;
       }
@@ -601,6 +636,7 @@ var SessionStore = class {
             toolCalls: data.toolCalls,
             toolResults: normalizePersistedToolResults(data.toolResults),
             fileObservations: data.fileObservations,
+            hostNotice: data.hostNotice,
             timestamp: record.timestamp
           };
           transcript.push(message);
@@ -942,7 +978,10 @@ function reviewRunnerFor(manager, attribution = {}) {
         rootRunId: attribution.rootRunId,
         parentRunId: attribution.parentRunId,
         parentSessionId: attribution.parentSessionId,
-        notifyParentOnCompletion: false
+        notifyParentOnCompletion: false,
+        // The report dies with the process, so a restart must not re-run a reviewer
+        // whose result nobody would receive.
+        resumeAfterRestart: false
       });
       return {
         id: record.id,
@@ -988,16 +1027,17 @@ function fixRunnerFor(manager, attribution = {}) {
 }
 
 // src/review/json.ts
-function extractJsonObject(text) {
-  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const candidate = fenced?.[1] ?? text;
-  const start = candidate.indexOf("{");
+function firstObjectIn(text) {
+  return objectIn(text, 0)?.slice;
+}
+function objectIn(text, from) {
+  const start = text.indexOf("{", from);
   if (start === -1) return void 0;
   let depth = 0;
   let inString = false;
   let escaped = false;
-  for (let index = start; index < candidate.length; index++) {
-    const char = candidate[index];
+  for (let index = start; index < text.length; index++) {
+    const char = text[index];
     if (inString) {
       if (escaped) escaped = false;
       else if (char === "\\") escaped = true;
@@ -1006,10 +1046,47 @@ function extractJsonObject(text) {
     }
     if (char === '"') inString = true;
     else if (char === "{") depth++;
-    else if (char === "}" && --depth === 0) return candidate.slice(start, index + 1);
+    else if (char === "}" && --depth === 0) {
+      return { start, end: index + 1, slice: text.slice(start, index + 1) };
+    }
   }
   return void 0;
 }
+function fenceRuns(text) {
+  const runs = [];
+  for (let index = text.indexOf("```"); index !== -1; index = text.indexOf("```", index + 3)) {
+    runs.push(index);
+  }
+  return runs;
+}
+function fenceContent(text, open, close) {
+  return text.slice(open + 3, close).replace(/^json\s*/i, "");
+}
+function isJsonObject(candidate) {
+  try {
+    const parsed = JSON.parse(candidate);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+function extractJsonObject(text) {
+  const runs = fenceRuns(text);
+  const whole = objectIn(text, 0);
+  if (whole !== void 0 && isJsonObject(whole.slice) && runs.every((run) => run >= whole.start && run < whole.end)) {
+    return whole.slice;
+  }
+  let firstBalanced;
+  for (let open = 0; open < runs.length; open++) {
+    for (let close = open + 1; close < runs.length; close++) {
+      const found = firstObjectIn(fenceContent(text, runs[open], runs[close]));
+      if (found === void 0) continue;
+      if (isJsonObject(found)) return found;
+      firstBalanced ??= found;
+    }
+  }
+  return firstBalanced ?? firstObjectIn(text);
+}
 function parseJsonObject(text) {
   const candidate = extractJsonObject(text);
   if (!candidate) return void 0;
@@ -1207,6 +1284,29 @@ function rankFindings(findings) {
 function filterLowConfidence(findings, threshold = DEFAULT_CONFIDENCE_THRESHOLD) {
   return findings.filter((finding) => finding.confidence >= threshold);
 }
+function isStanding(finding) {
+  return finding.verification === void 0 || finding.verification === "confirmed";
+}
+function deriveReviewVerdict(input) {
+  const entries = [...input.coverage.reviewers, input.coverage.verifier].filter(
+    (entry) => entry !== void 0
+  );
+  if (entries.some((entry) => entry.status !== "completed")) {
+    return { verdict: "inconclusive", reason: "incomplete-coverage" };
+  }
+  const standing = input.findings.filter(isStanding);
+  if (standing.some((finding) => finding.severity === "critical")) {
+    return { verdict: "blocking", reason: "standing-findings" };
+  }
+  if (standing.length > 0) return { verdict: "recommend", reason: "standing-findings" };
+  if (input.findings.length > 0) {
+    return { verdict: "inconclusive", reason: "unverified-findings" };
+  }
+  if (input.reviewerVerdicts?.some((verdict) => verdict === "inconclusive")) {
+    return { verdict: "inconclusive", reason: "reviewer-inconclusive" };
+  }
+  return { verdict: "clean", reason: "clean" };
+}
 
 // src/review/verify-findings.ts
 function buildVerificationPrompt(findings, config = {}, target) {
@@ -1370,13 +1470,23 @@ async function runSingleReview(runner, scope, workspace, options = {}) {
     rankFindings(filterLowConfidence(dedupeFindings(parsed.report.findings)))
   );
   const coverage = passCoverage("single", structured, parsed.droppedFindings, findings.length);
+  const reviewerEntries = [coverage];
+  const reportCoverage = { reviewers: reviewerEntries };
+  const { verdict, reason } = deriveReviewVerdict({
+    findings,
+    coverage: reportCoverage,
+    // A completed, structured pass whose own verdict is `inconclusive` is the
+    // one reviewer signal that is not already a coverage entry.
+    reviewerVerdicts: structured ? [parsed.report.verdict] : []
+  });
   const report = {
-    verdict: coverage.status === "completed" ? parsed.report.verdict : "inconclusive",
+    verdict,
     findings,
-    coverage: { reviewers: [coverage] }
+    coverage: reportCoverage
   };
   const text = [
-    renderCoverageWarnings([coverage]),
+    renderCoverageWarnings(reviewerEntries),
+    renderVerdictReason("Review", reason),
     renderReviewReport(report),
     coverage.status === "completed" ? "" : renderRawOutput("reviewer", settled.result)
   ].filter(Boolean).join("\n\n");
@@ -1414,6 +1524,17 @@ function renderCoverageWarnings(entries) {
     })
   ].join("\n");
 }
+function renderVerdictReason(prefix, reason) {
+  const explanation = {
+    "incomplete-coverage": "",
+    "standing-findings": "",
+    "unverified-findings": "the verifier could neither confirm nor reject the remaining findings.",
+    "reviewer-inconclusive": "a reviewer reported its review as inconclusive.",
+    clean: ""
+  };
+  const text = explanation[reason];
+  return text ? `${prefix}: ${text}` : "";
+}
 async function runDeepReview(runner, scope, workspace, options = {}) {
   if (scope.error) throw new Error(scope.error);
   const target = await resolveReviewTarget(workspace, scope);
@@ -1514,22 +1635,22 @@ async function runDeepReview(runner, scope, workspace, options = {}) {
     reviewerCoverage.sort(
       (left, right) => REVIEW_LENSES.findIndex((lens) => lens.id === left.id) - REVIEW_LENSES.findIndex((lens) => lens.id === right.id)
     );
-    const completeDiscovery = reviewerCoverage.every((entry) => entry.status === "completed");
     const candidates = reindex(rankFindings(filterLowConfidence(dedupeFindings(rawFindings))));
     if (candidates.length === 0) {
+      const reportCoverage2 = { reviewers: reviewerCoverage };
+      const { verdict: verdict2, reason: reason2 } = deriveReviewVerdict({
+        findings: [],
+        coverage: reportCoverage2,
+        reviewerVerdicts
+      });
       const report2 = {
-        verdict: completeDiscovery && reviewerVerdicts.every((verdict2) => verdict2 === "clean") ? "clean" : "inconclusive",
+        verdict: verdict2,
         findings: [],
-        coverage: { reviewers: reviewerCoverage }
+        coverage: reportCoverage2
       };
       const warning2 = renderCoverageWarnings(reviewerCoverage);
-      return {
-        target,
-        report: report2,
-        text: [warning2 || "Deep review complete: no confirmed findings.", ...rawOutputs].join(
-          "\n\n"
-        )
-      };
+      const summary = warning2 || (reason2 === "clean" ? "Deep review complete: no confirmed findings." : renderVerdictReason("Deep review", reason2));
+      return { target, report: report2, text: [summary, ...rawOutputs].join("\n\n") };
     }
     if (options.signal?.aborted) return cancelledDeepResult(target);
     const verifier = await spawnTracked(
@@ -1556,20 +1677,30 @@ async function runDeepReview(runner, scope, workspace, options = {}) {
     }
     const verified = applyVerification(candidates, verdicts);
     const ranked = rankFindings(verified);
-    const completeCoverage = completeDiscovery && verifierCoverage.status === "completed";
-    const verdict = !completeCoverage ? "inconclusive" : ranked.some(
-      (finding) => finding.verification === "confirmed" && finding.severity === "critical"
-    ) ? "blocking" : ranked.some((finding) => finding.verification === "confirmed") ? "recommend" : ranked.length > 0 ? "inconclusive" : "clean";
+    const reportCoverage = {
+      reviewers: reviewerCoverage,
+      verifier: verifierCoverage
+    };
+    const { verdict, reason } = deriveReviewVerdict({
+      findings: ranked,
+      coverage: reportCoverage,
+      reviewerVerdicts
+    });
     const report = {
       verdict,
       findings: ranked,
-      coverage: { reviewers: reviewerCoverage, verifier: verifierCoverage }
+      coverage: reportCoverage
     };
     const warning = renderCoverageWarnings([...reviewerCoverage, verifierCoverage]);
     return {
       target,
       report,
-      text: [warning, renderReviewReport(report), ...rawOutputs].filter(Boolean).join("\n\n")
+      text: [
+        warning,
+        renderVerdictReason("Deep review", reason),
+        renderReviewReport(report),
+        ...rawOutputs
+      ].filter(Boolean).join("\n\n")
     };
   } catch (error) {
     await stopNonTerminal(runner, spawned);
@@ -1857,12 +1988,18 @@ function reduceAgentSessionSnapshot(snapshot, event) {
     case "agent_permission":
     case "agent_persistence":
     case "skill_lifecycle":
+    case "notice":
     case "background_job_start":
     case "background_job_update":
     case "background_job_output":
     case "background_job_result":
     case "background_job_dismiss":
       return snapshot;
+    // `agent_notice` is a child's own line for the operator (#305): it is not part of the
+    // child's record and not part of the parent's transcript, so the snapshot drops it and
+    // the TUI reads it from the manager subscription instead (see `useManagedAgents`).
+    case "agent_notice":
+      return snapshot;
     case "evidence_update":
       return { ...snapshot, evidence: upsertById(snapshot.evidence, event.evidence) };
     case "attempt_discarded":
@@ -1900,6 +2037,9 @@ function reduceAgentSessionSnapshot(snapshot, event) {
 }
 
 // src/session/resolve.ts
+function recordResumeDriver(store, sessionId, recorded, driver) {
+  if (driver === "agent" && recorded !== "agent") store.patchMeta(sessionId, { driver: "agent" });
+}
 function selectSession(store, selector, cwd) {
   const exact = store.findByName(selector) ?? store.findById(selector);
   if (exact) return exact;
@@ -1970,7 +2110,8 @@ function resolveSessionBootstrap(store, options) {
       const sessionId2 = store.create({
         id: options.sessionId,
         cwd: options.cwd,
-        name: options.sessionName
+        name: options.sessionName,
+        driver: options.driver
       });
       return {
         sessionId: sessionId2,
@@ -1992,7 +2133,8 @@ function resolveSessionBootstrap(store, options) {
   if (selected) {
     const loaded = store.load(selected.id);
     if (options.forkSession) {
-      const sessionId2 = store.fork ? store.fork(selected.id, { cwd: options.cwd, name: options.sessionName }) : store.create({ cwd: options.cwd, name: options.sessionName });
+      const driver = loaded.meta.driver === "agent" ? "agent" : options.driver;
+      const sessionId2 = store.fork ? store.fork(selected.id, { cwd: options.cwd, name: options.sessionName, driver }) : store.create({ cwd: options.cwd, name: options.sessionName, driver });
       if (!store.fork) persistHistory(store, sessionId2, loaded.transcript);
       return {
         sessionId: sessionId2,
@@ -2010,6 +2152,7 @@ function resolveSessionBootstrap(store, options) {
       };
     }
     store.touch(selected.id);
+    recordResumeDriver(store, selected.id, loaded.meta.driver, options.driver);
     return {
       sessionId: selected.id,
       sessionName: loaded.meta.name,
@@ -2027,7 +2170,11 @@ function resolveSessionBootstrap(store, options) {
       created: false
     };
   }
-  const sessionId = store.create({ cwd: options.cwd, name: options.sessionName });
+  const sessionId = store.create({
+    cwd: options.cwd,
+    name: options.sessionName,
+    driver: options.driver
+  });
   return {
     sessionId,
     sessionName: options.sessionName,
@@ -2044,8 +2191,9 @@ function resolveSessionBootstrap(store, options) {
 }
 
 // src/input/file-mentions.ts
+import { stat } from "fs/promises";
 import { isAbsolute, relative, resolve as resolve2 } from "path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 var DEFAULT_IGNORE = [
   "**/.git/**",
   "**/node_modules/**",
@@ -2090,21 +2238,45 @@ function replaceActiveFileMention(input, mention, replacementPath) {
   const mentionText = needsQuotes ? `@"${replacementPath}" ` : `@${replacementPath} `;
   return input.slice(0, mention.start) + mentionText + input.slice(mention.end);
 }
+async function fileSizeBytes(filePath) {
+  try {
+    return (await stat(filePath)).size;
+  } catch {
+    return 0;
+  }
+}
+function withMissingAncestors(entries) {
+  const reported = new Set(entries.filter((entry) => entry.endsWith("/")));
+  const missing = [];
+  for (const entry of entries) {
+    const path = entry.endsWith("/") ? entry.slice(0, -1) : entry;
+    for (let cut = path.lastIndexOf("/"); cut > 0; cut = path.lastIndexOf("/", cut - 1)) {
+      const ancestor = path.slice(0, cut + 1);
+      if (reported.has(ancestor)) break;
+      reported.add(ancestor);
+      missing.push(ancestor);
+    }
+  }
+  return missing.length > 0 ? [...entries, ...missing] : entries;
+}
 async function getFileMentionCandidates(workspace, query, limit = 50, signal) {
   const normalizedQuery = normalizeMentionPath(query).toLowerCase();
   const gitignore = loadGitignore(workspace).patterns;
-  const ignore = [...DEFAULT_IGNORE, ...gitignore];
+  const ignore = globWalkIgnore([...DEFAULT_IGNORE, ...gitignore]);
   let entries;
   try {
-    entries = await fg("**/*", {
-      cwd: workspace,
-      dot: true,
-      onlyFiles: false,
-      unique: true,
-      ignore,
-      objectMode: true,
-      stats: true
-    });
+    entries = withMissingAncestors(
+      await glob("**/*", {
+        cwd: workspace,
+        dot: true,
+        onlyFiles: false,
+        ignore,
+        // A pattern naming a directory returns that directory, not everything inside it — which is
+        // the whole point of walking for mentions.
+        expandDirectories: false,
+        signal
+      })
+    );
   } catch {
     return [];
   }
@@ -2112,7 +2284,8 @@ async function getFileMentionCandidates(workspace, query, limit = 50, signal) {
   const scored = [];
   for (let index = 0; index < entries.length; index++) {
     const entry = entries[index];
-    const display = normalizeMentionPath(entry.path);
+    const isDirectory = entry.endsWith("/");
+    const display = normalizeMentionPath(isDirectory ? entry.slice(0, -1) : entry);
     const lower = display.toLowerCase();
     const base = lower.split("/").pop() ?? lower;
     let score = null;
@@ -2122,11 +2295,10 @@ async function getFileMentionCandidates(workspace, query, limit = 50, signal) {
     else if (base.startsWith(normalizedQuery)) score = 2;
     else if (lower.includes(normalizedQuery)) score = 4;
     if (score !== null) {
-      const kind = entry.dirent.isDirectory() ? "directory" : "file";
       scored.push({
-        path: kind === "directory" ? `${display}/` : display,
-        kind,
-        desc: kind === "directory" ? "directory" : `${entry.stats?.size ?? 0} bytes`,
+        path: isDirectory ? `${display}/` : display,
+        kind: isDirectory ? "directory" : "file",
+        desc: "",
         score
       });
     }
@@ -2138,7 +2310,18 @@ async function getFileMentionCandidates(workspace, query, limit = 50, signal) {
     return a.path.localeCompare(b.path);
   });
   throwIfAborted(signal);
-  return scored.slice(0, limit).map(({ score: _score, ...item }) => item);
+  const listed = scored.slice(0, limit);
+  const sizes = await Promise.all(
+    listed.map(
+      (candidate) => candidate.kind === "directory" ? 0 : fileSizeBytes(resolve2(workspace, candidate.path))
+    )
+  );
+  throwIfAborted(signal);
+  return listed.map(({ score: _score, path, kind }, index) => ({
+    path,
+    kind,
+    desc: kind === "directory" ? "directory" : `${sizes[index]} bytes`
+  }));
 }
 
 // src/session/lifecycle.ts
@@ -2154,7 +2337,14 @@ async function runSessionEnd(config, sessionId, reason, options) {
   await runHooks(
     config.settings.hooks.SessionEnd,
     "SessionEnd",
-    { workspace: config.workspace, event: "SessionEnd", sessionId, reason },
+    {
+      workspace: config.workspace,
+      event: "SessionEnd",
+      sessionId,
+      reason,
+      status: options?.endOutcome?.status,
+      stopReason: options?.endOutcome?.reason
+    },
     options
   );
 }
@@ -2173,11 +2363,76 @@ function splitTrailingPunctuation(token) {
   while (end > 0 && /[.,;:!?)]/.test(token[end - 1])) end--;
   return { path: token.slice(0, end), trailing: token.slice(end) };
 }
-function findMentionTokens(input) {
+function codeRanges(input) {
+  const fenced = fencedCodeRanges(input);
+  const inline = [];
+  let cursor = 0;
+  for (const [start, end] of fenced) {
+    collectParagraphInlineCodeSpans(input.slice(cursor, start), cursor, inline);
+    cursor = end;
+  }
+  collectParagraphInlineCodeSpans(input.slice(cursor), cursor, inline);
+  return [...fenced, ...inline];
+}
+function collectParagraphInlineCodeSpans(segment, base, ranges) {
+  const blankLine = /\n[ \t]*\r?\n/g;
+  let start = 0;
+  let separator;
+  while ((separator = blankLine.exec(segment)) !== null) {
+    collectInlineCodeSpans(segment.slice(start, separator.index), base + start, ranges);
+    start = separator.index + separator[0].length;
+  }
+  collectInlineCodeSpans(segment.slice(start), base + start, ranges);
+}
+function fencedCodeRanges(input) {
+  const ranges = [];
+  let fence = null;
+  let offset = 0;
+  while (offset < input.length) {
+    const newline = input.indexOf("\n", offset);
+    const lineEnd = newline === -1 ? input.length : newline;
+    const rangeEnd = newline === -1 ? input.length : newline + 1;
+    const line = input.slice(offset, lineEnd).replace(/\r$/, "");
+    if (fence) {
+      const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+      if (close && close[1][0] === fence.char && close[1].length >= fence.length) {
+        ranges.push([fence.start, rangeEnd]);
+        fence = null;
+      }
+    } else {
+      const open = /^ {0,3}(?:(`{3,})(?!.*`)|(~{3,}))/.exec(line);
+      if (open) {
+        const run = open[1] ?? open[2];
+        fence = { start: offset, char: run[0], length: run.length };
+      }
+    }
+    offset = rangeEnd;
+  }
+  if (fence) ranges.push([fence.start, input.length]);
+  return ranges;
+}
+function collectInlineCodeSpans(text, base, ranges) {
+  const runs = [...text.matchAll(/`+/g)];
+  for (let i = 0; i < runs.length; i++) {
+    const length = runs[i][0].length;
+    for (let j = i + 1; j < runs.length; j++) {
+      if (runs[j][0].length !== length) continue;
+      ranges.push([base + (runs[i].index ?? 0), base + (runs[j].index ?? 0) + length]);
+      i = j;
+      break;
+    }
+  }
+}
+function isInsideRanges(ranges, index) {
+  return ranges.some(([start, end]) => index >= start && index < end);
+}
+function findMentionTokens(input, excluded = []) {
+  if (!input.includes("@")) return [];
   const tokens = [];
+  const code = codeRanges(input);
   let i = 0;
   while (i < input.length) {
-    if (input[i] !== "@" || !isMentionBoundary2(input, i)) {
+    if (input[i] !== "@" || !isMentionBoundary2(input, i) || isInsideRanges(code, i) || isInsideRanges(excluded, i)) {
       i++;
       continue;
     }
@@ -2235,12 +2490,12 @@ function looksBinary(content) {
 }
 function expandMention(filePath, workspace) {
   const resolved = resolveWorkspaceMentionPath(workspace, filePath);
-  if (!resolved) return formatMentionError(filePath, "path is outside the workspace");
-  if (!existsSync2(resolved.filePath)) return formatMentionError(filePath, "file not found");
+  if (!resolved) return null;
+  if (!existsSync2(resolved.filePath)) return null;
   try {
-    const stat = statSync2(resolved.filePath);
-    if (stat.isDirectory()) return formatMentionError(resolved.relativePath, "path is a directory");
-    if (!stat.isFile())
+    const stat2 = statSync2(resolved.filePath);
+    if (stat2.isDirectory()) return null;
+    if (!stat2.isFile())
       return formatMentionError(resolved.relativePath, "path is not a regular file");
     const content = readFileSync2(resolved.filePath, "utf-8");
     if (looksBinary(content))
@@ -2262,24 +2517,14 @@ ${body}${suffix}
     return formatMentionError(filePath, message.slice(0, 200) || "unable to read file");
   }
 }
-function expandAtMentions(input, workspace) {
-  const tokens = findMentionTokens(input);
-  if (tokens.length === 0) return input;
-  let output = "";
-  let cursor = 0;
-  for (const token of tokens) {
-    output += input.slice(cursor, token.start);
-    output += expandMention(token.path, workspace);
-    output += token.trailing;
-    cursor = token.end + token.trailing.length;
-  }
-  output += input.slice(cursor);
-  return output;
+function mentionTokenRanges(input) {
+  return findMentionTokens(input).map((token) => [token.start, token.end]);
 }
-function collectAtMentionObservations(input, workspace, sourceRef) {
+function collectAtMentionObservations(input, workspace, sourceRef, expandShellInput = false) {
   const workspaceId = workspaceIdentity(workspace);
   const observations = [];
-  for (const token of findMentionTokens(input)) {
+  const shellLines = expandShellInput ? findShellLines(input) : [];
+  for (const token of findMentionTokens(input, shellLineRanges(shellLines))) {
     const resolved = resolveWorkspaceMentionPath(workspace, token.path);
     if (!resolved || !existsSync2(resolved.filePath)) continue;
     try {
@@ -2300,17 +2545,38 @@ function collectAtMentionObservations(input, workspace, sourceRef) {
   }
   return observations;
 }
-async function expandShellCommands(input, workspace, signal) {
-  const matches = [...input.matchAll(/^!(\S.*)$/gm)];
-  if (matches.length === 0) return input;
+function findShellLines(input) {
+  const fenced = fencedCodeRanges(input);
+  return [...input.matchAll(/^!(\S.*)$/gm)].filter((match) => !isInsideRanges(fenced, match.index ?? 0)).map((match) => {
+    const start = match.index ?? 0;
+    return { start, end: start + match[0].length, command: match[1] };
+  });
+}
+function shellLineRanges(lines) {
+  return lines.map((line) => [line.start, line.end]);
+}
+async function expandUserInput(input, workspace, options = {}) {
+  const shellLines = options.expandShell ? findShellLines(input) : [];
+  const tokens = findMentionTokens(input, shellLineRanges(shellLines));
+  if (shellLines.length === 0 && tokens.length === 0) return input;
+  const edits = [
+    ...shellLines.map((line) => ({
+      start: line.start,
+      end: line.end,
+      apply: () => executeShellExpansion(line.command, workspace, options.signal)
+    })),
+    ...tokens.map((token) => ({
+      start: token.start,
+      end: token.end,
+      apply: () => expandMention(token.path, workspace) ?? token.raw
+    }))
+  ].sort((left, right) => left.start - right.start);
   let output = "";
   let cursor = 0;
-  for (const match of matches) {
-    const index = match.index ?? 0;
-    const command = match[1];
-    output += input.slice(cursor, index);
-    output += await executeShellExpansion(command, workspace, signal);
-    cursor = index + match[0].length;
+  for (const edit of edits) {
+    output += input.slice(cursor, edit.start);
+    output += await edit.apply();
+    cursor = edit.end;
   }
   return output + input.slice(cursor);
 }
@@ -2321,6 +2587,9 @@ function executeShellExpansion(command, workspace, signal) {
       {
         cwd: workspace,
         encoding: "utf8",
+        // The `!command` the user typed is theirs, so it must not inherit the NODE_ENV Book
+        // defaulted for its own renderer.
+        env: buildChildEnv(),
         timeout: 1e4,
         maxBuffer: 1024 * 1024,
         signal,
@@ -2411,7 +2680,7 @@ var AgentInteractionController = class {
     this.pendingPermission = null;
     this.pendingPermissionQueue = [];
     this.publish();
-    for (const request of pending) request.resolve("deny");
+    for (const request of pending) request.resolve({ result: "deny", reason: "dismissed" });
     log2.event("permission:cancelled-all", { via, count: pending.length });
     return true;
   }
@@ -2594,21 +2863,13 @@ var AgentSessionOperations = class {
 };
 
 // src/session/agent-session.ts
-function subtractUsage(total, already) {
-  const at = (left, right) => Math.max(0, (left ?? 0) - (right ?? 0));
-  return {
-    promptTokens: at(total.promptTokens, already.promptTokens),
-    completionTokens: at(total.completionTokens, already.completionTokens),
-    totalTokens: at(total.totalTokens, already.totalTokens),
-    cacheReadInputTokens: at(total.cacheReadInputTokens, already.cacheReadInputTokens),
-    cacheCreationInputTokens: at(total.cacheCreationInputTokens, already.cacheCreationInputTokens)
-  };
-}
+var log3 = createDebugLogger("session:usage");
 var AgentSession = class {
   interactions = new AgentInteractionController();
   operations = new AgentSessionOperations();
   runLoop;
   compactRunner;
+  judgeRunner;
   postCompactHooksRunner;
   sessionStartRunner;
   sessionEndRunner;
@@ -2616,12 +2877,27 @@ var AgentSession = class {
   listeners = /* @__PURE__ */ new Set();
   runGeneration = 0;
   lifecycleStartedSessionId;
+  lifecycleStart;
   lifecycleEndedSessionId;
+  lifecycleEnd;
   runtime;
   registryFactory;
+  /**
+   * Every root this session has run, and where its spend is written (#336).
+   *
+   * `onUsage` persists what a run's own responses report, which leaves two
+   * shapes of spend with nowhere to go: whatever a managed child spent after the
+   * root's last response, and a root whose model was never called at all — a
+   * `/review` the host performed. Neither reaches a store on the way out, so the
+   * process ends holding tokens no later process restores, and `--max-budget-usd`
+   * re-authorises them. Registered by `run()` and by hosts that create a root
+   * themselves (`trackRunUsage`), and drained by `dispose`.
+   */
+  usageTargets = /* @__PURE__ */ new Map();
   constructor(dependencies = {}) {
     this.runLoop = dependencies.runLoop ?? runAgentLoop;
     this.compactRunner = dependencies.compactRunner ?? runCompact;
+    this.judgeRunner = dependencies.judgeRunner ?? judgeCompaction;
     this.postCompactHooksRunner = dependencies.postCompactHooksRunner ?? runPostCompactHooks;
     this.sessionStartRunner = dependencies.sessionStartRunner ?? runSessionStart;
     this.sessionEndRunner = dependencies.sessionEndRunner ?? runSessionEnd;
@@ -2766,8 +3042,20 @@ var AgentSession = class {
   getRuntime() {
     return this.runtime;
   }
+  /**
+   * Stop the outgoing runtime, write what it spent, and install its replacement.
+   *
+   * The one place a runtime goes away, so it is where its spend is written: the
+   * children are stopped first, so a managed agent charged during the teardown is
+   * in the figures the flush reads, and its targets are released with it rather
+   * than walked by every later sweep. A `/resume` or `/rewind` that reached the
+   * replacement without this left the outgoing runtime's unpersisted spend behind
+   * with it, and the resumed session restored a carry short of what it had cost.
+   */
   replaceRuntime(options = {}, via = "session_transition") {
-    this.runtime.dispose(via);
+    const outgoing = this.runtime;
+    outgoing.dispose(via);
+    this.releaseRunUsage(outgoing);
     this.runtime = new SessionRuntime(options);
     return this.runtime;
   }
@@ -2793,16 +3081,165 @@ var AgentSession = class {
     this.operations.reset({ bookTerminalReason: "session_disposed" });
     this.runGeneration++;
     this.runtime.dispose(via);
+    this.releaseRunUsage(this.runtime);
+  }
+  /**
+   * Record that `rootRunId`'s spend belongs in `target`, so the flush at the end
+   * of the session can persist what no response of that root reported.
+   *
+   * `run()` registers every root it runs. A host that starts a root itself and
+   * never sends a turn — a print-mode `/review`, whose reviewer agents spend
+   * under a root the root model is never asked for — registers it here, or its
+   * spend leaves the process with it. Re-registering a root replaces the target,
+   * so a run under an existing root keeps writing to where that root writes.
+   */
+  trackRunUsage(rootRunId, target) {
+    this.usageTargets.set(rootRunId, { target, runtime: this.runtime });
+  }
+  /**
+   * Register a compaction's root the way `run` registers a turn's.
+   *
+   * A compactor's model calls are charged to a run context, and no turn of that
+   * root may ever run — a manual `/compact` mints a root of its own, and a send
+   * cancelled between the host's auto-compact in `beforePrepare` and `run()`
+   * never reaches `run`'s own registration. Without this, that spend is charged
+   * to a root no flush knows about, and leaves the process unwritten.
+   */
+  registerUsageTarget(request, runtime) {
+    if (!request.runContext || !request.timelineStore || !request.sessionId) return;
+    this.usageTargets.set(request.runContext.rootRunId, {
+      target: { sessionId: request.sessionId, timelineStore: request.timelineStore },
+      runtime
+    });
+  }
+  /**
+   * Write what a root has spent and no `usage` record covers, as one record
+   * named after the response the host is being told about.
+   *
+   * The `onUsage` writer, and the reason it is one function rather than a
+   * closure: every host reaches it the same way, so the watermark it moves and
+   * the ones `flushRunUsage` moves are the same figure, written once. Cost is
+   * not stored — pricing changes between processes, so it is re-derived from the
+   * tokens at bootstrap, deliberately at the most expensive model involved.
+   *
+   * The watermark moves only where a record really lands. A turn that reaches no
+   * store — a session that moved on, a run with nowhere to write — leaves its
+   * spend unpersisted instead, for the next writer under this root to record;
+   * counted as written, no record would ever hold it and no restart would
+   * restore it.
+   */
+  persistReportedUsage(rootRunId, reported, metadata) {
+    const entry = this.usageTargets.get(rootRunId);
+    if (!entry) return;
+    const { target, runtime } = entry;
+    const recordUsage = runtime.runAccounting.peekUnpersistedUsage(rootRunId) ?? reported;
+    if (isSpendlessUsage(recordUsage)) return;
+    const store = target.isCurrent?.() === false ? void 0 : target.timelineStore;
+    if (!store) return;
+    store.append(target.sessionId, {
+      type: "usage",
+      timestamp: Date.now(),
+      data: {
+        version: 1,
+        usage: recordUsage,
+        // The response that triggered this write, which is not the same thing as
+        // the models the delta covers: a dearer child may have finished before it.
+        requestedModel: metadata?.requestedModel,
+        responseModel: metadata?.responseModel,
+        models: runtime.runAccounting.modelsFor(rootRunId)
+      }
+    });
+    runtime.runAccounting.commitPersistedUsage(rootRunId);
+  }
+  /**
+   * Write what a root has spent and no `usage` record covers, if it can be
+   * written at all.
+   *
+   * One record for the whole delta, so what this writes and what it then commits
+   * are the same figure by construction. It is named after the dearest model the
+   * root has spent on rather than after any one of them: `carriedCostUsd`
+   * (`headless.ts`) prices a restored carry at the most expensive model in
+   * `carriedModels` regardless of which record said what, and the records do not
+   * attribute tokens to models, so one name is all the restored pool can be said
+   * to have cost.
+   *
+   * `requireCurrent` is the end of a run, where the target's own currency still
+   * decides whether it is the session to write to. The end-of-session sweep does
+   * not pass it: by then every operation lease has been released, so consulting
+   * one would skip every target the TUI ever registered — which is where a
+   * background agent's late spend goes.
+   *
+   * A store that throws is contained here. This runs from a run's `finally` and
+   * from the runtime swap, so an escaping filesystem error would replace a
+   * completed run's outcome, abort the sweep part-way, and leave the session
+   * installed on a disposed runtime. Nothing was written, so the watermark stays
+   * where it was and the spend remains owed to the next writer that can.
+   */
+  flushRunUsage(rootRunId, requireCurrent) {
+    const entry = this.usageTargets.get(rootRunId);
+    if (!entry) return;
+    const { target, runtime } = entry;
+    const recordUsage = runtime.runAccounting.peekUnpersistedUsage(rootRunId);
+    if (!recordUsage || isSpendlessUsage(recordUsage)) return;
+    const store = requireCurrent && target.isCurrent?.() === false ? void 0 : target.timelineStore;
+    if (!store) return;
+    try {
+      store.append(target.sessionId, {
+        type: "usage",
+        timestamp: Date.now(),
+        data: {
+          version: 1,
+          usage: recordUsage,
+          requestedModel: runtime.runAccounting.dearestModel(rootRunId),
+          models: runtime.runAccounting.modelsFor(rootRunId)
+        }
+      });
+      runtime.runAccounting.commitPersistedUsage(rootRunId);
+    } catch (error) {
+      log3.warn("usage record could not be appended; spend left unpersisted", {
+        rootRunId,
+        sessionId: target.sessionId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Write what the roots of a runtime that is going away spent, and drop their
+   * targets: nothing can be charged to a root whose runtime is gone, so keeping
+   * its target would only make every later sweep walk it.
+   *
+   * Whatever lease a target carries is ignored — a `send()` lease has been
+   * released by the time any of these runs, so consulting one would skip every
+   * target the TUI ever made.
+   */
+  releaseRunUsage(runtime) {
+    for (const [rootRunId, entry] of [...this.usageTargets.entries()]) {
+      if (entry.runtime !== runtime) continue;
+      this.flushRunUsage(rootRunId, false);
+      this.usageTargets.delete(rootRunId);
+    }
   }
   async startLifecycle(config, sessionId, source, options) {
-    if (this.lifecycleStartedSessionId === sessionId) return;
+    if (this.lifecycleStartedSessionId === sessionId) {
+      await this.lifecycleStart?.catch(() => void 0);
+      return;
+    }
     this.lifecycleStartedSessionId = sessionId;
-    await this.sessionStartRunner(config, sessionId, source, options);
+    this.lifecycleStart = this.sessionStartRunner(config, sessionId, source, options);
+    await this.lifecycleStart;
   }
+  // A second call for a session that is already ending waits for the SessionEnd in flight
+  // instead of returning at once, which let a second exit or a `/clear` racing an exit move on
+  // while the hooks were still running. The first caller reports a failed SessionEnd; a caller that
+  // only waited for it does not report the same failure a second time.
   async endLifecycle(config, sessionId, reason, options) {
-    if (this.lifecycleEndedSessionId === sessionId) return;
+    if (this.lifecycleEndedSessionId === sessionId) {
+      await this.lifecycleEnd?.catch(() => void 0);
+      return;
+    }
     this.lifecycleEndedSessionId = sessionId;
-    await this.sessionEndRunner(config, sessionId, reason, options);
+    this.lifecycleEnd = this.sessionEndRunner(config, sessionId, reason, options);
+    await this.lifecycleEnd;
   }
   async clearSession(request) {
     request.onTransitionStart?.();
@@ -2811,9 +3248,19 @@ var AgentSession = class {
     if (request.previousName && request.store) {
       request.store.patchMeta(request.currentSessionId, { name: request.previousName });
     }
-    const sessionId = request.store ? request.store.create({ cwd: request.config.workspace }) : request.timelineStore?.create({ cwd: request.config.workspace }) ?? crypto.randomUUID();
+    const sessionId = request.store ? request.store.create({
+      cwd: request.config.workspace,
+      driver: request.config.sessionDriver
+    }) : request.timelineStore?.create({
+      cwd: request.config.workspace,
+      driver: request.config.sessionDriver
+    }) ?? crypto.randomUUID();
     if (request.store && request.timelineStore && request.timelineStore !== request.store) {
-      request.timelineStore.create({ id: sessionId, cwd: request.config.workspace });
+      request.timelineStore.create({
+        id: sessionId,
+        cwd: request.config.workspace,
+        driver: request.config.sessionDriver
+      });
     }
     const bootstrap = emptySessionBootstrap(
       sessionId,
@@ -2839,6 +3286,12 @@ var AgentSession = class {
     this.operations.cancel({ bookTerminalReason: "session_replaced" });
     await this.endLifecycle(request.config, request.currentSessionId, "resume");
     request.store.touch(selected.id);
+    recordResumeDriver(
+      request.store,
+      selected.id,
+      loaded.meta.driver,
+      request.config.sessionDriver
+    );
     const bootstrap = {
       sessionId: selected.id,
       sessionName: loaded.meta.name,
@@ -2857,6 +3310,7 @@ var AgentSession = class {
       created: false
     };
     this.reset("session-resume");
+    this.replaceRuntime({ history: bootstrap.transcript ?? bootstrap.history }, "session-resume");
     request.onTransition?.(bootstrap);
     await this.startLifecycle(request.config, selected.id, "resume");
     return { status: "transitioned", bootstrap };
@@ -2903,13 +3357,17 @@ var AgentSession = class {
     return { status: "prepared", contextMessage, rewindTarget, sessionName };
   }
   async recordUserMessage(request) {
-    const expandedMentions = request.contextMessage === void 0 ? expandAtMentions(request.displayMessage, request.config.workspace) : request.contextMessage;
-    const contextMessage = request.contextMessage !== void 0 || request.expandShellInput === false ? expandedMentions : await expandShellCommands(expandedMentions, request.config.workspace, request.signal);
+    const expandShellInput = request.contextMessage === void 0 && request.expandShellInput !== false;
+    const contextMessage = request.contextMessage !== void 0 ? request.contextMessage : await expandUserInput(request.displayMessage, request.config.workspace, {
+      expandShell: expandShellInput,
+      signal: request.signal
+    });
     request.userMessage.contextContent = contextMessage === request.displayMessage ? void 0 : contextMessage;
     request.userMessage.fileObservations = request.contextMessage === void 0 ? collectAtMentionObservations(
       request.displayMessage,
       request.config.workspace,
-      request.userMessage.id
+      request.userMessage.id,
+      expandShellInput
     ) : [];
     const observationLedger = (request.runtime ?? this.runtime).fileObservationLedger;
     for (const observation of request.userMessage.fileObservations) {
@@ -2943,29 +3401,125 @@ var AgentSession = class {
   async compact(request) {
     const runtime = request.runtime ?? this.runtime;
     if (request.runContext) runtime.runAccounting.startRoot(request.runContext);
+    this.registerUsageTarget(request, runtime);
     const result = await this.compactRunner(request.config, request.history, {
-      ...request.options,
-      sessionId: request.sessionId,
-      beforeModelCall: request.runContext ? (model) => {
-        const requestCheck = request.options.beforeModelCall?.(model);
-        if (requestCheck && !requestCheck.allowed) return requestCheck;
-        return runtime.runAccounting.checkBeforeModelCall(request.runContext.rootRunId, model);
-      } : request.options.beforeModelCall,
-      onUsage: request.runContext ? (usage, metadata) => {
-        runtime.runAccounting.record(request.runContext, usage, metadata);
-        request.options.onUsage?.(usage, metadata);
-      } : request.options.onUsage,
-      onUsageMissing: request.runContext ? (metadata) => {
-        runtime.runAccounting.markUsageUnknown(
-          request.runContext,
-          metadata,
-          "compaction_usage"
-        );
-        request.options.onUsageMissing?.(metadata);
-      } : request.options.onUsageMissing
+      ...this.accountedOptions(request.options, request.runContext, runtime, request.onUsage),
+      sessionId: request.sessionId
+    });
+    if (result.status !== "compacted") return { result };
+    if (request.isCurrent?.() === false) return { result };
+    return this.commitCompactResult(result, request);
+  }
+  /**
+   * Deferred compaction (`plans/async-compaction-plan.md`): the reducer half of
+   * `compact`, on a snapshot, without the record, the boundary or the
+   * PostCompact hooks. PreCompact hooks still run -- they are the refusal
+   * point, and the suspect-input scan they see is the snapshot's.
+   */
+  async prepareCompact(request) {
+    const runtime = request.runtime ?? this.runtime;
+    if (request.runContext) runtime.runAccounting.startRoot(request.runContext);
+    this.registerUsageTarget(request, runtime);
+    const result = await this.compactRunner(request.config, request.history, {
+      ...this.accountedOptions(request.options, request.runContext, runtime, request.onUsage),
+      sessionId: request.sessionId
     });
+    if (result.status !== "compacted") return { status: result.status, result };
+    return {
+      status: "prepared",
+      prepared: {
+        snapshot: [...request.history],
+        result,
+        trigger: request.options.trigger,
+        preContextTokens: request.options.preContextTokens
+      }
+    };
+  }
+  /**
+   * The other half: apply a prepared compaction to the history as it stands,
+   * ask the judge whether the checkpoint holds what the steps taken meanwhile
+   * relied on, and only then write the record and run the hooks. A rejected
+   * or inapplicable checkpoint is dropped, and the caller falls back to a
+   * synchronous compaction.
+   */
+  async commitCompact(request) {
+    const runtime = request.runtime ?? this.runtime;
+    const { prepared } = request;
+    const applied = applyCompactResult(prepared.result, prepared.snapshot, request.history, {
+      toolResultMaxTokens: resolveCompactBudgets(request.config).retainedToolResultMaxTokens
+    });
+    if (!applied) {
+      return {
+        result: {
+          status: "skipped",
+          reason: "not-applicable",
+          message: "The history no longer extends the snapshot the reducer read."
+        }
+      };
+    }
+    const snapshotIds = new Set(prepared.snapshot.map((message) => message.id));
+    const delta = request.history.filter((message) => !snapshotIds.has(message.id));
+    if (request.runContext) runtime.runAccounting.startRoot(request.runContext);
+    this.registerUsageTarget(request, runtime);
+    const accounted = this.accountedOptions(
+      { ...request.options, trigger: prepared.trigger },
+      request.runContext,
+      runtime,
+      request.onUsage
+    );
+    const judge = await this.judgeRunner(request.config, applied, delta, {
+      signal: accounted.signal,
+      provider: accounted.provider,
+      beforeModelCall: accounted.beforeModelCall,
+      onUsage: accounted.onUsage,
+      onUsageMissing: accounted.onUsageMissing
+    });
+    if (accounted.signal?.aborted || judge.note === "aborted") {
+      return { result: { status: "failed", reason: "aborted", error: "Compaction aborted." } };
+    }
+    const result = judgedResult(applied, judge);
     if (result.status !== "compacted") return { result };
     if (request.isCurrent?.() === false) return { result };
+    return this.commitCompactResult(result, {
+      config: request.config,
+      history: request.history,
+      sessionId: request.sessionId,
+      transcriptOrdinal: request.transcriptOrdinal,
+      options: { ...request.options, trigger: prepared.trigger },
+      runContext: request.runContext,
+      runtime,
+      timelineStore: request.timelineStore,
+      isCurrent: request.isCurrent,
+      onCommitted: request.onCommitted
+    });
+  }
+  /**
+   * The compactor's model calls charged to the run, the way `compact` has always charged
+   * them, and reported to the host's own session bill when it keeps one (#370).
+   */
+  accountedOptions(options, runContext, runtime, onUsage) {
+    return {
+      ...options,
+      beforeModelCall: runContext ? (model) => {
+        const requestCheck = options.beforeModelCall?.(model);
+        if (requestCheck && !requestCheck.allowed) return requestCheck;
+        return runtime.runAccounting.checkBeforeModelCall(runContext.rootRunId, model);
+      } : options.beforeModelCall,
+      // Left exactly as it was when there is nothing to chain: a compaction with
+      // no run context and no host callback hands the runner its own options back.
+      onUsage: runContext || onUsage ? (usage, metadata) => {
+        if (runContext) runtime.runAccounting.record(runContext, usage, metadata);
+        options.onUsage?.(usage, metadata);
+        onUsage?.(usage);
+      } : options.onUsage,
+      onUsageMissing: runContext ? (metadata) => {
+        runtime.runAccounting.markUsageUnknown(runContext, metadata, "compaction_usage");
+        options.onUsageMissing?.(metadata);
+      } : options.onUsageMissing
+    };
+  }
+  /** The record, the boundary, `onCommitted` and the PostCompact hooks for a compacted result. */
+  async commitCompactResult(result, request) {
     const timestamp = Date.now();
     const boundary = {
       id: result.compactId,
@@ -2977,7 +3531,8 @@ var AgentSession = class {
       postContextTokens: result.postContextTokens,
       generation: result.generation,
       checkpointVersion: 2,
-      timestamp
+      timestamp,
+      carriedCount: result.carriedCount
     };
     const data = {
       version: 2,
@@ -2994,10 +3549,12 @@ var AgentSession = class {
       throughEventRef: result.throughEventRef,
       summarizedCount: result.summarizedCount,
       retainedCount: result.retainedCount,
+      carriedCount: result.carriedCount,
       strategy: result.strategy,
       modelCalls: result.modelCalls,
       degraded: result.degraded,
-      warning: result.warning
+      warning: result.warning,
+      ...result.judge ? { judge: result.judge } : {}
     };
     if (request.timelineStore && request.sessionId) {
       request.timelineStore.append(request.sessionId, {
@@ -3012,8 +3569,7 @@ var AgentSession = class {
       trigger: result.trigger,
       sessionId: request.sessionId,
       focus: request.options.focus,
-      onHookEvent: request.options.onHookEvent,
-      signal: request.options.signal
+      onHookEvent: request.options.onHookEvent
     });
     return { result, boundary };
   }
@@ -3049,6 +3605,14 @@ var AgentSession = class {
         allowedTools: request.options?.allowedTools
       })
     );
+    this.usageTargets.set(runContext.rootRunId, {
+      target: {
+        sessionId: request.sessionId,
+        timelineStore: request.timelineStore,
+        isCurrent: request.isCurrent
+      },
+      runtime
+    });
     const finalizeOutcome = (outcome) => {
       if (!terminalOutcome) {
         terminalOutcome = outcome;
@@ -3066,13 +3630,6 @@ var AgentSession = class {
     emit({ type: "session", sessionId: request.sessionId });
     const unsubscribeShellEvents = runtime.shellManager.subscribe((event) => emit(event));
     try {
-      let persistedUsage = {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
-        cacheReadInputTokens: 0,
-        cacheCreationInputTokens: 0
-      };
       let lastPlanSignature = "";
       const persistPlan = () => {
         if (!request.timelineStore) return;
@@ -3106,6 +3663,7 @@ var AgentSession = class {
         },
         onToolCall: (toolCall) => emit({ type: "tool_use", toolCall }),
         onToolResult: (toolResult) => emit({ type: "tool_result", toolResult }),
+        onNotice: (message) => emit({ type: "notice", message }),
         onError: (error) => {
           emittedError = error;
           emit({ type: "error", error });
@@ -3117,7 +3675,9 @@ var AgentSession = class {
           finalizeOutcome(outcome2);
         },
         onPermissionRequired: (toolCall) => {
-          if (request.isCurrent?.() === false) return Promise.resolve("deny");
+          if (request.isCurrent?.() === false) {
+            return Promise.resolve({ result: "deny", reason: "dismissed" });
+          }
           return callbacks.onPermissionRequired ? callbacks.onPermissionRequired(toolCall) : this.interactions.requestPermission(toolCall);
         },
         onPlanApprovalRequired: (plan) => {
@@ -3139,32 +3699,21 @@ var AgentSession = class {
         },
         onUsage: (nextUsage, metadata) => {
           usage = nextUsage;
-          const inclusive = request.runContext ? runtime.runAccounting.snapshotRoot(request.runContext.rootRunId).inclusiveUsage : null;
-          const recordUsage = inclusive ? subtractUsage(inclusive, persistedUsage) : nextUsage;
-          if (inclusive) persistedUsage = inclusive;
-          if (recordUsage.totalTokens <= 0 && recordUsage.promptTokens <= 0) return;
-          if (request.isCurrent?.() !== false) {
-            request.timelineStore?.append(request.sessionId, {
-              type: "usage",
-              timestamp: Date.now(),
-              data: {
-                version: 1,
-                usage: recordUsage,
-                requestedModel: metadata?.requestedModel,
-                responseModel: metadata?.responseModel
-              }
-            });
-          }
+          this.persistReportedUsage(runContext.rootRunId, nextUsage, metadata);
           callbacks.onUsage?.(nextUsage, metadata);
         },
         getMode: callbacks.getMode,
         onModeChange: callbacks.onModeChange,
+        // The root run's only: a managed child and a Task subagent run the loop
+        // with their own callbacks, and neither announces calls to a stream the
+        // host is reading for them.
+        beforeToolExecution: callbacks.beforeToolExecution,
         onPlanHandoff: callbacks.onPlanHandoff,
-        // Kept under Zero-Mem: `loopConfig` already sets `autoCompactEnabled:
-        // false`, which gates the loop's two routine compaction paths, and the
-        // context-overflow path at the bottom of the turn is deliberately not
-        // gated by it. Nulling the callback disabled that recovery too.
+        // Passed through as is: the loop gates every compaction site on
+        // `autoCompactEnabled`, the context-overflow recovery included.
         onCompact: callbacks.onCompact,
+        prepareCompact: callbacks.prepareCompact,
+        commitCompact: callbacks.commitCompact,
         onAssistantMessageComplete: (message) => {
           if (request.isCurrent?.() === false) return;
           request.timelineStore?.append(request.sessionId, {
@@ -3180,7 +3729,10 @@ var AgentSession = class {
               kind: message.kind ?? "conversation",
               toolCalls: message.toolCalls,
               toolResults: message.toolResults,
-              fileObservations: message.fileObservations
+              fileObservations: message.fileObservations,
+              // Without this a resumed session reads a host notice as the model's
+              // own reply: `finalAnswerText` and the answer walk both key on it.
+              hostNotice: message.hostNotice
             }
           });
           callbacks.onAssistantMessageComplete?.(message);
@@ -3213,7 +3765,10 @@ var AgentSession = class {
               id: message.id,
               content: message.content,
               kind: message.kind ?? "conversation",
-              includeInContext: message.includeInContext ?? true
+              includeInContext: message.includeInContext ?? true,
+              // A host-appended prompt stays host-written across a reload: the ledger,
+              // Carried Turns and memory extraction all key on it.
+              derivedContent: message.derivedContent
             }
           });
         },
@@ -3224,21 +3779,26 @@ var AgentSession = class {
         onHookEvent: callbacks.onHookEvent,
         onAgentEvent: (event) => emit(event)
       };
-      const messages = await this.runLoop(
-        request.config,
-        request.registry,
-        request.prompt,
-        effectiveHistory,
-        baseLoopCallbacks,
-        request.mode,
-        {
-          ...request.options,
-          runtime,
-          runContext,
-          resolveAttachment: request.options?.resolveAttachment ?? (request.timelineStore?.readImageAttachment ? (attachment) => request.timelineStore.readImageAttachment(request.sessionId, attachment) : void 0),
-          signal: request.signal
-        }
-      );
+      let messages;
+      try {
+        messages = await this.runLoop(
+          request.config,
+          request.registry,
+          request.prompt,
+          effectiveHistory,
+          baseLoopCallbacks,
+          request.mode,
+          {
+            ...request.options,
+            runtime,
+            runContext,
+            resolveAttachment: request.options?.resolveAttachment ?? (request.timelineStore?.readImageAttachment ? (attachment) => request.timelineStore.readImageAttachment(request.sessionId, attachment) : void 0),
+            signal: request.signal
+          }
+        );
+      } finally {
+        this.flushRunUsage(runContext.rootRunId, true);
+      }
       const partialOutput = streamedAssistantText.length > 0 || messages.slice(effectiveHistory.length).some((message) => message.role === "assistant");
       const outcome = finalizeOutcome(
         terminalOutcome ?? (request.signal?.aborted ? classifyAbortReason(request.signal.reason, partialOutput) : emittedError ? createTerminalOutcome("failed", "provider_error", {
@@ -3481,16 +4041,21 @@ function validateElicitationContent(fields, content) {
 }
 
 export {
+  parseSessionDriver,
+  resolveSessionDriver,
   displaySessionName,
   normalizeWorkspace,
   SessionStore,
   reviewRunnerFor,
   fixRunnerFor,
+  extractJsonObject,
+  parseJsonObject,
   runHostReview,
   reviewReportJson,
   findActiveFileMention,
   replaceActiveFileMention,
   getFileMentionCandidates,
+  mentionTokenRanges,
   createAgentSessionSnapshot,
   reduceAgentSessionSnapshot,
   resolveSessionBootstrap,
@@ -3501,4 +4066,4 @@ export {
   coerceElicitationValue,
   validateElicitationContent
 };
-//# sourceMappingURL=chunk-V4BOYR52.js.map
+//# sourceMappingURL=chunk-RFJ6Q6LE.js.map