@letrquan/book 0.2.0 → 0.4.0-beta.0

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

@@ -5,46 +5,107 @@ import {
   createAgentRunContext,
   createRunAmbientSnapshot,
   createTerminalOutcome,
+  isSpendlessUsage,
   isTerminalStatus,
   loadGitignore,
   runAgentLoop,
-  runCompact,
-  runHooks,
-  runPostCompactHooks
-} from "./chunk-XIFFTATU.js";
+  seedShellIds
+} from "./chunk-KDNWMKXV.js";
 import {
   DEFAULT_CONFIDENCE_THRESHOLD,
   REVIEW_LENSES,
+  addUsage,
+  applyCompactResult,
   buildReviewerPrompt,
   buildSingleReviewPrompt,
   clampConfidence,
+  createGoal,
   isReviewCategory,
   isReviewSeverity,
+  judgeCompaction,
+  judgedResult,
   loadReviewConfig,
   renderReviewConfigInstruction,
   renderReviewTarget,
-  resolveReviewTarget
-} from "./chunk-A7JLBK2Y.js";
+  resolveCompactBudgets,
+  resolveReviewTarget,
+  restoreGoal,
+  runCompact,
+  runHooks,
+  runPostCompactHooks
+} from "./chunk-FPR7SKIE.js";
 import {
+  observationKey,
+  observationPathFor,
   onAbort,
   throwIfAborted,
+  workspaceIdentity,
   yieldToEventLoop
-} from "./chunk-MAQXCUR4.js";
+} from "./chunk-N2G4Q7ME.js";
 import {
-  normalizeToolResult,
-  observationKey,
-  workspaceIdentity
-} from "./chunk-5GDZ22YP.js";
+  globWalkIgnore
+} from "./chunk-XJRJVXJR.js";
+import {
+  defaultGitRunner,
+  describeMissingObjects,
+  hardenedGitArgs,
+  noFetchGitEnv,
+  readRepositoryGitConfig
+} from "./chunk-32WBCUAN.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import {
+  findRepositoryRoot,
+  tryRealPath
+} from "./chunk-SBTU5BEC.js";
+import {
+  resolveAdditionalRoots
+} from "./chunk-4DKHLZRI.js";
 import {
   createDebugLogger,
   createDebugLoggerWithCounter
-} from "./chunk-GTVB4HEM.js";
+} from "./chunk-OJBMDM5H.js";
+import {
+  isOutside,
+  normalizeToolResult,
+  resolveMentionReadablePath
+} from "./chunk-YIL6HTJX.js";
+import {
+  createUncGuard,
+  reachesUncPath,
+  uncGuardedWalkFs
+} from "./chunk-EEX6QNXV.js";
+import {
+  renderUntrustedText
+} from "./chunk-WV3O5PGX.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";
 var MAX_SESSION_NAME_LENGTH = 56;
 function deriveSessionName(prompt) {
-  const normalized = prompt.replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim().replace(/^[/!#>*_`~-]+\s*/, "").replace(/[.!?,;:]+$/, "").trim();
+  const normalized = prompt.replace(/^\s*`{3,}[^\n`]*\r?\n/, "").replace(/^[ \t]*`{3,}[\w+-]*[ \t\r]*$/gm, "").replace(/\r?\n/g, " ").replace(/\s+/g, " ").trim().replace(/^[/!#>*_~-]+\s*/, "").replace(/[.!?,;:]+$/, "").trim();
   if (!normalized) return UNTITLED_SESSION_NAME;
   const titled = normalized.replace(/^[a-z]/, (letter) => letter.toUpperCase());
   if (Array.from(titled).length <= MAX_SESSION_NAME_LENGTH) return titled;
@@ -85,6 +146,7 @@ var READ_REF_LIMIT = 8;
 var READ_TOTAL_CHARS = 16e3;
 var TOOL_RESULT_PREVIEW_CHARS = 4e3;
 var SESSION_INDEX_FILE = "session-index.json";
+var HEADER_PROBE_BYTES = 16 * 1024;
 var JSONL_READ_BUFFER_BYTES = 64 * 1024;
 var IMAGE_STORAGE_KEY = /^[a-f0-9]{64}\.(?:png|jpg|gif|webp)$/;
 function imageSessionDirectory(root, sessionId) {
@@ -173,30 +235,37 @@ var SessionStore = class {
   }
   persistIndex(deletedIds = [], changedIds) {
     if (this.buildingIndex) return;
+    this.withIndexLock(() => this.writeIndexLocked(deletedIds, changedIds));
+  }
+  withIndexLock(action) {
     const lock = this.acquireIndexLock();
     try {
-      const sessions = this.readPersistedIndexEntries();
-      const ids = changedIds ?? Array.from(this.metadataIndex.keys());
-      for (const id of ids) {
-        const entry = this.metadataIndex.get(id);
-        if (entry) sessions[id] = entry;
-      }
-      for (const id of deletedIds) delete sessions[id];
-      const target = this.indexPath();
-      const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
-      try {
-        writeFileSync(temporary, JSON.stringify({ version: 1, sessions }), "utf-8");
-        renameSync(temporary, target);
-        this.indexMtimeMs = statSync(target).mtimeMs;
-        this.metadataIndex.clear();
-        for (const [id, entry] of Object.entries(sessions)) this.metadataIndex.set(id, entry);
-      } finally {
-        if (existsSync(temporary)) unlinkSync(temporary);
-      }
+      return action();
     } finally {
       this.releaseIndexLock(lock);
     }
   }
+  /** The index write itself; the caller holds the index lock. */
+  writeIndexLocked(deletedIds, changedIds) {
+    const sessions = this.readPersistedIndexEntries();
+    const ids = changedIds ?? Array.from(this.metadataIndex.keys());
+    for (const id of ids) {
+      const entry = this.metadataIndex.get(id);
+      if (entry) sessions[id] = entry;
+    }
+    for (const id of deletedIds) delete sessions[id];
+    const target = this.indexPath();
+    const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporary, JSON.stringify({ version: 1, sessions }), "utf-8");
+      renameSync(temporary, target);
+      this.indexMtimeMs = statSync(target).mtimeMs;
+      this.metadataIndex.clear();
+      for (const [id, entry] of Object.entries(sessions)) this.metadataIndex.set(id, entry);
+    } finally {
+      if (existsSync(temporary)) unlinkSync(temporary);
+    }
+  }
   acquireIndexLock() {
     const path = `${this.indexPath()}.lock`;
     for (let attempt = 0; attempt < 50; attempt++) {
@@ -274,7 +343,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 +356,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,12 +370,12 @@ 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 = [];
+    const records2 = [];
     const descriptor = openSync(p, "r");
     const buffer = Buffer.allocUnsafe(JSONL_READ_BUFFER_BYTES);
     const decoder = new StringDecoder("utf8");
@@ -315,7 +385,7 @@ var SessionStore = class {
       lineNumber++;
       if (!line) return;
       try {
-        records.push(JSON.parse(line));
+        records2.push(JSON.parse(line));
       } catch {
         log.warn("ignoring corrupt session record", { id, line: lineNumber });
       }
@@ -337,11 +407,11 @@ var SessionStore = class {
       closeSync(descriptor);
     }
     this.parsedSessions.set(id, {
-      size: stat.size,
-      mtimeMs: stat.mtimeMs,
-      records
+      size: stat2.size,
+      mtimeMs: stat2.mtimeMs,
+      records: records2
     });
-    return records;
+    return records2;
   }
   updateIndexAfterAppend(id, record) {
     const entry = this.metadataIndex.get(id);
@@ -356,10 +426,15 @@ 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";
-      if (!entry.meta.name && data.content) entry.meta.name = deriveSessionName(data.content);
+      if (!entry.meta.name && data.content && data.kind !== "agent-notification") {
+        entry.meta.name = deriveSessionName(data.content);
+      }
     } else if (record.type === "local") {
       entry.meta.messageCount++;
       entry.lastMessageRole = "assistant";
@@ -393,10 +468,10 @@ var SessionStore = class {
     });
   }
   load(id) {
-    const records = this.readRecords(id);
+    const records2 = this.readRecords(id);
     const parsedCache = this.parsedSessions.get(id);
     if (parsedCache?.loaded) return cloneLoadedSession(parsedCache.loaded);
-    const metaRec = records.find(
+    const metaRec = records2.find(
       (record) => record.data?.kind === "session_meta"
     );
     const storedMeta = metaRec?.data;
@@ -406,7 +481,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 = [];
@@ -418,30 +494,28 @@ var SessionStore = class {
     const checkpointByUserEventId = /* @__PURE__ */ new Map();
     const snapshotIds = /* @__PURE__ */ new Set();
     let latestPlan;
+    let latestGoal;
     let carriedUsage;
     const carriedModels = /* @__PURE__ */ new Set();
     let count = 0;
-    for (let lineIndex = 0; lineIndex < records.length; lineIndex++) {
-      const record = records[lineIndex];
+    for (let lineIndex = 0; lineIndex < records2.length; lineIndex++) {
+      const record = records2[lineIndex];
       const eventId = record.eventId ?? `legacy-line-${lineIndex + 1}`;
       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;
       }
@@ -450,6 +524,11 @@ var SessionStore = class {
         if (plan?.version === 1) latestPlan = plan;
         continue;
       }
+      if (record.type === "goal") {
+        const goal = record.data;
+        if (goal?.version === 1) latestGoal = goal;
+        continue;
+      }
       if (record.type === "turn_checkpoint") {
         const checkpoint = record.data;
         if (checkpoint?.version !== 1 || !checkpoint.checkpointId || !checkpoint.userEventId || typeof checkpoint.prompt !== "string") {
@@ -460,6 +539,7 @@ var SessionStore = class {
           id: checkpoint.checkpointId,
           userEventId: checkpoint.userEventId,
           prompt: checkpoint.prompt,
+          ...checkpoint.promptTyped === true ? { promptTyped: true } : {},
           attachments: checkpoint.attachments,
           timestamp: record.timestamp,
           ...checkpoint.checkpoint,
@@ -601,6 +681,7 @@ var SessionStore = class {
             toolCalls: data.toolCalls,
             toolResults: normalizePersistedToolResults(data.toolResults),
             fileObservations: data.fileObservations,
+            hostNotice: data.hostNotice,
             timestamp: record.timestamp
           };
           transcript.push(message);
@@ -639,11 +720,11 @@ var SessionStore = class {
         }
       }
     }
-    if (records.length) meta.updatedAt = records[records.length - 1].timestamp;
+    if (records2.length) meta.updatedAt = records2[records2.length - 1].timestamp;
     meta.messageCount = count;
     if (!meta.name) {
       const firstUserPrompt = transcript.find(
-        (message) => message.role === "user" && message.kind !== "local"
+        (message) => message.role === "user" && message.kind !== "local" && message.kind !== "agent-notification"
       )?.content;
       if (firstUserPrompt) meta.name = deriveSessionName(firstUserPrompt);
     }
@@ -658,6 +739,7 @@ var SessionStore = class {
       activeEventIds,
       meta,
       plan: latestPlan,
+      goal: latestGoal,
       carriedUsage,
       carriedModels: [...carriedModels],
       history: contextHistory
@@ -780,9 +862,9 @@ var SessionStore = class {
   activeRecordMap(id) {
     const cache = this.parsedSessions.get(id);
     if (cache?.recordsByActiveId) return cache.recordsByActiveId;
-    const records = this.activeRecordIndex(id);
+    const records2 = this.activeRecordIndex(id);
     const refreshed = this.parsedSessions.get(id);
-    const byId = new Map(records.map((record) => [record.eventId, record]));
+    const byId = new Map(records2.map((record) => [record.eventId, record]));
     if (refreshed) refreshed.recordsByActiveId = byId;
     return byId;
   }
@@ -805,9 +887,15 @@ var SessionStore = class {
     }
     return references;
   }
-  mostRecentInCwd(cwd) {
+  /**
+   * The newest session in `cwd` that holds a conversation. A launch that ends
+   * before its first prompt leaves a session with no messages, and that is never
+   * the conversation `--continue` means (#428). `accept` replaces that default test
+   * for a caller with a wider idea of a live session, such as `book status`.
+   */
+  mostRecentInCwd(cwd, accept = (meta) => meta.messageCount > 0) {
     const normalized = normalizeWorkspace(cwd);
-    return this.list().find((meta) => meta.cwd === normalized);
+    return this.list().find((meta) => meta.cwd === normalized && accept(meta));
   }
   findByName(name) {
     return this.list().find((meta) => meta.name === name);
@@ -824,19 +912,13 @@ var SessionStore = class {
       if (preserveIds.has(id)) continue;
       try {
         if (entry.meta.updatedAt < cutoff) {
-          unlinkSync(this.path(id));
-          rmSync(imageSessionDirectory(this.root, id), { recursive: true, force: true });
-          this.metadataIndex.delete(id);
-          this.parsedSessions.delete(id);
+          this.discardSession(id);
           removedIds.push(id);
           removed++;
         }
       } catch {
         if (existsSync(this.path(id)) && statSync(this.path(id)).mtimeMs < cutoff) {
-          unlinkSync(this.path(id));
-          rmSync(imageSessionDirectory(this.root, id), { recursive: true, force: true });
-          this.metadataIndex.delete(id);
-          this.parsedSessions.delete(id);
+          this.discardSession(id);
           removedIds.push(id);
           removed++;
         }
@@ -845,7 +927,85 @@ var SessionStore = class {
     if (removedIds.length > 0) this.persistIndex(removedIds, []);
     return removed;
   }
+  /**
+   * Remove one session this process created if nothing was ever recorded in it: its file
+   * holds nothing but the bare header `create` wrote (no turn, no run, no patch, no name).
+   * A name is something a user typed (`--name`), so a named session is kept. The decision
+   * is made from the stored file, under the index lock, and the file and its index entry go
+   * together. A file another process still holds (EBUSY, EPERM on Windows) is left in place.
+   * Once the file is gone the session is gone: an attachment directory that will not go, or an
+   * index file that cannot be rewritten, no longer undoes that (a later index rebuild drops the
+   * stale entry). Returns whether the session was removed.
+   */
+  removeUntouched(id) {
+    if (!existsSync(this.path(id))) return false;
+    this.ensureIndex();
+    const entry = this.metadataIndex.get(id);
+    if (entry && (entry.meta.messageCount > 0 || entry.meta.name)) return false;
+    try {
+      return this.withIndexLock(() => {
+        if (!this.isUntouched(id)) return false;
+        try {
+          this.discardSession(id);
+        } catch (error) {
+          if (!isErrno(error, ["ENOENT"])) throw error;
+          this.dropSession(id);
+        }
+        try {
+          this.writeIndexLocked([id], []);
+        } catch (error) {
+          if (!isErrno(error, ["ENOENT", "EBUSY", "EPERM"])) throw error;
+          log.warn("could not rewrite the session index after removing a session", { id });
+        }
+        return true;
+      });
+    } catch (error) {
+      if (isErrno(error, ["ENOENT", "EBUSY", "EPERM"])) return false;
+      throw error;
+    }
+  }
+  isUntouched(id) {
+    if (statSync(this.path(id)).size > HEADER_PROBE_BYTES) return false;
+    const lines = readFileSync(this.path(id), "utf-8").split("\n").filter(Boolean);
+    if (lines.length === 0) return true;
+    if (lines.length > 1) return false;
+    try {
+      const header = JSON.parse(lines[0]);
+      const data = header.data ?? {};
+      return header.type === "session_meta" && data.kind === "session_meta" && !data.name;
+    } catch {
+      return false;
+    }
+  }
+  /** Remove one session's file, attachments and cached state. The index file is not rewritten. */
+  discardSession(id) {
+    this.unlinkSessionFile(id);
+    this.dropSession(id);
+  }
+  unlinkSessionFile(id) {
+    unlinkSync(this.path(id));
+  }
+  /** What remains once the session file is gone. Attachments are best-effort. */
+  dropSession(id) {
+    try {
+      this.removeAttachments(id);
+    } catch (error) {
+      log.warn("could not remove a session attachment directory", {
+        id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    this.metadataIndex.delete(id);
+    this.parsedSessions.delete(id);
+  }
+  removeAttachments(id) {
+    rmSync(imageSessionDirectory(this.root, id), { recursive: true, force: true });
+  }
 };
+function isErrno(error, codes) {
+  const code = error?.code;
+  return code !== void 0 && codes.includes(code);
+}
 function cloneLoadedSession(session) {
   const contextHistory = [...session.contextHistory];
   return {
@@ -860,6 +1020,7 @@ function cloneLoadedSession(session) {
       todos: session.plan.todos?.map((todo) => ({ ...todo })),
       tasks: session.plan.tasks?.map((task) => ({ ...task }))
     } : void 0,
+    goal: session.goal ? { version: 1, goal: session.goal.goal ? { ...session.goal.goal } : null } : void 0,
     carriedUsage: session.carriedUsage ? { ...session.carriedUsage } : void 0,
     carriedModels: session.carriedModels ? [...session.carriedModels] : void 0,
     history: contextHistory
@@ -942,7 +1103,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,
@@ -980,24 +1144,25 @@ function fixRunnerFor(manager, attribution = {}) {
       const evidence = (await manager.listEvidence({ ids: [evidenceId] }))[0];
       return evidence ? evidenceProjection(evidence) : void 0;
     },
-    async apply(agentId, evidenceId) {
-      const result = await manager.apply(agentId, evidenceId);
+    async apply(agentId, evidenceId, options) {
+      const result = await manager.apply(agentId, evidenceId, options);
       return { status: result.status, commit: result.commit, error: result.error };
     }
   };
 }
 
 // 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 +1171,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 +1409,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 +1595,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 +1649,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 +1760,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 +1802,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);
@@ -1684,7 +1940,15 @@ async function applyReviewFixes(runner, confirmed, options = {}) {
         );
         continue;
       }
-      const applied = await runner.apply(patcher.id, candidate.id);
+      let applied;
+      try {
+        applied = await runner.apply(patcher.id, candidate.id, { signal: options.signal });
+      } catch (error) {
+        if (!options.signal?.aborted) throw error;
+        result.cancelled = true;
+        result.messages.push(`Stopped while applying ${finding.file}: ${REVIEW_CANCELLED}.`);
+        break;
+      }
       if (applied.status === "applied") {
         result.applied++;
         result.messages.push(
@@ -1857,12 +2121,19 @@ function reduceAgentSessionSnapshot(snapshot, event) {
     case "agent_permission":
     case "agent_persistence":
     case "skill_lifecycle":
+    case "notice":
+    case "goal_status":
     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 +2171,10 @@ function reduceAgentSessionSnapshot(snapshot, event) {
 }
 
 // src/session/resolve.ts
+var log2 = createDebugLogger("session:resolve");
+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;
@@ -1940,6 +2215,25 @@ function persistHistory(store, sessionId, history) {
     });
   }
 }
+function discardUntouchedSession(store, launch) {
+  if (!store || !launch.created) return false;
+  try {
+    return store.removeUntouched?.(launch.sessionId) ?? false;
+  } catch (error) {
+    log2.warn("could not remove the untouched session", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+function discardUntouchedSessions(store, launch, createdSessionIds) {
+  let removed = 0;
+  if (discardUntouchedSession(store, launch)) removed++;
+  for (const sessionId of createdSessionIds) {
+    if (discardUntouchedSession(store, { sessionId, created: true })) removed++;
+  }
+  return removed;
+}
 function resolveSessionBootstrap(store, options) {
   if (!store) {
     if (options.resume || options.continue) {
@@ -1970,7 +2264,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 +2287,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,
@@ -2004,12 +2300,14 @@ function resolveSessionBootstrap(store, options) {
         rewindTargets: loaded.rewindTargets,
         activeEventIds: loaded.activeEventIds,
         plan: loaded.plan,
+        goal: loaded.goal,
         source: "resume",
         persisted: true,
         created: true
       };
     }
     store.touch(selected.id);
+    recordResumeDriver(store, selected.id, loaded.meta.driver, options.driver);
     return {
       sessionId: selected.id,
       sessionName: loaded.meta.name,
@@ -2020,6 +2318,7 @@ function resolveSessionBootstrap(store, options) {
       rewindTargets: loaded.rewindTargets,
       activeEventIds: loaded.activeEventIds,
       plan: loaded.plan,
+      goal: loaded.goal,
       carriedUsage: loaded.carriedUsage,
       carriedModels: loaded.carriedModels,
       source: "resume",
@@ -2027,7 +2326,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 +2347,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/**",
@@ -2066,9 +2370,8 @@ function resolveWorkspaceMentionPath(workspace, mentionPath) {
   const normalized = mentionPath.replace(/\\/g, "/");
   const candidate = isAbsolute(normalized) ? normalized : resolve2(root, normalized);
   const filePath = resolve2(candidate);
-  const rel = relative(root, filePath);
-  if (rel.startsWith("..") || isAbsolute(rel)) return null;
-  return { filePath, relativePath: normalizeMentionPath(rel) };
+  if (isOutside(root, filePath)) return null;
+  return { filePath, relativePath: normalizeMentionPath(relative(root, filePath)) };
 }
 function findActiveFileMention(input) {
   for (let i = input.length - 1; i >= 0; i--) {
@@ -2090,21 +2393,50 @@ 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 reachesUnc = createUncGuard();
+  if (reachesUnc(workspace)) return [];
   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,
+        // The walk follows links: on Windows each one is asked about first, so none to a share is
+        // resolved.
+        fs: uncGuardedWalkFs(workspace, reachesUnc),
+        signal
+      })
+    );
   } catch {
     return [];
   }
@@ -2112,7 +2444,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 +2455,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 +2470,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,15 +2497,96 @@ 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
   );
 }
 
 // src/input/input-expansion.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 import { exec } from "child_process";
 import { createHash as createHash2 } from "crypto";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "path";
+
+// src/input/committed-files.ts
+var REPOSITORY_SELECTION = {
+  GIT_DIR: void 0,
+  GIT_WORK_TREE: void 0,
+  GIT_INDEX_FILE: void 0,
+  GIT_OBJECT_DIRECTORY: void 0,
+  GIT_ALTERNATE_OBJECT_DIRECTORIES: void 0,
+  GIT_COMMON_DIR: void 0,
+  GIT_NAMESPACE: void 0,
+  GIT_PREFIX: void 0
+};
+var GIT_ENV = { ...REPOSITORY_SELECTION, ...noFetchGitEnv() };
+var GIT_TIMEOUT_MS = 1e4;
+function records(stdout) {
+  return stdout.split("\0").filter(Boolean).flatMap((record) => {
+    const tab = record.indexOf("	");
+    if (tab === -1) return [];
+    return [{ fields: record.slice(0, tab).split(" "), path: record.slice(tab + 1) }];
+  });
+}
+async function committedFileStates(repoRoot, paths, signal) {
+  const states = /* @__PURE__ */ new Map();
+  if (paths.length === 0) return states;
+  const { pins, partialClone } = await readRepositoryGitConfig(repoRoot, void 0, {
+    signal,
+    timeoutMs: GIT_TIMEOUT_MS,
+    env: GIT_ENV
+  });
+  const git = async (args) => {
+    try {
+      return (await defaultGitRunner(hardenedGitArgs([...pins, "--literal-pathspecs", ...args]), {
+        cwd: repoRoot,
+        signal,
+        timeoutMs: GIT_TIMEOUT_MS,
+        env: GIT_ENV
+      })).stdout;
+    } catch (error) {
+      if (!(error instanceof Error)) throw error;
+      const message = describeMissingObjects(error.message, partialClone);
+      throw message === error.message ? error : new Error(message, { cause: error });
+    }
+  };
+  const settled = await Promise.allSettled([
+    git(["ls-tree", "-r", "-z", "--full-tree", "HEAD", "--", ...paths]),
+    git(["ls-files", "-z", "--stage", "--full-name", "--", ...paths]),
+    git(["hash-object", "--", ...paths])
+  ]);
+  const [tree, index, hashes] = settled.map((result) => {
+    if (result.status === "rejected") throw result.reason;
+    return result.value;
+  });
+  const committed = /* @__PURE__ */ new Map();
+  for (const { fields, path } of records(tree)) {
+    if ((fields[0] === "100644" || fields[0] === "100755") && fields[1] === "blob") {
+      committed.set(path, fields[2]);
+    }
+  }
+  const staged = /* @__PURE__ */ new Map();
+  for (const { fields, path } of records(index)) {
+    if (fields[2] === "0") staged.set(path, fields[1]);
+  }
+  const worktree = hashes.split(/\r?\n/);
+  paths.forEach((path, position) => {
+    const blob = committed.get(path);
+    if (blob === void 0) states.set(path, "untracked");
+    else if (staged.get(path) !== blob || worktree[position] !== blob) states.set(path, "changed");
+    else states.set(path, "unchanged");
+  });
+  return states;
+}
+
+// src/input/input-expansion.ts
 var AT_MENTION_CHAR_LIMIT = 2e4;
 function isMentionBoundary2(input, index) {
   if (index === 0) return true;
@@ -2173,11 +2597,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;
     }
@@ -2233,94 +2722,198 @@ function formatMentionError(filePath, reason) {
 function looksBinary(content) {
   return content.includes("\0");
 }
-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");
+var REFUSAL_TEXT = {
+  outside: "it is outside the workspace and additionalDirectories",
+  unc: "it is, or links to, a network (UNC) path",
+  "no-repository": "a project command inlines only files committed to git, and there is no repository",
+  untracked: "a project command inlines only files committed to git, and git does not track it",
+  changed: "a project command inlines only committed files without local changes, and it has some",
+  "git-failed": "a project command inlines only committed files, and git could not check it"
+};
+function formatRefusedMentionNotice(refused) {
+  return `\u26A0  Left @${renderUntrustedText(refused.path, 400)} as written: ${REFUSAL_TEXT[refused.reason]}.`;
+}
+function mentionTarget(workspace, mentionPath, additionalRoots) {
+  const inWorkspace = resolveWorkspaceMentionPath(workspace, mentionPath);
+  if (inWorkspace) return inWorkspace;
+  const normalized = mentionPath.replace(/\\/g, "/");
+  if (!isAbsolute2(normalized)) return null;
+  const filePath = resolve3(normalized);
+  if (!additionalRoots.some((root) => !isOutside(root, filePath))) return null;
+  return { filePath, relativePath: normalizeMentionPath(relative2(resolve3(workspace), filePath)) };
+}
+function decideMention(workspace, mentionPath, additionalRoots) {
+  const target = mentionTarget(workspace, mentionPath, additionalRoots);
+  if (!target) return null;
+  if (reachesUncPath(target.filePath)) return { kind: "refused", reason: "unc" };
+  const realPath = tryRealPath(target.filePath);
+  if (realPath === void 0) return null;
+  let regular;
+  try {
+    const stat2 = statSync2(realPath);
+    if (stat2.isDirectory()) return null;
+    regular = stat2.isFile();
+  } catch {
+    return null;
+  }
+  const readable = resolveMentionReadablePath(
+    { workspaceRoot: workspace, additionalRoots },
+    realPath
+  );
+  if (!("path" in readable)) {
+    return { kind: "refused", reason: readable.reason === "unc" ? "unc" : "outside" };
+  }
+  return { kind: "file", realPath, relativePath: target.relativePath, regular };
+}
+async function applyProjectCommandRule(workspace, decisions, signal) {
+  const files = decisions.filter(
+    (decision) => decision?.kind === "file"
+  );
+  if (files.length === 0) return decisions;
+  const refuse = (reason) => decisions.map(
+    (decision) => decision?.kind === "file" ? { kind: "refused", reason } : decision
+  );
+  const repoRoot = findRepositoryRoot(workspace);
+  if (repoRoot === void 0) return refuse("no-repository");
+  const inRepository = (realPath) => isOutside(repoRoot, realPath) ? void 0 : relative2(repoRoot, realPath).replace(/\\/g, "/");
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const path = file.regular ? inRepository(file.realPath) : void 0;
+    if (path !== void 0) paths.add(path);
+  }
+  let states;
+  try {
+    states = await committedFileStates(repoRoot, [...paths], signal);
+  } catch {
+    states = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      try {
+        states.set(path, (await committedFileStates(repoRoot, [path], signal)).get(path));
+      } catch {
+        states.set(path, "git-failed");
+      }
+    }
+  }
+  return decisions.map((decision) => {
+    if (decision?.kind !== "file") return decision;
+    const path = inRepository(decision.realPath);
+    const state = path === void 0 ? "untracked" : states.get(path) ?? "untracked";
+    return state === "unchanged" ? decision : { kind: "refused", reason: state };
+  });
+}
+function inlineMention(token, decision, scope) {
+  if (decision?.kind !== "file") return { text: null };
+  if (!decision.regular) {
+    return { text: formatMentionError(decision.relativePath, "path is not a regular file") };
+  }
+  let bytes;
   try {
-    const stat = statSync2(resolved.filePath);
-    if (stat.isDirectory()) return formatMentionError(resolved.relativePath, "path is a directory");
-    if (!stat.isFile())
-      return formatMentionError(resolved.relativePath, "path is not a regular file");
-    const content = readFileSync2(resolved.filePath, "utf-8");
-    if (looksBinary(content))
-      return formatMentionError(resolved.relativePath, "file appears to be binary");
-    const truncated = content.length > AT_MENTION_CHAR_LIMIT;
-    const body = truncated ? content.slice(0, AT_MENTION_CHAR_LIMIT) : content;
-    const suffix = truncated ? `
+    bytes = readFileSync2(decision.realPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { text: formatMentionError(token.path, message.slice(0, 200) || "unable to read file") };
+  }
+  const observation = {
+    // Filed the way Read and Edit file and look a file up (`observationPathFor`): canonical, so a
+    // mention through a link, or of a file in an `additionalDirectories` entry, counts as seen.
+    path: observationPathFor(scope.workspace, decision.realPath),
+    workspaceId: scope.workspaceId,
+    sha256: createHash2("sha256").update(bytes).digest("hex"),
+    byteSize: bytes.byteLength,
+    operation: "mention",
+    sourceRef: scope.sourceRef,
+    timestamp: Date.now()
+  };
+  const content = bytes.toString("utf-8");
+  if (looksBinary(content)) {
+    return {
+      text: formatMentionError(decision.relativePath, "file appears to be binary"),
+      observation
+    };
+  }
+  const truncated = content.length > AT_MENTION_CHAR_LIMIT;
+  const body = truncated ? content.slice(0, AT_MENTION_CHAR_LIMIT) : content;
+  const suffix = truncated ? `
 
 [File truncated at ${AT_MENTION_CHAR_LIMIT} characters; use the Read tool for more.]` : "";
-    return `
-Contents of ${resolved.relativePath}:
+  return {
+    text: `
+Contents of ${decision.relativePath}:
 
 \`\`\`
 ${body}${suffix}
 \`\`\`
-`;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return formatMentionError(filePath, message.slice(0, 200) || "unable to read file");
-  }
+`,
+    observation
+  };
 }
-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) {
-  const workspaceId = workspaceIdentity(workspace);
-  const observations = [];
-  for (const token of findMentionTokens(input)) {
-    const resolved = resolveWorkspaceMentionPath(workspace, token.path);
-    if (!resolved || !existsSync2(resolved.filePath)) continue;
-    try {
-      const info = statSync2(resolved.filePath);
-      if (!info.isFile()) continue;
-      const bytes = readFileSync2(resolved.filePath);
-      observations.push({
-        path: resolved.relativePath,
-        workspaceId,
-        sha256: createHash2("sha256").update(bytes).digest("hex"),
-        byteSize: bytes.byteLength,
-        operation: "mention",
-        sourceRef,
-        timestamp: Date.now()
-      });
-    } catch {
-    }
-  }
-  return observations;
+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] };
+  });
 }
-async function expandShellCommands(input, workspace, signal) {
-  const matches = [...input.matchAll(/^!(\S.*)$/gm)];
-  if (matches.length === 0) return input;
+function shellLineRanges(lines) {
+  return lines.map((line) => [line.start, line.end]);
+}
+async function expandUserInputDetailed(input, workspace, options = {}) {
+  const shellLines = options.expandShell && !options.projectCommand ? findShellLines(input) : [];
+  const tokens = findMentionTokens(input, shellLineRanges(shellLines));
+  if (shellLines.length === 0 && tokens.length === 0) {
+    return { text: input, observations: [], refused: [] };
+  }
+  const additionalRoots = options.additionalRoots ?? [];
+  const decide = (token) => decideMention(workspace, token.path, additionalRoots);
+  const decided = options.projectCommand ? await applyProjectCommandRule(workspace, tokens.map(decide), options.signal) : void 0;
+  const scope = {
+    workspace,
+    workspaceId: workspaceIdentity(workspace),
+    sourceRef: options.sourceRef ?? ""
+  };
+  const observations = [];
+  const refused = [];
+  const edits = [
+    ...shellLines.map((line) => ({
+      start: line.start,
+      end: line.end,
+      apply: () => executeShellExpansion(line.command, workspace, options.signal)
+    })),
+    ...tokens.map((token, index) => ({
+      start: token.start,
+      end: token.end,
+      apply: () => {
+        const decision = decided ? decided[index] : decide(token);
+        if (decision?.kind === "refused")
+          refused.push({ path: token.path, reason: decision.reason });
+        const inlined = inlineMention(token, decision, scope);
+        if (inlined.observation) observations.push(inlined.observation);
+        return inlined.text ?? 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);
+  return { text: output + input.slice(cursor), observations, refused };
 }
 function executeShellExpansion(command, workspace, signal) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     exec(
       command,
       {
         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,
@@ -2329,18 +2922,18 @@ function executeShellExpansion(command, workspace, signal) {
       (error, stdout) => {
         if (error) {
           const message = error.message.slice(0, 200) || "unknown error";
-          resolve3(`(command '${command}' failed: ${message})`);
+          resolve4(`(command '${command}' failed: ${message})`);
           return;
         }
         const value = stdout.trim();
-        resolve3(value || `(command '${command}' produced no output)`);
+        resolve4(value || `(command '${command}' produced no output)`);
       }
     );
   });
 }
 
 // src/session/agent-interactions.ts
-var log2 = createDebugLoggerWithCounter("session:interactions");
+var log3 = createDebugLoggerWithCounter("session:interactions");
 function snapshotOf(permission, planApproval, userQuestions, elicitations) {
   return Object.freeze({
     pendingPermission: permission ? Object.freeze({ toolCall: permission.toolCall }) : null,
@@ -2369,11 +2962,11 @@ var AgentInteractionController = class {
     return () => this.listeners.delete(listener);
   }
   requestPermission(toolCall) {
-    return new Promise((resolve3) => {
-      const request = { toolCall, resolve: resolve3 };
+    return new Promise((resolve4) => {
+      const request = { toolCall, resolve: resolve4 };
       if (this.pendingPermission) {
         this.pendingPermissionQueue.push(request);
-        log2.event("permission:queued", {
+        log3.event("permission:queued", {
           tool: toolCall.name,
           id: toolCall.id,
           queueLength: this.pendingPermissionQueue.length
@@ -2381,19 +2974,19 @@ var AgentInteractionController = class {
       } else {
         this.pendingPermission = request;
         this.publish();
-        log2.event("permission:pending", { tool: toolCall.name, id: toolCall.id });
+        log3.event("permission:pending", { tool: toolCall.name, id: toolCall.id });
       }
     });
   }
   settlePermission(result, via) {
     const pending = this.pendingPermission;
     if (!pending) {
-      log2.event("permission:settled:noop", { reason: "no-pending", result, via });
+      log3.event("permission:settled:noop", { reason: "no-pending", result, via });
       return false;
     }
     this.pendingPermission = this.pendingPermissionQueue.shift() ?? null;
     this.publish();
-    log2.event("permission:settled", {
+    log3.event("permission:settled", {
       tool: pending.toolCall.name,
       id: pending.toolCall.id,
       result,
@@ -2411,27 +3004,27 @@ var AgentInteractionController = class {
     this.pendingPermission = null;
     this.pendingPermissionQueue = [];
     this.publish();
-    for (const request of pending) request.resolve("deny");
-    log2.event("permission:cancelled-all", { via, count: pending.length });
+    for (const request of pending) request.resolve({ result: "deny", reason: "dismissed" });
+    log3.event("permission:cancelled-all", { via, count: pending.length });
     return true;
   }
   requestPlanApproval(plan) {
     if (this.pendingPlanApproval) this.settlePlanApproval("reject", "superseded");
-    return new Promise((resolve3) => {
-      this.pendingPlanApproval = { plan, resolve: resolve3 };
+    return new Promise((resolve4) => {
+      this.pendingPlanApproval = { plan, resolve: resolve4 };
       this.publish();
-      log2.event("plan-approval:pending", { len: plan.length });
+      log3.event("plan-approval:pending", { len: plan.length });
     });
   }
   settlePlanApproval(result, via) {
     const pending = this.pendingPlanApproval;
     if (!pending) {
-      log2.event("plan-approval:settled:noop", { reason: "no-pending", result, via });
+      log3.event("plan-approval:settled:noop", { reason: "no-pending", result, via });
       return false;
     }
     this.pendingPlanApproval = null;
     this.publish();
-    log2.event("plan-approval:settled", { result, via, len: pending.plan.length });
+    log3.event("plan-approval:settled", { result, via, len: pending.plan.length });
     pending.resolve(result);
     return true;
   }
@@ -2442,10 +3035,10 @@ var AgentInteractionController = class {
         message: `Duplicate user question request: ${request.id}`
       });
     }
-    return new Promise((resolve3) => {
-      this.pendingUserQuestions = [...this.pendingUserQuestions, { request, resolve: resolve3 }];
+    return new Promise((resolve4) => {
+      this.pendingUserQuestions = [...this.pendingUserQuestions, { request, resolve: resolve4 }];
       this.publish();
-      log2.event("user-question:pending", {
+      log3.event("user-question:pending", {
         id: request.id,
         count: request.questions.length,
         queueLength: this.pendingUserQuestions.length,
@@ -2456,14 +3049,14 @@ var AgentInteractionController = class {
   settleUserQuestion(result, via, requestId) {
     const index = requestId ? this.pendingUserQuestions.findIndex((entry) => entry.request.id === requestId) : 0;
     if (index < 0 || this.pendingUserQuestions.length === 0) {
-      log2.event("user-question:settled:noop", { reason: "no-pending", via, requestId });
+      log3.event("user-question:settled:noop", { reason: "no-pending", via, requestId });
       return false;
     }
     const next = [...this.pendingUserQuestions];
     const [pending] = next.splice(index, 1);
     this.pendingUserQuestions = next;
     this.publish();
-    log2.event("user-question:settled", {
+    log3.event("user-question:settled", {
       id: pending.request.id,
       action: result.action,
       via,
@@ -2480,7 +3073,7 @@ var AgentInteractionController = class {
     for (const entry of pending) {
       entry.resolve({ action: "cancel", message: `Question cancelled via ${via}.` });
     }
-    log2.event("user-question:cancelled-all", { via, count: pending.length });
+    log3.event("user-question:cancelled-all", { via, count: pending.length });
     return pending.length;
   }
   /**
@@ -2491,10 +3084,10 @@ var AgentInteractionController = class {
     if (this.pendingElicitations.some((entry) => entry.request.id === request.id)) {
       return Promise.resolve({ action: "cancel" });
     }
-    return new Promise((resolve3) => {
-      this.pendingElicitations = [...this.pendingElicitations, { request, resolve: resolve3 }];
+    return new Promise((resolve4) => {
+      this.pendingElicitations = [...this.pendingElicitations, { request, resolve: resolve4 }];
       this.publish();
-      log2.event("elicitation:pending", {
+      log3.event("elicitation:pending", {
         id: request.id,
         server: request.server,
         fields: request.fields.length,
@@ -2505,14 +3098,14 @@ var AgentInteractionController = class {
   settleElicitation(result, via, requestId) {
     const index = requestId ? this.pendingElicitations.findIndex((entry) => entry.request.id === requestId) : 0;
     if (index < 0 || this.pendingElicitations.length === 0) {
-      log2.event("elicitation:settled:noop", { reason: "no-pending", via, requestId });
+      log3.event("elicitation:settled:noop", { reason: "no-pending", via, requestId });
       return false;
     }
     const next = [...this.pendingElicitations];
     const [pending] = next.splice(index, 1);
     this.pendingElicitations = next;
     this.publish();
-    log2.event("elicitation:settled", {
+    log3.event("elicitation:settled", {
       id: pending.request.id,
       action: result.action,
       via,
@@ -2527,7 +3120,7 @@ var AgentInteractionController = class {
     this.pendingElicitations = [];
     this.publish();
     for (const entry of pending) entry.resolve({ action: "cancel" });
-    log2.event("elicitation:cancelled-all", { via, count: pending.length });
+    log3.event("elicitation:cancelled-all", { via, count: pending.length });
     return pending.length;
   }
   cancelAll(via) {
@@ -2594,21 +3187,22 @@ 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 log4 = createDebugLogger("session:usage");
+function persistGoal(target, goal) {
+  if (!target.timelineStore || !target.sessionId) return;
+  const data = { version: 1, goal: goal ? { ...goal } : null };
+  target.timelineStore.append(target.sessionId, {
+    type: "goal",
+    timestamp: Date.now(),
+    data
+  });
 }
 var AgentSession = class {
   interactions = new AgentInteractionController();
   operations = new AgentSessionOperations();
   runLoop;
   compactRunner;
+  judgeRunner;
   postCompactHooksRunner;
   sessionStartRunner;
   sessionEndRunner;
@@ -2616,12 +3210,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;
@@ -2674,6 +3283,11 @@ var AgentSession = class {
           contextMessage: request.contextMessage,
           userMessage,
           sessionName: request.sessionName,
+          sessionNameSource: request.sessionNameSource,
+          sessionNameExact: request.sessionNameExact,
+          expandShellInput: request.expandShellInput,
+          projectCommand: request.projectCommand,
+          typedText: request.typedText,
           snapshotStore: request.snapshotStore,
           timelineStore: request.timelineStore,
           signal: control.signal,
@@ -2719,6 +3333,7 @@ var AgentSession = class {
             ...request.options,
             runtime,
             displayMessage: request.displayMessage,
+            typedText: request.typedText,
             userMessageId: userMessage.id,
             userMessageTimestamp: userMessage.timestamp,
             userFileObservations: userMessage.fileObservations,
@@ -2766,9 +3381,61 @@ var AgentSession = class {
   getRuntime() {
     return this.runtime;
   }
+  /** The session's `/goal`, if one is set. */
+  getGoal() {
+    return this.runtime.activeGoal;
+  }
+  /**
+   * Set the session's goal, replacing any earlier one. The next time the agent
+   * stops without calling a tool, the loop checks the condition (`agent/goal.ts`).
+   * Taking effect on the runtime means a goal set mid-run applies to that run.
+   */
+  setGoal(condition, target = {}) {
+    const goal = createGoal(condition);
+    this.runtime.activeGoal = goal;
+    persistGoal(target, goal);
+    return goal;
+  }
+  /**
+   * Carry a goal into a conversation that started fresh -- a plan handoff reseeds a new
+   * session to implement the plan the goal was guiding -- keeping its progress.
+   */
+  adoptGoal(goal, target = {}) {
+    this.runtime.activeGoal = { ...goal };
+    persistGoal(target, this.runtime.activeGoal);
+  }
+  /** Clear the session's goal. Returns the goal that was cleared, if there was one. */
+  clearGoal(target = {}) {
+    const goal = this.runtime.activeGoal;
+    if (!goal) return void 0;
+    this.runtime.activeGoal = void 0;
+    persistGoal(target, null);
+    return goal;
+  }
+  /** Put back an unmet goal a resumed session recorded. Call after the runtime it belongs on is installed. */
+  restoreGoal(record) {
+    this.runtime.activeGoal = restoreGoal(record);
+  }
+  /**
+   * 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);
-    this.runtime = new SessionRuntime(options);
+    const outgoing = this.runtime;
+    outgoing.agentManager?.handOffLateApplications(() => this.runtime.agentManager);
+    outgoing.dispose(via);
+    this.releaseRunUsage(outgoing);
+    this.runtime = new SessionRuntime({
+      ...options,
+      // The managers this session disposed, the outgoing one included, own nothing (#568).
+      disposedAgentInstanceIds: options.disposedAgentInstanceIds ?? outgoing.disposedAgentInstanceIds
+    });
     return this.runtime;
   }
   subscribe(listener) {
@@ -2793,16 +3460,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) {
+      log4.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 +3627,20 @@ 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.createdSessions?.add(sessionId);
     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 +3666,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,
@@ -2852,11 +3685,14 @@ var AgentSession = class {
       // user who wrote a plan, switched away and came back resumed a half-finished
       // objective with an empty task list and no notice that it had been dropped.
       plan: loaded.plan,
+      goal: loaded.goal,
       source: "resume",
       persisted: true,
       created: false
     };
     this.reset("session-resume");
+    const resumed = this.replaceRuntime({}, "session-resume");
+    seedShellIds(resumed.backgroundShells, loaded.transcript, loaded.contextHistory);
     request.onTransition?.(bootstrap);
     await this.startLifecycle(request.config, selected.id, "resume");
     return { status: "transitioned", bootstrap };
@@ -2877,10 +3713,13 @@ var AgentSession = class {
       gitHead: capture.gitHead,
       codeUnavailableReason: capture.reason
     };
+    const rewindPrompt = request.typedText ?? request.displayMessage;
+    const promptTyped = request.typedText !== void 0;
     const rewindTarget = {
       id: checkpointId,
       userEventId: request.userMessage.id,
-      prompt: request.displayMessage,
+      prompt: rewindPrompt,
+      ...promptTyped ? { promptTyped } : {},
       attachments: request.userMessage.attachments,
       timestamp: checkpointTimestamp,
       ...checkpoint,
@@ -2894,23 +3733,32 @@ var AgentSession = class {
         version: 1,
         checkpointId,
         userEventId: request.userMessage.id,
-        prompt: request.displayMessage,
+        prompt: rewindPrompt,
+        ...promptTyped ? { promptTyped } : {},
         attachments: request.userMessage.attachments,
         checkpoint
       }
     });
-    const { contextMessage, sessionName } = await this.recordUserMessage(request);
-    return { status: "prepared", contextMessage, rewindTarget, sessionName };
+    const { contextMessage, sessionName, mentionNotices } = await this.recordUserMessage(request);
+    return { status: "prepared", contextMessage, rewindTarget, sessionName, mentionNotices };
   }
   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 expansion = request.contextMessage !== void 0 ? void 0 : await expandUserInputDetailed(request.displayMessage, request.config.workspace, {
+      expandShell: request.expandShellInput === true,
+      signal: request.signal,
+      sourceRef: request.userMessage.id,
+      // The roots Read serves besides the workspace, resolved as the agent loop does, and
+      // only for text that can hold a mention at all.
+      additionalRoots: request.displayMessage.includes("@") ? resolveAdditionalRoots(
+        request.config.workspace,
+        request.config.settings.additionalDirectories
+      ) : [],
+      projectCommand: request.projectCommand
+    });
+    const contextMessage = expansion?.text ?? request.contextMessage ?? request.displayMessage;
+    const mentionNotices = (expansion?.refused ?? []).map(formatRefusedMentionNotice);
     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.fileObservations = expansion?.observations ?? [];
     const observationLedger = (request.runtime ?? this.runtime).fileObservationLedger;
     for (const observation of request.userMessage.fileObservations) {
       observationLedger.set(observationKey(observation.workspaceId, observation.path), observation);
@@ -2934,40 +3782,139 @@ var AgentSession = class {
       }
     });
     if (request.timelineStore) request.onUserMessagePersisted?.();
-    const sessionName = request.sessionName?.trim() || deriveSessionName(request.displayMessage);
+    if (request.userMessage.kind === "agent-notification") {
+      return { contextMessage, sessionName: request.sessionName, mentionNotices };
+    }
+    const sessionName = request.sessionName?.trim() || request.sessionNameExact?.trim() || deriveSessionName(request.sessionNameSource ?? request.displayMessage);
     if (!request.sessionName?.trim()) {
       request.timelineStore?.patchMeta?.(request.sessionId, { name: sessionName });
     }
-    return { contextMessage, sessionName };
+    return { contextMessage, sessionName, mentionNotices };
   }
   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 = {
+    const recorded = {
       id: result.compactId,
       trigger: result.trigger,
       transcriptOrdinal: request.transcriptOrdinal,
@@ -2977,7 +3924,13 @@ var AgentSession = class {
       postContextTokens: result.postContextTokens,
       generation: result.generation,
       checkpointVersion: 2,
-      timestamp
+      timestamp,
+      carriedCount: result.carriedCount
+    };
+    const boundary = {
+      ...recorded,
+      ...result.degraded ? { degraded: true } : {},
+      ...result.warning ? { warning: result.warning } : {}
     };
     const data = {
       version: 2,
@@ -2990,14 +3943,16 @@ var AgentSession = class {
       preContextTokens: result.preContextTokens,
       postContextTokens: result.postContextTokens,
       replacementHistory: result.replacementHistory,
-      boundary,
+      boundary: recorded,
       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 +3967,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 +4003,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 +4028,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;
@@ -3094,6 +4049,15 @@ var AgentSession = class {
           data
         });
       };
+      let lastGoalSignature = "";
+      const persistRunGoal = () => {
+        if (request.isCurrent?.() === false) return;
+        const goal = runtime.activeGoal ?? null;
+        const signature = JSON.stringify(goal);
+        if (signature === lastGoalSignature) return;
+        lastGoalSignature = signature;
+        persistGoal({ sessionId: request.sessionId, timelineStore: request.timelineStore }, goal);
+      };
       const baseLoopCallbacks = {
         onText: (content) => {
           streamedAssistantText += content;
@@ -3106,6 +4070,12 @@ var AgentSession = class {
         },
         onToolCall: (toolCall) => emit({ type: "tool_use", toolCall }),
         onToolResult: (toolResult) => emit({ type: "tool_result", toolResult }),
+        onNotice: (message) => emit({ type: "notice", message }),
+        onGoalStatus: (event) => {
+          persistRunGoal();
+          emit({ type: "goal_status", event });
+        },
+        onAuxiliaryUsage: callbacks.onAuxiliaryUsage,
         onError: (error) => {
           emittedError = error;
           emit({ type: "error", error });
@@ -3117,7 +4087,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 +4111,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 +4141,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 +4177,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 key on it.
+              derivedContent: message.derivedContent
             }
           });
         },
@@ -3224,21 +4191,27 @@ 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);
+        if (runtime.activeGoal) persistRunGoal();
+      }
       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", {
@@ -3287,10 +4260,10 @@ async function captureSnapshot(snapshotStore) {
     return { ok: false, reason: "Filesystem checkpoint storage is unavailable." };
   }
   if (snapshotStore.captureAsync) return snapshotStore.captureAsync();
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     setTimeout(() => {
       try {
-        resolve3(snapshotStore.capture());
+        resolve4(snapshotStore.capture());
       } catch (error) {
         reject(error);
       }
@@ -3481,6 +4454,8 @@ function validateElicitationContent(fields, content) {
 }
 
 export {
+  parseSessionDriver,
+  resolveSessionDriver,
   displaySessionName,
   normalizeWorkspace,
   SessionStore,
@@ -3491,8 +4466,11 @@ export {
   findActiveFileMention,
   replaceActiveFileMention,
   getFileMentionCandidates,
+  mentionTokenRanges,
   createAgentSessionSnapshot,
   reduceAgentSessionSnapshot,
+  discardUntouchedSession,
+  discardUntouchedSessions,
   resolveSessionBootstrap,
   AgentSession,
   toElicitationFields,
@@ -3501,4 +4479,4 @@ export {
   coerceElicitationValue,
   validateElicitationContent
 };
-//# sourceMappingURL=chunk-V4BOYR52.js.map
+//# sourceMappingURL=chunk-ENLB7NYV.js.map