@letrquan/book 0.3.0 → 0.4.0-beta.0

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

@@ -8,8 +8,9 @@ import {
   isSpendlessUsage,
   isTerminalStatus,
   loadGitignore,
-  runAgentLoop
-} from "./chunk-5YHTKWJN.js";
+  runAgentLoop,
+  seedShellIds
+} from "./chunk-KDNWMKXV.js";
 import {
   DEFAULT_CONFIDENCE_THRESHOLD,
   REVIEW_LENSES,
@@ -18,6 +19,7 @@ import {
   buildReviewerPrompt,
   buildSingleReviewPrompt,
   clampConfidence,
+  createGoal,
   isReviewCategory,
   isReviewSeverity,
   judgeCompaction,
@@ -27,30 +29,56 @@ import {
   renderReviewTarget,
   resolveCompactBudgets,
   resolveReviewTarget,
+  restoreGoal,
   runCompact,
   runHooks,
   runPostCompactHooks
-} from "./chunk-IME7R2UI.js";
+} from "./chunk-FPR7SKIE.js";
 import {
   observationKey,
+  observationPathFor,
   onAbort,
   throwIfAborted,
   workspaceIdentity,
   yieldToEventLoop
-} from "./chunk-J62VZYOB.js";
+} from "./chunk-N2G4Q7ME.js";
 import {
   globWalkIgnore
-} from "./chunk-JTPOI3KU.js";
+} 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-62QL5QUP.js";
+} from "./chunk-OJBMDM5H.js";
+import {
+  isOutside,
+  normalizeToolResult,
+  resolveMentionReadablePath
+} from "./chunk-YIL6HTJX.js";
+import {
+  createUncGuard,
+  reachesUncPath,
+  uncGuardedWalkFs
+} from "./chunk-EEX6QNXV.js";
 import {
-  normalizeToolResult
-} from "./chunk-224FJZLH.js";
+  renderUntrustedText
+} from "./chunk-WV3O5PGX.js";
 
 // src/session-driver.ts
 var SESSION_DRIVERS = ["human", "agent"];
@@ -77,7 +105,7 @@ function resolveSessionDriver(input) {
 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;
@@ -118,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) {
@@ -206,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++) {
@@ -339,7 +375,7 @@ var SessionStore = class {
     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");
@@ -349,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 });
       }
@@ -373,9 +409,9 @@ var SessionStore = class {
     this.parsedSessions.set(id, {
       size: stat2.size,
       mtimeMs: stat2.mtimeMs,
-      records
+      records: records2
     });
-    return records;
+    return records2;
   }
   updateIndexAfterAppend(id, record) {
     const entry = this.metadataIndex.get(id);
@@ -396,7 +432,9 @@ var SessionStore = class {
     } 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";
@@ -430,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;
@@ -456,11 +494,12 @@ 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") {
@@ -485,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") {
@@ -495,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,
@@ -675,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);
     }
@@ -694,6 +739,7 @@ var SessionStore = class {
       activeEventIds,
       meta,
       plan: latestPlan,
+      goal: latestGoal,
       carriedUsage,
       carriedModels: [...carriedModels],
       history: contextHistory
@@ -816,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;
   }
@@ -841,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);
@@ -860,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++;
         }
@@ -881,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 {
@@ -896,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
@@ -1019,8 +1144,8 @@ 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 };
     }
   };
@@ -1815,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(
@@ -1989,6 +2122,7 @@ function reduceAgentSessionSnapshot(snapshot, event) {
     case "agent_persistence":
     case "skill_lifecycle":
     case "notice":
+    case "goal_status":
     case "background_job_start":
     case "background_job_update":
     case "background_job_output":
@@ -2037,6 +2171,7 @@ 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" });
 }
@@ -2080,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) {
@@ -2146,6 +2300,7 @@ function resolveSessionBootstrap(store, options) {
         rewindTargets: loaded.rewindTargets,
         activeEventIds: loaded.activeEventIds,
         plan: loaded.plan,
+        goal: loaded.goal,
         source: "resume",
         persisted: true,
         created: true
@@ -2163,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",
@@ -2214,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--) {
@@ -2260,6 +2415,8 @@ function withMissingAncestors(entries) {
   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 = globWalkIgnore([...DEFAULT_IGNORE, ...gitignore]);
@@ -2274,6 +2431,9 @@ async function getFileMentionCandidates(workspace, query, limit = 50, signal) {
         // 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
       })
     );
@@ -2350,9 +2510,83 @@ async function runSessionEnd(config, sessionId, 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;
@@ -2488,63 +2722,134 @@ function formatMentionError(filePath, reason) {
 function looksBinary(content) {
   return content.includes("\0");
 }
-function expandMention(filePath, workspace) {
-  const resolved = resolveWorkspaceMentionPath(workspace, filePath);
-  if (!resolved) return null;
-  if (!existsSync2(resolved.filePath)) return null;
+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(resolved.filePath);
+    const stat2 = statSync2(realPath);
     if (stat2.isDirectory()) return null;
-    if (!stat2.isFile())
-      return formatMentionError(resolved.relativePath, "path is not a regular file");
-    const content = readFileSync2(resolved.filePath, "utf-8");
-    if (looksBinary(content))
-      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 ? `
+    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 {
+    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 mentionTokenRanges(input) {
   return findMentionTokens(input).map((token) => [token.start, token.end]);
 }
-function collectAtMentionObservations(input, workspace, sourceRef, expandShellInput = false) {
-  const workspaceId = workspaceIdentity(workspace);
-  const observations = [];
-  const shellLines = expandShellInput ? findShellLines(input) : [];
-  for (const token of findMentionTokens(input, shellLineRanges(shellLines))) {
-    const resolved = resolveWorkspaceMentionPath(workspace, token.path);
-    if (!resolved || !existsSync2(resolved.filePath)) continue;
-    try {
-      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) => {
@@ -2555,20 +2860,39 @@ function findShellLines(input) {
 function shellLineRanges(lines) {
   return lines.map((line) => [line.start, line.end]);
 }
-async function expandUserInput(input, workspace, options = {}) {
-  const shellLines = options.expandShell ? findShellLines(input) : [];
+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 input;
+  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) => ({
+    ...tokens.map((token, index) => ({
       start: token.start,
       end: token.end,
-      apply: () => expandMention(token.path, workspace) ?? token.raw
+      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 = "";
@@ -2578,10 +2902,10 @@ async function expandUserInput(input, workspace, options = {}) {
     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,
       {
@@ -2598,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,
@@ -2638,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
@@ -2650,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,
@@ -2681,26 +3005,26 @@ var AgentInteractionController = class {
     this.pendingPermissionQueue = [];
     this.publish();
     for (const request of pending) request.resolve({ result: "deny", reason: "dismissed" });
-    log2.event("permission:cancelled-all", { via, count: pending.length });
+    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;
   }
@@ -2711,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,
@@ -2725,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,
@@ -2749,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;
   }
   /**
@@ -2760,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,
@@ -2774,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,
@@ -2796,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) {
@@ -2863,7 +3187,16 @@ var AgentSessionOperations = class {
 };
 
 // src/session/agent-session.ts
-var log3 = createDebugLogger("session:usage");
+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();
@@ -2950,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,
@@ -2995,6 +3333,7 @@ var AgentSession = class {
             ...request.options,
             runtime,
             displayMessage: request.displayMessage,
+            typedText: request.typedText,
             userMessageId: userMessage.id,
             userMessageTimestamp: userMessage.timestamp,
             userFileObservations: userMessage.fileObservations,
@@ -3042,6 +3381,41 @@ 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.
    *
@@ -3054,9 +3428,14 @@ var AgentSession = class {
    */
   replaceRuntime(options = {}, via = "session_transition") {
     const outgoing = this.runtime;
+    outgoing.agentManager?.handOffLateApplications(() => this.runtime.agentManager);
     outgoing.dispose(via);
     this.releaseRunUsage(outgoing);
-    this.runtime = new SessionRuntime(options);
+    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) {
@@ -3196,7 +3575,7 @@ var AgentSession = class {
       });
       runtime.runAccounting.commitPersistedUsage(rootRunId);
     } catch (error) {
-      log3.warn("usage record could not be appended; spend left unpersisted", {
+      log4.warn("usage record could not be appended; spend left unpersisted", {
         rootRunId,
         sessionId: target.sessionId,
         error: error instanceof Error ? error.message : String(error)
@@ -3255,6 +3634,7 @@ var AgentSession = class {
       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,
@@ -3305,12 +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");
-    this.replaceRuntime({ history: bootstrap.transcript ?? bootstrap.history }, "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 };
@@ -3331,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,
@@ -3348,27 +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 expandShellInput = request.contextMessage === void 0 && request.expandShellInput !== false;
-    const contextMessage = request.contextMessage !== void 0 ? request.contextMessage : await expandUserInput(request.displayMessage, request.config.workspace, {
-      expandShell: expandShellInput,
-      signal: request.signal
+    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,
-      expandShellInput
-    ) : [];
+    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);
@@ -3392,11 +3782,14 @@ 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;
@@ -3521,7 +3914,7 @@ var AgentSession = class {
   /** 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,
@@ -3534,6 +3927,11 @@ var AgentSession = class {
       timestamp,
       carriedCount: result.carriedCount
     };
+    const boundary = {
+      ...recorded,
+      ...result.degraded ? { degraded: true } : {},
+      ...result.warning ? { warning: result.warning } : {}
+    };
     const data = {
       version: 2,
       compactId: result.compactId,
@@ -3545,7 +3943,7 @@ var AgentSession = class {
       preContextTokens: result.preContextTokens,
       postContextTokens: result.postContextTokens,
       replacementHistory: result.replacementHistory,
-      boundary,
+      boundary: recorded,
       throughEventRef: result.throughEventRef,
       summarizedCount: result.summarizedCount,
       retainedCount: result.retainedCount,
@@ -3651,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;
@@ -3664,6 +4071,11 @@ 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 });
@@ -3767,7 +4179,7 @@ var AgentSession = class {
               kind: message.kind ?? "conversation",
               includeInContext: message.includeInContext ?? true,
               // A host-appended prompt stays host-written across a reload: the ledger,
-              // Carried Turns and memory extraction all key on it.
+              // Carried Turns key on it.
               derivedContent: message.derivedContent
             }
           });
@@ -3798,6 +4210,7 @@ var AgentSession = class {
         );
       } 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(
@@ -3847,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);
       }
@@ -4048,8 +4461,6 @@ export {
   SessionStore,
   reviewRunnerFor,
   fixRunnerFor,
-  extractJsonObject,
-  parseJsonObject,
   runHostReview,
   reviewReportJson,
   findActiveFileMention,
@@ -4058,6 +4469,8 @@ export {
   mentionTokenRanges,
   createAgentSessionSnapshot,
   reduceAgentSessionSnapshot,
+  discardUntouchedSession,
+  discardUntouchedSessions,
   resolveSessionBootstrap,
   AgentSession,
   toElicitationFields,
@@ -4066,4 +4479,4 @@ export {
   coerceElicitationValue,
   validateElicitationContent
 };
-//# sourceMappingURL=chunk-RFJ6Q6LE.js.map
+//# sourceMappingURL=chunk-ENLB7NYV.js.map