@mtreeai/msapling-cli 2.3.6-beta.45 → 2.3.6-beta.47

package/dist/index.js

@@ -1017,6 +1017,21 @@ var init_src = __esm({
         const data = overviewData;
         return this.mapUser(data, billingData);
       }
+      /**
+       * CLI-PARITY-P0-3: Web search via the backend proxy (POST /api/web/search).
+       *
+       * Provider API keys (Tavily/Serper) stay server-side; the CLI only ever sees
+       * normalised result rows. Mirrors the WebSearchTool surface so the agent can
+       * search the live web without local credentials. Backend fails open with an
+       * empty result set + provider "none" rather than 500 when no provider is
+       * available, so callers can degrade gracefully.
+       */
+      async webSearch(query, maxResults = 5) {
+        return await this.request("/api/web/search", {
+          method: "POST",
+          body: JSON.stringify({ query, max_results: maxResults })
+        });
+      }
       async getHistory(chatId) {
         const data = await this.request(`/api/projects/chat/${chatId}/history`);
         return data.messages.map((m) => ({
@@ -1268,6 +1283,30 @@ var init_src = __esm({
         const data = await this.request(`/api/projects/${encodeURIComponent(projectId)}/chats`);
         return Array.isArray(data) ? data : data.chats ?? [];
       }
+      // P0-4 (CLI-RESUME-01): list the user's recent chats across ALL projects for
+      // `/resume` + `msapling --continue`. The /api/projects/ tree keys projects by
+      // NAME and nests each project's `chats` array ({id, title, model, created_at,
+      // updated_at?}). We flatten the tree, stamp each chat with its project name,
+      // and sort by recency (updated_at, then created_at) so the most-recently
+      // touched chat is first. Backend doesn't expose a flat "recent chats" route,
+      // so this client-side flatten is the canonical path (mirrors chat.ts).
+      async listRecentChats(limit = 20) {
+        const data = await this.request("/api/projects/");
+        const flat = [];
+        for (const [projectName, bucket] of Object.entries(data.projects ?? {})) {
+          for (const chat of bucket?.chats ?? []) {
+            if (!chat?.id) continue;
+            flat.push({ ...chat, project: projectName });
+          }
+        }
+        const recencyKey = (c) => {
+          const raw = c.updated_at ?? c.created_at;
+          const t = raw ? Date.parse(raw) : NaN;
+          return Number.isNaN(t) ? 0 : t;
+        };
+        flat.sort((a, b) => recencyKey(b) - recencyKey(a));
+        return flat.slice(0, Math.max(1, limit));
+      }
       // CLI-CHAT-CREATE-01 (Iter 34): create a new chat in a project. Per LAB
       // projects.py:365 — POST /api/projects/chat/new with
       // {project_name, slot_label?, chat_name?, model?, client_type?}.
@@ -2155,7 +2194,7 @@ var init_RunCommandTool = __esm({
           this.activeCommands++;
           return;
         }
-        return new Promise((resolve20) => this.queue.push(resolve20));
+        return new Promise((resolve21) => this.queue.push(resolve21));
       }
       static releaseLock() {
         if (this.queue.length > 0) {
@@ -2235,9 +2274,9 @@ var init_RunCommandTool = __esm({
           const chunks = { stdout: [], stderr: [] };
           proc.stdout?.on("data", (chunk) => chunks.stdout.push(chunk));
           proc.stderr?.on("data", (chunk) => chunks.stderr.push(chunk));
-          const exitCode = await new Promise((resolve20) => {
-            proc.on("exit", (code) => resolve20(code ?? 1));
-            proc.on("error", () => resolve20(1));
+          const exitCode = await new Promise((resolve21) => {
+            proc.on("exit", (code) => resolve21(code ?? 1));
+            proc.on("error", () => resolve21(1));
           });
           const stdout = Buffer.concat(chunks.stdout).toString("utf-8");
           const stderr = Buffer.concat(chunks.stderr).toString("utf-8");
@@ -2395,7 +2434,7 @@ var init_src2 = __esm({
         const message = `Content-Length: ${Buffer.byteLength(content, "utf8")}\r
 \r
 ${content}`;
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve21, reject) => {
           const timeoutHandle = setTimeout(() => {
             this.pendingRequests.delete(id);
             reject(new Error(`LSP request timeout after ${timeoutMs}ms: ${method}`));
@@ -2403,7 +2442,7 @@ ${content}`;
           this.pendingRequests.set(id, {
             resolve: (response) => {
               clearTimeout(timeoutHandle);
-              resolve20(response);
+              resolve21(response);
             },
             reject: (error) => {
               clearTimeout(timeoutHandle);
@@ -2556,9 +2595,9 @@ var init_SubShellTool = __esm({
               }
               throw e;
             }
-            await new Promise((resolve20) => {
-              proc.on("exit", () => resolve20());
-              proc.on("error", () => resolve20());
+            await new Promise((resolve21) => {
+              proc.on("exit", () => resolve21());
+              proc.on("error", () => resolve21());
             });
             return { content: `Successfully launched separate window for ${args2.worker_id}` };
           }
@@ -2637,27 +2676,42 @@ async function* walkFiles(root, current = root) {
     }
   }
 }
+function rgCandidates() {
+  if (process.platform === "win32") {
+    return [
+      "rg.exe",
+      "rg",
+      "C:\\Program Files\\ripgrep\\rg.exe",
+      "C:\\ProgramData\\chocolatey\\bin\\rg.exe"
+    ];
+  }
+  return ["rg", "/usr/bin/rg", "/usr/local/bin/rg", "/opt/homebrew/bin/rg"];
+}
 async function findRg() {
-  const candidates = ["rg", "C:\\Program Files\\ripgrep\\rg.exe"];
-  for (const bin of candidates) {
+  if (_rgCache.resolved) return _rgCache.value;
+  for (const bin of rgCandidates()) {
     try {
-      const exited = await new Promise((resolve20) => {
+      const exited = await new Promise((resolve21) => {
         try {
           const p = spawn4(bin, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
-          p.on("error", () => resolve20(null));
-          p.on("exit", (code) => resolve20(code));
+          p.on("error", () => resolve21(null));
+          p.on("exit", (code) => resolve21(code));
         } catch {
-          resolve20(null);
+          resolve21(null);
         }
       });
-      if (exited === 0) return bin;
+      if (exited === 0) {
+        _rgCache = { resolved: true, value: bin };
+        return bin;
+      }
     } catch {
     }
   }
+  _rgCache = { resolved: true, value: null };
   return null;
 }
 function runRg(bin, args2) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const p = spawn4(bin, args2, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2668,17 +2722,24 @@ function runRg(bin, args2) {
       stderr += d.toString("utf8");
     });
     p.on("error", (e) => {
-      resolve20({ stdout, stderr: stderr + (e?.message ?? ""), exitCode: -1 });
+      resolve21({ stdout, stderr: stderr + (e?.message ?? ""), exitCode: -1 });
     });
     p.on("exit", (code) => {
-      resolve20({ stdout, stderr, exitCode: code });
+      resolve21({ stdout, stderr, exitCode: code });
     });
   });
 }
-async function nodeGrepFallback(pattern, searchRoot, maxMatches, caseSensitive) {
+async function nodeGrepFallback(pattern, searchRoot, maxMatches, caseSensitive, include, exclude) {
   const regex = new RegExp(pattern, caseSensitive ? "" : "i");
   const matches2 = [];
+  const relPaths = [];
   for await (const relPath of walkFiles(searchRoot)) {
+    if (include && !include.test(relPath)) continue;
+    if (exclude && exclude.test(relPath)) continue;
+    relPaths.push(relPath);
+  }
+  relPaths.sort();
+  for (const relPath of relPaths) {
     if (matches2.length >= maxMatches) break;
     const fullPath = join6(searchRoot, relPath);
     try {
@@ -2698,7 +2759,7 @@ async function nodeGrepFallback(pattern, searchRoot, maxMatches, caseSensitive)
   }
   return matches2;
 }
-var MAX_GLOB_RESULTS, MAX_GREP_MATCHES, SKIP_DIRS, GlobFilesTool, GrepSearchTool;
+var MAX_GLOB_RESULTS, MAX_GREP_MATCHES, SKIP_DIRS, GlobFilesTool, _rgCache, GrepSearchTool;
 var init_SearchTools = __esm({
   "../core/src/tools/SearchTools.ts"() {
     "use strict";
@@ -2786,9 +2847,13 @@ var init_SearchTools = __esm({
         }
       }
     };
+    _rgCache = {
+      resolved: false,
+      value: null
+    };
     GrepSearchTool = class extends BaseTool {
       name = "grep_search";
-      description = "Search file contents for a regex pattern. Returns matching lines with file path and line number. Uses ripgrep (rg) when available, falls back to a built-in scanner otherwise.";
+      description = 'Search file contents for a regex pattern. Returns matching lines with file path and line number, sorted deterministically. Uses ripgrep (rg) when available \u2014 fast on large repos, respects .gitignore \u2014 and falls back to a built-in scanner otherwise. Optional include/exclude glob filters narrow which files are searched (e.g. include "*.ts", exclude "*.test.ts").';
       parameters = {
         type: "object",
         required: ["pattern"],
@@ -2804,6 +2869,14 @@ var init_SearchTools = __esm({
           case_sensitive: {
             type: "boolean",
             description: "Whether the search is case-sensitive (default: false)."
+          },
+          include: {
+            type: "string",
+            description: 'Optional glob of files to include (e.g. "*.ts", "src/**/*.tsx"). Passed to ripgrep as --glob.'
+          },
+          exclude: {
+            type: "string",
+            description: 'Optional glob of files to exclude (e.g. "*.test.ts", "dist/**"). Passed to ripgrep as a negated --glob.'
           }
         }
       };
@@ -2831,6 +2904,8 @@ var init_SearchTools = __esm({
           };
         }
         const caseSensitive = args2?.case_sensitive === true;
+        const include = typeof args2?.include === "string" && args2.include.trim() ? args2.include.trim() : void 0;
+        const exclude = typeof args2?.exclude === "string" && args2.exclude.trim() ? args2.exclude.trim() : void 0;
         const rg = await findRg();
         if (rg) {
           try {
@@ -2838,9 +2913,14 @@ var init_SearchTools = __esm({
               "--line-number",
               `--max-count=${MAX_GREP_MATCHES}`,
               "--no-heading",
-              "--color=never"
+              "--color=never",
+              // Deterministic output: sort by file path so repeated queries return
+              // identical ordering (ripgrep parallelises by default → non-stable).
+              "--sort=path"
             ];
             if (!caseSensitive) rgArgs.push("--ignore-case");
+            if (include) rgArgs.push("--glob", include);
+            if (exclude) rgArgs.push("--glob", `!${exclude}`);
             rgArgs.push("--", pattern, searchPath);
             const { stdout, stderr, exitCode } = await runRg(rg, rgArgs);
             if (exitCode !== 0 && exitCode !== 1) {
@@ -2860,15 +2940,28 @@ var init_SearchTools = __esm({
         }
         try {
           const isFile = statSync(searchPath).isFile();
+          const includeRe = include ? globToRegExp(include) : void 0;
+          const excludeRe = exclude ? globToRegExp(exclude) : void 0;
           let matches2;
           if (isFile) {
-            const content = await readFile4(searchPath, "utf8");
-            const regex = new RegExp(pattern, caseSensitive ? "" : "i");
-            const lines = content.split("\n");
             const relPath = args2?.path ?? searchPath;
-            matches2 = lines.flatMap((line, idx) => regex.test(line) ? [`${relPath}:${idx + 1}:${line}`] : []).slice(0, MAX_GREP_MATCHES);
+            if (includeRe && !includeRe.test(String(relPath)) || excludeRe && excludeRe.test(String(relPath))) {
+              matches2 = [];
+            } else {
+              const content = await readFile4(searchPath, "utf8");
+              const regex = new RegExp(pattern, caseSensitive ? "" : "i");
+              const lines = content.split("\n");
+              matches2 = lines.flatMap((line, idx) => regex.test(line) ? [`${relPath}:${idx + 1}:${line}`] : []).slice(0, MAX_GREP_MATCHES);
+            }
           } else {
-            matches2 = await nodeGrepFallback(pattern, searchPath, MAX_GREP_MATCHES, caseSensitive);
+            matches2 = await nodeGrepFallback(
+              pattern,
+              searchPath,
+              MAX_GREP_MATCHES,
+              caseSensitive,
+              includeRe,
+              excludeRe
+            );
           }
           if (matches2.length === 0) return { content: "No matches found." };
           const suffix = matches2.length >= MAX_GREP_MATCHES ? `
@@ -3361,13 +3454,164 @@ Pre-edit content backed up to: ${backedUpTo}`;
   }
 });
 
+// ../core/src/agent/namedAgents.ts
+import { readdirSync as readdirSync2, statSync as statSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join9 } from "path";
+function normalizeToolName(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  const lower = trimmed.toLowerCase();
+  const key = lower.replace(/[^a-z0-9]/g, "");
+  if (TOOL_NAME_ALIASES[key]) return TOOL_NAME_ALIASES[key];
+  return lower;
+}
+function discoverAgentFiles(cwd, homeDir) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const scope of [
+    { dir: join9(homeDir, ".msapling", "agents"), scope: "user" },
+    { dir: join9(cwd, ".msapling", "agents"), scope: "project" }
+  ]) {
+    const entries = safeReaddir(scope.dir);
+    for (const fname of entries) {
+      if (!fname.toLowerCase().endsWith(".md")) continue;
+      const path2 = join9(scope.dir, fname);
+      if (!isRegularFile(path2)) continue;
+      const base = fname.slice(0, -".md".length);
+      seen.set(base, { name: base, path: path2, scope: scope.scope });
+    }
+  }
+  return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync2(dir);
+  } catch {
+    return [];
+  }
+}
+function isRegularFile(p) {
+  try {
+    return statSync3(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function parseToolsValue(raw) {
+  if (raw === void 0) return void 0;
+  let s = raw.trim();
+  if (s === "") return void 0;
+  if (s === "*" || s.toLowerCase() === "all") return void 0;
+  if (s.startsWith("[") && s.endsWith("]")) s = s.slice(1, -1);
+  const parts = s.split(",").map((t) => t.trim().replace(/^['"]|['"]$/g, "")).map((t) => normalizeToolName(t)).filter(Boolean);
+  return [...new Set(parts)];
+}
+function parseAgentFile(text, fallbackName) {
+  const fm = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+  if (!fm) {
+    const body = text.trim();
+    const firstLine = body.split(/\r?\n/).find((l) => l.trim()) ?? "";
+    return {
+      name: fallbackName.toLowerCase(),
+      description: firstLine.replace(/^#\s+/, "").trim() || `(agent: ${fallbackName})`,
+      systemPrompt: body
+    };
+  }
+  const meta = fm[1];
+  const systemPrompt = text.slice(fm[0].length).trim();
+  const scalar = (key) => {
+    const m = meta.match(new RegExp(`^${key}[ \\t]*:[ \\t]*(.+)$`, "m"));
+    return m ? m[1].trim().replace(/^['"]|['"]$/g, "") : void 0;
+  };
+  const name = (scalar("name") ?? fallbackName).toLowerCase();
+  const description = scalar("description") ?? `(agent: ${name})`;
+  const model = scalar("model");
+  let tools;
+  const inlineTools = scalar("tools");
+  const blockMatch = meta.match(/^tools[ \t]*:[ \t]*\n((?:[ \t]*-[ \t]*.+\n?)+)/m);
+  if (blockMatch && (inlineTools === void 0 || inlineTools === "")) {
+    const items = blockMatch[1].split(/\r?\n/).map((l) => l.replace(/^[ \t]*-[ \t]*/, "").trim().replace(/^['"]|['"]$/g, "")).map((t) => normalizeToolName(t)).filter(Boolean);
+    tools = [...new Set(items)];
+  } else {
+    tools = parseToolsValue(inlineTools);
+  }
+  return { name, description, model, tools, systemPrompt };
+}
+function loadNamedAgents(cwd, homeDir) {
+  const out = [];
+  for (const file of discoverAgentFiles(cwd, homeDir)) {
+    let text;
+    try {
+      text = readFileSync2(file.path, "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseAgentFile(text, file.name);
+    out.push({
+      name: parsed.name,
+      description: parsed.description,
+      model: parsed.model,
+      tools: parsed.tools,
+      systemPrompt: parsed.systemPrompt,
+      path: file.path,
+      scope: file.scope
+    });
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const a of out) {
+    const prev = byName.get(a.name);
+    if (!prev || prev.scope === "user" && a.scope === "project") {
+      byName.set(a.name, a);
+    }
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function findNamedAgent(name, cwd, homeDir) {
+  const target = name.trim().toLowerCase();
+  return loadNamedAgents(cwd, homeDir).find((a) => a.name === target) ?? null;
+}
+var TOOL_NAME_ALIASES;
+var init_namedAgents = __esm({
+  "../core/src/agent/namedAgents.ts"() {
+    "use strict";
+    init_esm_shims();
+    TOOL_NAME_ALIASES = {
+      read: "read_file",
+      write: "write_file",
+      edit: "edit_file",
+      multiedit: "multi_edit_file",
+      patch: "patch_file",
+      move: "move_file",
+      delete: "delete_file",
+      bash: "bash_command",
+      shell: "bash_command",
+      run: "run_command",
+      glob: "glob_files",
+      grep: "grep_search",
+      ls: "list_directory",
+      list: "list_directory",
+      webfetch: "web_fetch",
+      websearch: "web_search",
+      fetch: "web_fetch",
+      search: "web_search",
+      task: "dispatch_agent",
+      dispatch: "dispatch_agent",
+      todowrite: "todo_write",
+      todoread: "todo_read",
+      notebookread: "notebook_read",
+      notebookedit: "notebook_edit_cell"
+    };
+  }
+});
+
 // ../core/src/tools/DispatchAgentTool.ts
+import { homedir as homedir5 } from "os";
 var SUB_AGENT_TIMEOUT_MS, MAX_PROMPT_CHARS, MAX_RESPONSE_CHARS, DEFAULT_SUB_AGENT_MODEL, DispatchAgentTool;
 var init_DispatchAgentTool = __esm({
   "../core/src/tools/DispatchAgentTool.ts"() {
     "use strict";
     init_esm_shims();
     init_BaseTool();
+    init_namedAgents();
     SUB_AGENT_TIMEOUT_MS = 12e4;
     MAX_PROMPT_CHARS = 8e3;
     MAX_RESPONSE_CHARS = 16e3;
@@ -3383,6 +3627,10 @@ var init_DispatchAgentTool = __esm({
             type: "string",
             description: `The full self-contained prompt for the sub-agent. Include all necessary context \u2014 the sub-agent does not have access to prior conversation history. Maximum ${MAX_PROMPT_CHARS} characters.`
           },
+          agent: {
+            type: "string",
+            description: "Optional NAMED subagent to run (defined in .msapling/agents/<name>.md). The named agent supplies its own system prompt, model, and tool allowlist \u2014 unlike the anonymous dispatch path it CAN run tools (gated by the permission system). Run /agents to list available named agents. When omitted, an anonymous read/reasoning sub-agent runs."
+          },
           description: {
             type: "string",
             description: 'Short human-readable label for this sub-task (e.g. "Summarise auth.ts"). Appears in the session log alongside the result.'
@@ -3400,11 +3648,27 @@ var init_DispatchAgentTool = __esm({
       client;
       parentChatId;
       projectRoot;
+      onSubagentStop;
+      runNamedAgent;
       constructor(options) {
         super();
         this.client = options.client;
         this.parentChatId = options.parentChatId ?? void 0;
         this.projectRoot = options.projectRoot;
+        this.onSubagentStop = options.onSubagentStop;
+        this.runNamedAgent = options.runNamedAgent;
+      }
+      /** Resolve the user home dir, preferring env overrides so test isolation
+       *  (HOME / USERPROFILE) is honored exactly like outputStyle.ts. */
+      resolveHome() {
+        return process.env.HOME || process.env.USERPROFILE || homedir5();
+      }
+      /** Fire the subagent-stop callback defensively — it must never throw. */
+      signalStop(info) {
+        try {
+          this.onSubagentStop?.(info);
+        } catch {
+        }
       }
       async execute(args2, _projectRoot) {
         if (!args2?.prompt || typeof args2.prompt !== "string" || args2.prompt.trim() === "") {
@@ -3414,9 +3678,19 @@ var init_DispatchAgentTool = __esm({
           };
         }
         const prompt4 = args2.prompt.trim().slice(0, MAX_PROMPT_CHARS);
-        const model = typeof args2.model === "string" && args2.model.trim() ? args2.model.trim() : DEFAULT_SUB_AGENT_MODEL;
         const chatId = typeof args2.chat_id === "string" && args2.chat_id.trim() ? args2.chat_id.trim() : this.parentChatId;
-        const description = typeof args2.description === "string" && args2.description.trim() ? args2.description.trim() : "sub-task";
+        let named = null;
+        if (typeof args2.agent === "string" && args2.agent.trim()) {
+          named = findNamedAgent(args2.agent.trim(), this.projectRoot, this.resolveHome());
+          if (!named) {
+            return {
+              content: `dispatch_agent error: no named agent "${args2.agent.trim()}" found in .msapling/agents/. Run /agents to list available agents.`,
+              isError: true
+            };
+          }
+        }
+        const model = typeof args2.model === "string" && args2.model.trim() ? args2.model.trim() : named?.model && named.model.trim() ? named.model.trim() : DEFAULT_SUB_AGENT_MODEL;
+        const description = typeof args2.description === "string" && args2.description.trim() ? args2.description.trim() : named ? `agent:${named.name}` : "sub-task";
         let response = "";
         const timeoutPromise = new Promise(
           (_, reject) => setTimeout(
@@ -3425,10 +3699,28 @@ var init_DispatchAgentTool = __esm({
           )
         );
         const streamPromise = (async () => {
+          if (named && this.runNamedAgent) {
+            await this.runNamedAgent({
+              agent: named,
+              prompt: prompt4,
+              model,
+              chatId,
+              onContent: (chunk) => {
+                response += chunk;
+              }
+            });
+            return;
+          }
+          const effectivePrompt = named ? `[System prompt for agent "${named.name}"]
+${named.systemPrompt}
+
+---
+
+${prompt4}`.slice(0, MAX_PROMPT_CHARS) : prompt4;
           const stream = this.client.streamChat({
-            prompt: prompt4,
+            prompt: effectivePrompt,
             model,
-            // No tools — sub-agent is read/reasoning only.
+            // No tools — sub-agent is read/reasoning only on this path.
             tools: [],
             ...chatId ? { chat_id: chatId } : {},
             // Forward project root as context so the backend can enrich the prompt
@@ -3444,12 +3736,14 @@ var init_DispatchAgentTool = __esm({
         try {
           await Promise.race([streamPromise, timeoutPromise]);
         } catch (e) {
+          this.signalStop({ description, ok: false, chars: response.length, error: e?.message });
           return {
             content: `dispatch_agent error [${description}]: ${e.message}`,
             isError: true
           };
         }
         if (!response.trim()) {
+          this.signalStop({ description, ok: false, chars: 0, error: "empty response" });
           return {
             content: `dispatch_agent [${description}]: Sub-agent returned an empty response.`,
             isError: true
@@ -3461,6 +3755,7 @@ var init_DispatchAgentTool = __esm({
 
 ... [TRUNCATED: Sub-agent response exceeded ${MAX_RESPONSE_CHARS} characters]`;
         }
+        this.signalStop({ description, ok: true, chars: finalResponse.length });
         return {
           content: `[dispatch_agent: ${description}]
 
@@ -3776,6 +4071,83 @@ Content-Type: ${contentType}
   }
 });
 
+// ../core/src/tools/WebSearchTool.ts
+var DEFAULT_MAX_RESULTS, MAX_RESULTS_CEILING, MAX_SNIPPET_CHARS, WebSearchTool;
+var init_WebSearchTool = __esm({
+  "../core/src/tools/WebSearchTool.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_BaseTool();
+    DEFAULT_MAX_RESULTS = 5;
+    MAX_RESULTS_CEILING = 10;
+    MAX_SNIPPET_CHARS = 500;
+    WebSearchTool = class extends BaseTool {
+      name = "web_search";
+      description = "Search the live web for current information and return a ranked list of result titles, URLs, and snippets. Use this to find documentation, recent events, library versions, error explanations, or any topic where you need up-to-date sources you do not already have a URL for. Pair with web_fetch to read a specific result in full. Runs through the MSapling backend so no API keys are needed client-side.";
+      parameters = {
+        type: "object",
+        required: ["query"],
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query. Be specific for better results."
+          },
+          max_results: {
+            type: "number",
+            description: `Maximum number of results to return. Default: ${DEFAULT_MAX_RESULTS}. Max: ${MAX_RESULTS_CEILING}.`
+          }
+        }
+      };
+      client;
+      constructor(options) {
+        super();
+        this.client = options.client;
+      }
+      async execute(args2, _projectRoot) {
+        const rawQuery = args2?.query;
+        if (!rawQuery || typeof rawQuery !== "string" || rawQuery.trim() === "") {
+          return {
+            content: 'Error: web_search requires a non-empty "query" argument.',
+            isError: true
+          };
+        }
+        const query = rawQuery.trim();
+        let maxResults = DEFAULT_MAX_RESULTS;
+        if (typeof args2?.max_results === "number" && args2.max_results > 0) {
+          maxResults = Math.min(Math.floor(args2.max_results), MAX_RESULTS_CEILING);
+        }
+        let resp;
+        try {
+          resp = await this.client.webSearch(query, maxResults);
+        } catch (e) {
+          return {
+            content: `Error: web_search failed \u2014 ${e?.message ?? String(e)}`,
+            isError: true
+          };
+        }
+        const results = Array.isArray(resp?.results) ? resp.results : [];
+        if (results.length === 0) {
+          return {
+            content: `[web_search] No results for "${query}" (provider: ${resp?.provider ?? "none"}). Try rephrasing the query or use web_fetch if you already have a URL.`
+          };
+        }
+        const confidence = results[0]?.confidence ?? 0;
+        const confidenceLabel = confidence >= 0.9 ? "high" : "low (scraped)";
+        const header = `[web_search: ${results.length} result(s) for "${query}" \u2014 provider: ${resp.provider}, confidence: ${confidenceLabel}]
+
+`;
+        const body = results.map((r, i) => {
+          const snippet = (r.snippet || "").slice(0, MAX_SNIPPET_CHARS);
+          return `${i + 1}. ${r.title || "(untitled)"}
+   ${r.url || ""}
+   ${snippet}`;
+        }).join("\n\n");
+        return { content: header + body };
+      }
+    };
+  }
+});
+
 // ../core/src/tools/BashTool.ts
 import { resolve as resolve7, normalize as normalize6, relative as relative7, isAbsolute as isAbsolute7 } from "path";
 import { spawn as spawn5 } from "child_process";
@@ -3923,12 +4295,12 @@ Command: ${command}`,
         proc.stdout?.on("data", (chunk) => chunks.stdout.push(chunk));
         proc.stderr?.on("data", (chunk) => chunks.stderr.push(chunk));
         const timeoutPromise = new Promise(
-          (resolve20) => setTimeout(() => resolve20("timeout"), timeoutMs)
+          (resolve21) => setTimeout(() => resolve21("timeout"), timeoutMs)
         );
         const processPromise = (async () => {
-          const exitCode2 = await new Promise((resolve20) => {
-            proc.on("exit", (code) => resolve20(code ?? 1));
-            proc.on("error", () => resolve20(1));
+          const exitCode2 = await new Promise((resolve21) => {
+            proc.on("exit", (code) => resolve21(code ?? 1));
+            proc.on("error", () => resolve21(1));
           });
           const stdout2 = Buffer.concat(chunks.stdout).toString("utf-8");
           const stderr2 = Buffer.concat(chunks.stderr).toString("utf-8");
@@ -3962,8 +4334,315 @@ ${stderr}`;
   }
 });
 
+// ../core/src/tools/BackgroundShellTool.ts
+import { resolve as resolve8, normalize as normalize7, relative as relative8, isAbsolute as isAbsolute8 } from "path";
+import { spawn as spawn6 } from "child_process";
+function formatBackgroundShells(shells) {
+  if (shells.length === 0) return "No background shells.";
+  return shells.map((s) => {
+    const dur = ((s.endedAt ?? Date.now()) - s.startedAt) / 1e3;
+    const exit = s.exitCode !== void 0 && s.exitCode !== null ? ` exit=${s.exitCode}` : "";
+    const pid = s.pid !== void 0 ? ` pid=${s.pid}` : "";
+    return `[${s.id}] ${s.status.toUpperCase()}${pid}${exit} ${dur.toFixed(1)}s  $ ${s.command}`;
+  }).join("\n");
+}
+function resolveCwd(projectRoot, rawArg) {
+  let cwd = projectRoot;
+  if (typeof rawArg === "string" && rawArg.trim()) {
+    const raw = rawArg.trim();
+    const resolved = isAbsolute8(raw) ? normalize7(raw) : resolve8(projectRoot, raw);
+    const rel = relative8(projectRoot, resolved);
+    if (rel.startsWith("..") || isAbsolute8(rel)) {
+      return { error: `Security Block: cwd "${raw}" resolves outside the project root.` };
+    }
+    cwd = resolved;
+  }
+  return { cwd };
+}
+var MAX_BUFFER_BYTES, MAX_FINISHED_RETAINED, BackgroundShellRegistryImpl, BackgroundShellRegistry, BashBackgroundTool, ListBackgroundShellsTool, ReadBackgroundShellTool, KillBackgroundShellTool;
+var init_BackgroundShellTool = __esm({
+  "../core/src/tools/BackgroundShellTool.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_BaseTool();
+    init_BashTool();
+    MAX_BUFFER_BYTES = 256 * 1024;
+    MAX_FINISHED_RETAINED = 50;
+    BackgroundShellRegistryImpl = class {
+      shells = /* @__PURE__ */ new Map();
+      counter = 0;
+      /** Monotonic, human-readable id: bg-1, bg-2, … */
+      nextId() {
+        this.counter += 1;
+        return `bg-${this.counter}`;
+      }
+      /**
+       * Register an already-spawned child process and start buffering its output.
+       * Returns the assigned shell id.
+       */
+      register(proc, command, cwd) {
+        const id = this.nextId();
+        const entry = {
+          id,
+          command,
+          cwd,
+          status: "running",
+          pid: proc.pid,
+          startedAt: Date.now(),
+          proc,
+          buffer: "",
+          bufferTruncated: false
+        };
+        this.shells.set(id, entry);
+        const append = (chunk) => {
+          entry.buffer += chunk.toString("utf-8");
+          if (entry.buffer.length > MAX_BUFFER_BYTES) {
+            entry.buffer = entry.buffer.slice(entry.buffer.length - MAX_BUFFER_BYTES);
+            entry.bufferTruncated = true;
+          }
+        };
+        proc.stdout?.on("data", append);
+        proc.stderr?.on("data", append);
+        proc.on("error", (err) => {
+          if (entry.status === "running") {
+            entry.status = "error";
+            entry.endedAt = Date.now();
+            entry.buffer += `
+[spawn error: ${err.message}]`;
+          }
+          this.reapFinished();
+        });
+        proc.on("exit", (code, signal) => {
+          if (entry.status === "running") {
+            entry.status = "exited";
+          }
+          entry.exitCode = code;
+          entry.endedAt = Date.now();
+          if (signal) entry.buffer += `
+[terminated by signal ${signal}]`;
+          this.reapFinished();
+        });
+        return id;
+      }
+      /** Evict the oldest finished shells once we exceed the retention cap. */
+      reapFinished() {
+        const finished = [...this.shells.values()].filter((s) => s.status !== "running").sort((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+        let excess = finished.length - MAX_FINISHED_RETAINED;
+        for (let i = 0; i < finished.length && excess > 0; i++, excess--) {
+          this.shells.delete(finished[i].id);
+        }
+      }
+      /** Public view of all tracked shells, newest first. */
+      list() {
+        return [...this.shells.values()].sort((a, b) => b.startedAt - a.startedAt).map((s) => this.toInfo(s));
+      }
+      get(id) {
+        const s = this.shells.get(id);
+        return s ? this.toInfo(s) : void 0;
+      }
+      /**
+       * Read the buffered output of a shell.  `lines` (optional) tails the last N
+       * lines.  Returns null if the id is unknown.
+       */
+      readOutput(id, lines) {
+        const s = this.shells.get(id);
+        if (!s) return null;
+        let output = s.buffer;
+        if (lines && lines > 0) {
+          const all = output.split("\n");
+          output = all.slice(-lines).join("\n");
+        }
+        return { output, truncated: s.bufferTruncated };
+      }
+      /**
+       * Terminate a running shell.  Returns:
+       *   - 'killed'    on success
+       *   - 'not-found' if the id is unknown
+       *   - 'already'   if the shell had already finished
+       */
+      kill(id) {
+        const s = this.shells.get(id);
+        if (!s) return "not-found";
+        if (s.status !== "running") return "already";
+        s.status = "killed";
+        s.endedAt = Date.now();
+        try {
+          s.proc.kill();
+        } catch {
+        }
+        return "killed";
+      }
+      /** Kill every running shell (used on CLI shutdown). */
+      killAll() {
+        for (const s of this.shells.values()) {
+          if (s.status === "running") {
+            s.status = "killed";
+            s.endedAt = Date.now();
+            try {
+              s.proc.kill();
+            } catch {
+            }
+          }
+        }
+      }
+      /** Test-only: drop all tracked shells (does not kill — caller's responsibility). */
+      _reset() {
+        this.shells.clear();
+        this.counter = 0;
+      }
+      toInfo(s) {
+        return {
+          id: s.id,
+          command: s.command,
+          cwd: s.cwd,
+          status: s.status,
+          pid: s.pid,
+          exitCode: s.exitCode,
+          startedAt: s.startedAt,
+          endedAt: s.endedAt
+        };
+      }
+    };
+    BackgroundShellRegistry = new BackgroundShellRegistryImpl();
+    BashBackgroundTool = class extends BaseTool {
+      name = "bash_background";
+      description = "Launch a shell command in the BACKGROUND and return immediately with a shell id. Use for long-running processes (dev servers, watchers, `tail -f`) that should keep running while you continue working. Inspect output with read_background_shell, list with list_background_shells, and stop with kill_background_shell. Runs via bash (Unix) / cmd (Windows) so shell operators work. For commands that must finish before you proceed, use bash_command instead.";
+      parameters = {
+        type: "object",
+        required: ["command"],
+        properties: {
+          command: {
+            type: "string",
+            description: "The shell command to run in the background. May contain pipes, redirects, and other shell operators."
+          },
+          cwd: {
+            type: "string",
+            description: "Optional working directory (relative to project root). Defaults to the project root."
+          }
+        }
+      };
+      async execute(args2, projectRoot) {
+        if (!args2?.command || typeof args2.command !== "string" || args2.command.trim() === "") {
+          return {
+            content: 'Error: bash_background requires a non-empty "command" argument.',
+            isError: true
+          };
+        }
+        const command = args2.command;
+        const block = BashTool.checkBlocklist(command);
+        if (block.blocked) {
+          return {
+            content: `Security Block: command rejected \u2014 ${block.reason}.
+Command: ${command}`,
+            isError: true
+          };
+        }
+        const cwdResult = resolveCwd(projectRoot, args2.cwd);
+        if ("error" in cwdResult) {
+          return { content: cwdResult.error, isError: true };
+        }
+        const cwd = cwdResult.cwd;
+        const isWindows = process.platform === "win32";
+        const shellArgv = isWindows ? ["cmd", "/c", command] : ["bash", "-c", command];
+        let proc;
+        try {
+          proc = spawn6(shellArgv[0], shellArgv.slice(1), {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false
+          });
+        } catch (e) {
+          return { content: `Error: failed to spawn background shell: ${e.message}`, isError: true };
+        }
+        const id = BackgroundShellRegistry.register(proc, command, cwd);
+        return {
+          content: `Started background shell ${id} (pid ${proc.pid ?? "?"}).
+Command: ${command}
+Use read_background_shell with shell_id="${id}" to read its output, or kill_background_shell to stop it.`
+        };
+      }
+    };
+    ListBackgroundShellsTool = class extends BaseTool {
+      name = "list_background_shells";
+      description = "List all background shells started in this session (running and finished), with their id, status, pid, exit code, and command.";
+      parameters = {
+        type: "object",
+        properties: {}
+      };
+      async execute() {
+        return { content: formatBackgroundShells(BackgroundShellRegistry.list()) };
+      }
+    };
+    ReadBackgroundShellTool = class extends BaseTool {
+      name = "read_background_shell";
+      description = "Read the buffered output of a background shell by its id. Optionally tail only the last N lines.";
+      parameters = {
+        type: "object",
+        required: ["shell_id"],
+        properties: {
+          shell_id: {
+            type: "string",
+            description: 'The background shell id (e.g. "bg-1") returned by bash_background.'
+          },
+          lines: {
+            type: "number",
+            description: "Optional: return only the last N lines of buffered output."
+          }
+        }
+      };
+      async execute(args2) {
+        const id = typeof args2?.shell_id === "string" ? args2.shell_id.trim() : "";
+        if (!id) {
+          return { content: 'Error: read_background_shell requires a "shell_id" argument.', isError: true };
+        }
+        const lines = typeof args2?.lines === "number" && args2.lines > 0 ? Math.floor(args2.lines) : void 0;
+        const read = BackgroundShellRegistry.readOutput(id, lines);
+        if (!read) {
+          return { content: `Error: no background shell with id "${id}".`, isError: true };
+        }
+        const info = BackgroundShellRegistry.get(id);
+        const header = `[${info.id}] ${info.status.toUpperCase()}` + (info.exitCode !== void 0 && info.exitCode !== null ? ` exit=${info.exitCode}` : "") + `  $ ${info.command}
+`;
+        const body = read.output.trim() === "" ? "(no output yet)" : read.output;
+        const truncNote = read.truncated ? "\n... [output buffer truncated to most recent 256 KB]" : "";
+        return { content: header + body + truncNote };
+      }
+    };
+    KillBackgroundShellTool = class extends BaseTool {
+      name = "kill_background_shell";
+      description = "Terminate a running background shell by its id.";
+      parameters = {
+        type: "object",
+        required: ["shell_id"],
+        properties: {
+          shell_id: {
+            type: "string",
+            description: 'The background shell id (e.g. "bg-1") to terminate.'
+          }
+        }
+      };
+      async execute(args2) {
+        const id = typeof args2?.shell_id === "string" ? args2.shell_id.trim() : "";
+        if (!id) {
+          return { content: 'Error: kill_background_shell requires a "shell_id" argument.', isError: true };
+        }
+        const result = BackgroundShellRegistry.kill(id);
+        switch (result) {
+          case "killed":
+            return { content: `Killed background shell ${id}.` };
+          case "already":
+            return { content: `Background shell ${id} had already finished.` };
+          case "not-found":
+          default:
+            return { content: `Error: no background shell with id "${id}".`, isError: true };
+        }
+      }
+    };
+  }
+});
+
 // ../core/src/tools/NotebookReadTool.ts
-import { resolve as resolve8, normalize as normalize7, relative as relative8, isAbsolute as isAbsolute8, extname } from "path";
+import { resolve as resolve9, normalize as normalize8, relative as relative9, isAbsolute as isAbsolute9, extname } from "path";
 import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 function joinSource(source) {
@@ -4118,9 +4797,9 @@ var init_NotebookReadTool = __esm({
             isError: true
           };
         }
-        const absPath = isAbsolute8(rawPath) ? normalize7(rawPath) : resolve8(projectRoot, rawPath);
-        const rel = relative8(projectRoot, absPath);
-        if (rel.startsWith("..") || isAbsolute8(rel)) {
+        const absPath = isAbsolute9(rawPath) ? normalize8(rawPath) : resolve9(projectRoot, rawPath);
+        const rel = relative9(projectRoot, absPath);
+        if (rel.startsWith("..") || isAbsolute9(rel)) {
           return {
             content: `Security Block: path "${rawPath}" resolves outside the project root.`,
             isError: true
@@ -4188,10 +4867,10 @@ _(Note: notebook has ${nb.cells.length} cells; only first ${MAX_CELLS} shown.)_`
 });
 
 // ../core/src/tools/NotebookEditTool.ts
-import { resolve as resolve9, normalize as normalize8, relative as relative9, isAbsolute as isAbsolute9, extname as extname2, join as join10 } from "path";
+import { resolve as resolve10, normalize as normalize9, relative as relative10, isAbsolute as isAbsolute10, extname as extname2, join as join11 } from "path";
 import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { randomBytes as randomBytes5 } from "crypto";
 function normaliseSource(source) {
   if (source === "") return [];
@@ -4312,9 +4991,9 @@ var init_NotebookEditTool = __esm({
             isError: true
           };
         }
-        const absPath = isAbsolute9(rawPath) ? normalize8(rawPath) : resolve9(projectRoot, rawPath);
-        const rel = relative9(projectRoot, absPath);
-        if (rel.startsWith("..") || isAbsolute9(rel)) {
+        const absPath = isAbsolute10(rawPath) ? normalize9(rawPath) : resolve10(projectRoot, rawPath);
+        const rel = relative10(projectRoot, absPath);
+        if (rel.startsWith("..") || isAbsolute10(rel)) {
           return {
             content: `Security Block: path "${rawPath}" resolves outside the project root.`,
             isError: true
@@ -4371,13 +5050,13 @@ var init_NotebookEditTool = __esm({
           const filename = absPath.split(/[\\/]/).pop() ?? "notebook.ipynb";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const suffix = randomBytes5(4).toString("hex");
-          const backupPath = join10(
-            homedir5(),
+          const backupPath = join11(
+            homedir6(),
             ".msapling",
             "backups",
             `${filename}.backup-${stamp}-${suffix}.bak`
           );
-          await mkdir3(join10(homedir5(), ".msapling", "backups"), { recursive: true });
+          await mkdir3(join11(homedir6(), ".msapling", "backups"), { recursive: true });
           await writeFile3(backupPath, rawJson, "utf8");
           backedUpTo = backupPath;
         } catch {
@@ -4447,10 +5126,10 @@ Backup: ${backedUpTo}`;
 });
 
 // ../core/src/tools/MultiEditFileTool.ts
-import { resolve as resolve10, normalize as normalize9, relative as relative10, isAbsolute as isAbsolute10, join as join11 } from "path";
+import { resolve as resolve11, normalize as normalize10, relative as relative11, isAbsolute as isAbsolute11, join as join12 } from "path";
 import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { randomBytes as randomBytes6 } from "crypto";
 var MAX_EDITS, MultiEditFileTool;
 var init_MultiEditFileTool = __esm({
@@ -4544,9 +5223,9 @@ var init_MultiEditFileTool = __esm({
             };
           }
         }
-        const normalizedTarget = isAbsolute10(args2.path) ? normalize9(args2.path) : resolve10(projectRoot, args2.path.trim());
-        const rel = relative10(projectRoot, normalizedTarget);
-        if (rel.startsWith("..") || isAbsolute10(rel)) {
+        const normalizedTarget = isAbsolute11(args2.path) ? normalize10(args2.path) : resolve11(projectRoot, args2.path.trim());
+        const rel = relative11(projectRoot, normalizedTarget);
+        if (rel.startsWith("..") || isAbsolute11(rel)) {
           return {
             content: `Security Block: path "${args2.path}" resolves outside the project root.`,
             isError: true
@@ -4614,13 +5293,13 @@ No changes were written (atomic: all-or-nothing).`,
           const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const suffix = randomBytes6(4).toString("hex");
-          const backupPath = join11(
-            homedir6(),
+          const backupPath = join12(
+            homedir7(),
             ".msapling",
             "backups",
             `${filename}.backup-${stamp}-${suffix}.bak`
           );
-          await mkdir4(join11(homedir6(), ".msapling", "backups"), { recursive: true });
+          await mkdir4(join12(homedir7(), ".msapling", "backups"), { recursive: true });
           await writeFile4(backupPath, originalContent, "utf8");
           backedUpTo = backupPath;
         } catch {
@@ -4648,14 +5327,14 @@ Pre-edit content backed up to: ${backedUpTo}`;
 });
 
 // ../core/src/tools/MoveFileTool.ts
-import { resolve as resolve11, normalize as normalize10, relative as relative11, isAbsolute as isAbsolute11, dirname as dirname2 } from "path";
+import { resolve as resolve12, normalize as normalize11, relative as relative12, isAbsolute as isAbsolute12, dirname as dirname2 } from "path";
 import { rename, mkdir as mkdir5, copyFile, rm, stat as stat2, readdir as readdir2 } from "fs/promises";
-import { existsSync as existsSync10, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, statSync as statSync4 } from "fs";
 import { randomBytes as randomBytes7 } from "crypto";
 function containedPath(p, root) {
-  const abs = isAbsolute11(p) ? normalize10(p) : resolve11(root, p.trim());
-  const rel = relative11(root, abs);
-  if (rel.startsWith("..") || isAbsolute11(rel)) {
+  const abs = isAbsolute12(p) ? normalize11(p) : resolve12(root, p.trim());
+  const rel = relative12(root, abs);
+  if (rel.startsWith("..") || isAbsolute12(rel)) {
     return { ok: false, reason: `path "${p}" resolves outside the project root` };
   }
   return { ok: true, abs };
@@ -4664,8 +5343,8 @@ async function copyDir(src, dst) {
   await mkdir5(dst, { recursive: true });
   const entries = await readdir2(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = resolve11(src, entry.name);
-    const dstPath = resolve11(dst, entry.name);
+    const srcPath = resolve12(src, entry.name);
+    const dstPath = resolve12(dst, entry.name);
     if (entry.isDirectory()) {
       await copyDir(srcPath, dstPath);
     } else {
@@ -4676,18 +5355,18 @@ async function copyDir(src, dst) {
 async function backupFile(absPath) {
   try {
     const { readFile: readFile30, writeFile: writeFile19, mkdir: mkdir10 } = await import("fs/promises");
-    const { homedir: homedir22 } = await import("os");
-    const { join: join39 } = await import("path");
+    const { homedir: homedir25 } = await import("os");
+    const { join: join41 } = await import("path");
     const filename = absPath.split(/[\\/]/).pop() ?? "file";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const suffix = randomBytes7(4).toString("hex");
-    const backupPath = join39(
-      homedir22(),
+    const backupPath = join41(
+      homedir25(),
       ".msapling",
       "backups",
       `${filename}.backup-${stamp}-${suffix}.bak`
     );
-    await mkdir10(join39(homedir22(), ".msapling", "backups"), { recursive: true });
+    await mkdir10(join41(homedir25(), ".msapling", "backups"), { recursive: true });
     const content = await readFile30(absPath, "utf8");
     await writeFile19(backupPath, content, "utf8");
     return backupPath;
@@ -4747,7 +5426,7 @@ var init_MoveFileTool = __esm({
             isError: true
           };
         }
-        const srcStat = statSync3(absSrc);
+        const srcStat = statSync4(absSrc);
         const srcIsDir = srcStat.isDirectory();
         let rawDst = args2.destination.trim();
         const dstPrelimCheck = containedPath(rawDst, projectRoot);
@@ -4755,11 +5434,11 @@ var init_MoveFileTool = __esm({
           return { content: `Security Block: ${dstPrelimCheck.reason}.`, isError: true };
         }
         let absDst = dstPrelimCheck.abs;
-        if (existsSync10(absDst) && statSync3(absDst).isDirectory() && !srcIsDir) {
+        if (existsSync10(absDst) && statSync4(absDst).isDirectory() && !srcIsDir) {
           const srcName = absSrc.split(/[\\/]/).pop();
-          absDst = resolve11(absDst, srcName);
-          const rel2 = relative11(projectRoot, absDst);
-          if (rel2.startsWith("..") || isAbsolute11(rel2)) {
+          absDst = resolve12(absDst, srcName);
+          const rel2 = relative12(projectRoot, absDst);
+          if (rel2.startsWith("..") || isAbsolute12(rel2)) {
             return {
               content: `Security Block: adjusted destination "${absDst}" resolves outside the project root.`,
               isError: true
@@ -4780,7 +5459,7 @@ var init_MoveFileTool = __esm({
               isError: true
             };
           }
-          if (!statSync3(absDst).isDirectory()) {
+          if (!statSync4(absDst).isDirectory()) {
             backedUpTo = await backupFile(absDst);
           }
         }
@@ -4839,7 +5518,7 @@ Overwritten destination backed up to: ${backedUpTo}`;
 });
 
 // ../core/src/tools/DeleteFileTool.ts
-import { resolve as resolve12, normalize as normalize11, relative as relative12, isAbsolute as isAbsolute12, join as join13 } from "path";
+import { resolve as resolve13, normalize as normalize12, relative as relative13, isAbsolute as isAbsolute13, join as join14 } from "path";
 import { rm as rm2, stat as stat3 } from "fs/promises";
 import { randomBytes as randomBytes8 } from "crypto";
 var DeleteFileTool;
@@ -4874,15 +5553,15 @@ var init_DeleteFileTool = __esm({
         }
         const rawPath = args2.path.trim();
         const recursive = args2.recursive === true;
-        const abs = isAbsolute12(rawPath) ? normalize11(rawPath) : resolve12(projectRoot, rawPath);
-        const rel = relative12(projectRoot, abs);
-        if (rel.startsWith("..") || isAbsolute12(rel)) {
+        const abs = isAbsolute13(rawPath) ? normalize12(rawPath) : resolve13(projectRoot, rawPath);
+        const rel = relative13(projectRoot, abs);
+        if (rel.startsWith("..") || isAbsolute13(rel)) {
           return {
             content: `Security Block: path "${rawPath}" resolves outside the project root.`,
             isError: true
           };
         }
-        if (rel === "" || abs === normalize11(projectRoot)) {
+        if (rel === "" || abs === normalize12(projectRoot)) {
           return {
             content: "Security Block: refusing to delete the project root directory.",
             isError: true
@@ -4915,13 +5594,13 @@ var init_DeleteFileTool = __esm({
         if (isFile) {
           try {
             const { readFile: readFile30, writeFile: writeFile19, mkdir: mkdir10 } = await import("fs/promises");
-            const { homedir: homedir22 } = await import("os");
+            const { homedir: homedir25 } = await import("os");
             const existingContent = await readFile30(abs, "utf8");
             const filename = abs.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
             const suffix = randomBytes8(4).toString("hex");
-            const backupPath = join13(homedir22(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
-            await mkdir10(join13(homedir22(), ".msapling", "backups"), { recursive: true });
+            const backupPath = join14(homedir25(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+            await mkdir10(join14(homedir25(), ".msapling", "backups"), { recursive: true });
             await writeFile19(backupPath, existingContent, "utf8");
             backedUpTo = backupPath;
           } catch {
@@ -4953,6 +5632,65 @@ Backup: ${backedUpTo}`;
   }
 });
 
+// ../core/src/tools/PlanModeTools.ts
+var MAX_PLAN_CHARS, EnterPlanModeTool, ExitPlanModeTool;
+var init_PlanModeTools = __esm({
+  "../core/src/tools/PlanModeTools.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_BaseTool();
+    MAX_PLAN_CHARS = 2e4;
+    EnterPlanModeTool = class extends BaseTool {
+      name = "enter_plan_mode";
+      description = "Switch into Plan Mode for a complex task that needs exploration before any changes. In Plan Mode you may ONLY use read-only tools (read_file, grep, glob, list_directory, web_fetch, web_search, etc.) \u2014 file writes and shell commands are blocked. Use this when the task is non-trivial and you should design an approach first. When your plan is ready, call exit_plan_mode to present it for the user's approval before executing.";
+      parameters = {
+        type: "object",
+        properties: {}
+      };
+      async execute(_args, _projectRoot) {
+        return {
+          content: "Entered Plan Mode. This is a READ-ONLY exploration and design phase.\n1. Thoroughly explore the codebase to understand existing patterns.\n2. Identify similar features and architectural approaches.\n3. Consider multiple approaches and their trade-offs.\n4. Design a concrete implementation strategy.\n5. When ready, call exit_plan_mode with your finished plan for approval.\nDo NOT write or edit files or run commands until the plan is approved."
+        };
+      }
+    };
+    ExitPlanModeTool = class _ExitPlanModeTool extends BaseTool {
+      name = "exit_plan_mode";
+      description = "Present your finished implementation plan to the user for approval and exit Plan Mode. Only call this once you have a concrete plan. The plan is shown to the user; if they approve, Plan Mode is lifted and you may begin making changes. If they reject, you remain in Plan Mode and should revise the plan based on their feedback. Pass the full plan as Markdown in `plan`.";
+      parameters = {
+        type: "object",
+        required: ["plan"],
+        properties: {
+          plan: {
+            type: "string",
+            description: "The full implementation plan, formatted as Markdown. Describe the steps you will take, the files you will change, and any trade-offs."
+          }
+        }
+      };
+      /** Validate the plan argument. Returns an error string or null when valid. */
+      static validatePlan(args2) {
+        const plan = args2?.plan;
+        if (!plan || typeof plan !== "string" || plan.trim() === "") {
+          return 'Error: exit_plan_mode requires a non-empty "plan" argument (the implementation plan to present for approval).';
+        }
+        if (plan.length > MAX_PLAN_CHARS) {
+          return `Error: plan is too long (${plan.length} chars; max ${MAX_PLAN_CHARS}). Summarize the plan.`;
+        }
+        return null;
+      }
+      async execute(args2, _projectRoot) {
+        const err = _ExitPlanModeTool.validatePlan(args2);
+        if (err) return { content: err, isError: true };
+        return {
+          content: `Plan recorded. (No interactive approval surface available \u2014 use /mode default or /mode acceptEdits to leave Plan Mode and begin execution.)
+
+## Plan
+${String(args2.plan)}`
+        };
+      }
+    };
+  }
+});
+
 // ../core/src/MDrive.ts
 import { createHash as createHash2 } from "crypto";
 var MDriveService;
@@ -5004,7 +5742,7 @@ var init_MDrive = __esm({
 });
 
 // ../core/src/Sandbox.ts
-import { resolve as resolve13, normalize as normalize12, relative as relative13, isAbsolute as isAbsolute13 } from "path";
+import { resolve as resolve14, normalize as normalize13, relative as relative14, isAbsolute as isAbsolute14 } from "path";
 import { realpathSync } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
@@ -5063,7 +5801,7 @@ var init_Sandbox = __esm({
         "sc"
       ]);
       constructor(projectRoot, opts) {
-        this.projectRoot = resolve13(projectRoot);
+        this.projectRoot = resolve14(projectRoot);
         this.realpathSyncFn = opts?.realpathSync ?? realpathSync;
       }
       setPermissions(state) {
@@ -5078,15 +5816,15 @@ var init_Sandbox = __esm({
         return hasher.digest("hex");
       }
       isPathSafe(targetPath) {
-        const normalizedTarget = isAbsolute13(targetPath) ? normalize12(targetPath) : resolve13(this.projectRoot, targetPath);
+        const normalizedTarget = isAbsolute14(targetPath) ? normalize13(targetPath) : resolve14(this.projectRoot, targetPath);
         let resolvedTarget = normalizedTarget;
         try {
           resolvedTarget = this.realpathSyncFn(normalizedTarget);
         } catch {
           resolvedTarget = normalizedTarget;
         }
-        const rel = relative13(this.projectRoot, resolvedTarget);
-        const isOutside = rel.startsWith("..") || isAbsolute13(rel);
+        const rel = relative14(this.projectRoot, resolvedTarget);
+        const isOutside = rel.startsWith("..") || isAbsolute14(rel);
         if (isOutside) {
           if (this.permissions.trustedPaths.includes(resolvedTarget) || this.permissions.trustedPaths.includes(normalizedTarget)) {
             return { safe: true, absolutePath: resolvedTarget };
@@ -5104,15 +5842,15 @@ var init_Sandbox = __esm({
        * isPathSafe (sync) is kept for cold/boot-time paths and existing tests.
        */
       async isPathSafeAsync(targetPath) {
-        const normalizedTarget = isAbsolute13(targetPath) ? normalize12(targetPath) : resolve13(this.projectRoot, targetPath);
+        const normalizedTarget = isAbsolute14(targetPath) ? normalize13(targetPath) : resolve14(this.projectRoot, targetPath);
         let resolvedTarget = normalizedTarget;
         try {
           resolvedTarget = await realpath2(normalizedTarget);
         } catch {
           resolvedTarget = normalizedTarget;
         }
-        const rel = relative13(this.projectRoot, resolvedTarget);
-        const isOutside = rel.startsWith("..") || isAbsolute13(rel);
+        const rel = relative14(this.projectRoot, resolvedTarget);
+        const isOutside = rel.startsWith("..") || isAbsolute14(rel);
         if (isOutside) {
           if (this.permissions.trustedPaths.includes(resolvedTarget) || this.permissions.trustedPaths.includes(normalizedTarget)) {
             return { safe: true, absolutePath: resolvedTarget };
@@ -5144,7 +5882,7 @@ var init_Sandbox = __esm({
         }
         const parsed = parse(commandLine);
         const tokens = parsed.filter((t) => typeof t === "string");
-        const normalize13 = (raw) => {
+        const normalize14 = (raw) => {
           let b = raw.toLowerCase();
           const slash = Math.max(b.lastIndexOf("/"), b.lastIndexOf("\\"));
           if (slash >= 0) b = b.slice(slash + 1);
@@ -5152,7 +5890,7 @@ var init_Sandbox = __esm({
           return b;
         };
         for (const tok of tokens) {
-          const b = normalize13(tok);
+          const b = normalize14(tok);
           if (_Sandbox.DANGEROUS_BINARIES.has(b)) {
             return { status: "blocked", reason: `Binary '${b}' is explicitly forbidden.`, hash };
           }
@@ -5160,7 +5898,7 @@ var init_Sandbox = __esm({
         if (tokens.length === 0) {
           return { status: "safe", hash };
         }
-        const binary = normalize13(tokens[0]);
+        const binary = normalize14(tokens[0]);
         const sub = tokens.length > 1 ? tokens[1].toLowerCase() : "";
         if (binary === "git") {
           const destructiveGit = /* @__PURE__ */ new Set(["push", "reset", "clean", "rebase", "merge", "force-push"]);
@@ -5259,7 +5997,7 @@ var init_Sandbox = __esm({
 });
 
 // ../core/src/Voice.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 function buildTtsInvocation(text, rate) {
   const psCommand = `
     Add-Type -AssemblyName System.Speech;
@@ -5299,10 +6037,10 @@ var init_Voice = __esm({
         const { command, args: args2, env } = buildTtsInvocation(text, rate);
         try {
           if (process.platform === "win32") {
-            await new Promise((resolve20, reject) => {
+            await new Promise((resolve21, reject) => {
               try {
-                const proc = spawn6(command, args2, { env });
-                proc.on("exit", () => resolve20());
+                const proc = spawn7(command, args2, { env });
+                proc.on("exit", () => resolve21());
                 proc.on("error", reject);
               } catch (e) {
                 reject(e);
@@ -5399,7 +6137,7 @@ var init_ShadowService = __esm({
 });
 
 // ../core/src/Hooks.ts
-import { spawn as spawn7 } from "child_process";
+import { exec } from "child_process";
 function matches(entry, ctx) {
   if (!entry.matcher) return true;
   let re;
@@ -5416,62 +6154,50 @@ function matches(entry, ctx) {
 async function runOne(entry, ctx) {
   const timeoutMs = entry.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const command = entry.command;
-  return new Promise((resolve20) => {
-    const isWindows = process.platform === "win32";
-    const child = spawn7(isWindows ? "cmd.exe" : "sh", isWindows ? ["/c", command] : ["-c", command], {
-      cwd: ctx.cwd ?? process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
+  const env = { ...process.env, MSAPLING_HOOK_PAYLOAD: JSON.stringify({ ...ctx }) };
+  return new Promise((resolve21) => {
     let timedOut = false;
     let settled = false;
-    const finish = (exitCode) => {
+    const finish = (exitCode, stdout, stderr) => {
       if (settled) return;
       settled = true;
       clearTimeout(killer);
-      const blocked = !!entry.blocking && (exitCode === null || exitCode !== 0);
-      resolve20({ command, exitCode, stdout, stderr, timedOut, blocked });
+      const blocked = !NON_BLOCKING_EVENTS.has(ctx.event) && !!entry.blocking && (exitCode === null || exitCode !== 0);
+      resolve21({ command, exitCode, stdout, stderr, timedOut, blocked });
     };
+    const child = exec(command, {
+      cwd: ctx.cwd ?? process.cwd(),
+      env,
+      maxBuffer: MAX_OUTPUT_BYTES3
+    }, (err, stdout, stderr) => {
+      const rawCode = err ? err.code : 0;
+      const exitCode = typeof rawCode === "number" ? rawCode : null;
+      finish(exitCode, stdout.slice(0, MAX_OUTPUT_BYTES3), stderr.slice(0, MAX_OUTPUT_BYTES3));
+    });
     const killer = setTimeout(() => {
       timedOut = true;
       try {
         child.kill("SIGKILL");
       } catch {
       }
-      finish(null);
+      finish(null, "", "");
     }, timeoutMs);
-    child.stdout.on("data", (b) => {
-      if (stdout.length < MAX_OUTPUT_BYTES3) stdout += b.toString("utf8");
-    });
-    child.stderr.on("data", (b) => {
-      if (stderr.length < MAX_OUTPUT_BYTES3) stderr += b.toString("utf8");
-    });
-    child.on("error", (e) => {
-      stderr += `
-[hook spawn error] ${e.message}`;
-      finish(null);
-    });
-    child.on("close", (code) => finish(code));
-    try {
-      child.stdin.write(JSON.stringify({ ...ctx }) + "\n");
-      child.stdin.end();
-    } catch (e) {
-      stderr += `
-[hook stdin error] ${e?.message}`;
-      try {
-        child.kill();
-      } catch {
-      }
-      finish(null);
-    }
   });
 }
-var DEFAULT_TIMEOUT_MS3, MAX_OUTPUT_BYTES3, HookRunner;
+var NON_BLOCKING_EVENTS, DEFAULT_TIMEOUT_MS3, MAX_OUTPUT_BYTES3, HookRunner;
 var init_Hooks = __esm({
   "../core/src/Hooks.ts"() {
     "use strict";
     init_esm_shims();
+    NON_BLOCKING_EVENTS = /* @__PURE__ */ new Set([
+      "post-tool-use",
+      "session-start",
+      "session-end",
+      "stop",
+      "subagent-stop",
+      "pre-compact",
+      "notification"
+    ]);
     DEFAULT_TIMEOUT_MS3 = 5e3;
     MAX_OUTPUT_BYTES3 = 32e3;
     HookRunner = class {
@@ -5499,6 +6225,18 @@ var init_Hooks = __esm({
         }
         return outcomes;
       }
+      /**
+       * P1-7a: fire an observation-only lifecycle event without awaiting or
+       * blocking the caller. Errors are swallowed so a misbehaving hook can never
+       * break session start/stop/teardown. Returns immediately; the hook chain
+       * runs in the background. No-op if no hooks are registered for the event.
+       */
+      fireForget(ctx) {
+        const entries = this.hooks[ctx.event];
+        if (!entries || entries.length === 0) return;
+        void this.fire(ctx).catch(() => {
+        });
+      }
       /** Convenience: did any outcome block? */
       static anyBlocked(outcomes) {
         return outcomes.find((o) => o.blocked) ?? null;
@@ -5661,9 +6399,9 @@ var init_specs = __esm({
 
 // ../core/src/governor/ResourceGovernor.ts
 import { freemem as freemem2 } from "os";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function determineTier(specs) {
   const memGB = specs.memory.totalGB;
   const cores = specs.cpu.cores;
@@ -5678,7 +6416,7 @@ function recommendLimits(specs) {
 }
 async function readConfigOverrides() {
   try {
-    const configPath = join14(homedir7(), ".msapling", "config.json");
+    const configPath = join15(homedir8(), ".msapling", "config.json");
     const content = await readFile9(configPath, "utf-8");
     const config = JSON.parse(content);
     return config.limits ?? null;
@@ -5759,7 +6497,7 @@ var init_ResourceGovernor = __esm({
           this.activeAgents++;
           return;
         }
-        await new Promise((resolve20) => this.agentWaiters.push(resolve20));
+        await new Promise((resolve21) => this.agentWaiters.push(resolve21));
         this.activeAgents++;
       }
       /**
@@ -5778,7 +6516,7 @@ var init_ResourceGovernor = __esm({
           this.activeTool++;
           return;
         }
-        await new Promise((resolve20) => this.toolWaiters.push(resolve20));
+        await new Promise((resolve21) => this.toolWaiters.push(resolve21));
         this.activeTool++;
       }
       /**
@@ -5834,21 +6572,29 @@ var init_ToolExecutor = __esm({
     init_PatchFileTool();
     init_DispatchAgentTool();
     init_WebFetchTool();
+    init_WebSearchTool();
     init_BashTool();
+    init_BackgroundShellTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
     init_MultiEditFileTool();
     init_MoveFileTool();
     init_DeleteFileTool();
+    init_PlanModeTools();
     init_MDrive();
     init_Sandbox();
     init_Voice();
     init_ShadowService();
     init_Hooks();
     init_ResourceGovernor();
-    APPROVAL_GATED = /* @__PURE__ */ new Set(["run_command", "bash_command", "edit_file", "write_file", "patch_file", "multi_edit_file", "notebook_edit_cell", "move_file", "delete_file", "open_sub_shell"]);
+    APPROVAL_GATED = /* @__PURE__ */ new Set(["run_command", "bash_command", "bash_background", "edit_file", "write_file", "patch_file", "multi_edit_file", "notebook_edit_cell", "move_file", "delete_file", "open_sub_shell"]);
     ToolExecutor = class {
       tools = /* @__PURE__ */ new Map();
+      /** Backend client — retained so named-subagent dispatch can open its own
+       *  scoped stream (CLI-PARITY-P1-6). */
+      client;
+      /** Project root — retained for named-subagent dispatch context. */
+      projectRoot;
       sandbox;
       mdrive;
       voice;
@@ -5875,7 +6621,16 @@ var init_ToolExecutor = __esm({
       sessionTrust = /* @__PURE__ */ new Set();
       mcpRegistry = null;
       hooks = null;
+      /**
+       * CLI-PARITY-P0-2: Notifier fired whenever a tool flips the permission mode
+       * (enter_plan_mode / exit_plan_mode). Lets the CLI keep its React `mode`
+       * state + footer in sync with a model-driven mode change. Optional — when
+       * unset the mode still flips internally; only the UI display would lag.
+       */
+      onModeChange = null;
       constructor(client, projectRoot) {
+        this.client = client;
+        this.projectRoot = projectRoot;
         this.sandbox = new Sandbox(projectRoot);
         this.mdrive = new MDriveService(client);
         this.voice = new VoiceService();
@@ -5894,15 +6649,37 @@ var init_ToolExecutor = __esm({
         this.registerTool(new PatchFileTool());
         this.registerTool(new DispatchAgentTool({
           client,
-          projectRoot
+          projectRoot,
+          // P1-7a (CLI-HOOKS-LIFECYCLE-01): fire the subagent-stop lifecycle hook
+          // when a dispatched sub-agent finishes. Observation-only / non-blocking.
+          onSubagentStop: (info) => {
+            this.hooks?.fireForget({
+              event: "subagent-stop",
+              tool: info.description,
+              payload: info,
+              cwd: projectRoot
+            });
+          },
+          // CLI-PARITY-P1-6: named-subagent runner. Runs a named agent with its own
+          // system prompt + model + TOOL ALLOWLIST. Tools execute back through THIS
+          // executor (so the existing permission/approval system gates writes), but
+          // only the agent's allowlisted tools are advertised + permitted.
+          runNamedAgent: (req) => this.runNamedSubagent(req)
         }));
         this.registerTool(new WebFetchTool());
+        this.registerTool(new WebSearchTool({ client }));
         this.registerTool(new BashTool());
+        this.registerTool(new BashBackgroundTool());
+        this.registerTool(new ListBackgroundShellsTool());
+        this.registerTool(new ReadBackgroundShellTool());
+        this.registerTool(new KillBackgroundShellTool());
         this.registerTool(new NotebookReadTool());
         this.registerTool(new NotebookEditTool());
         this.registerTool(new MultiEditFileTool());
         this.registerTool(new MoveFileTool());
         this.registerTool(new DeleteFileTool());
+        this.registerTool(new EnterPlanModeTool());
+        this.registerTool(new ExitPlanModeTool());
       }
       setToolsEnabled(enabled) {
         this.toolsEnabled = enabled;
@@ -5913,6 +6690,24 @@ var init_ToolExecutor = __esm({
       getMode() {
         return this.mode;
       }
+      /**
+       * CLI-PARITY-P0-2: Register a callback invoked when a tool changes the
+       * permission mode (enter_plan_mode / exit_plan_mode), so the CLI can mirror
+       * the new mode into its React state. Does not affect the internal mode.
+       */
+      setOnModeChange(cb) {
+        this.onModeChange = cb;
+      }
+      /** Internal: flip the mode AND notify any registered listener. */
+      applyModeChange(mode) {
+        this.mode = mode;
+        if (this.onModeChange) {
+          try {
+            this.onModeChange(mode);
+          } catch {
+          }
+        }
+      }
       setApprovalCallback(cb) {
         this.approvalCallback = cb;
       }
@@ -5957,6 +6752,61 @@ var init_ToolExecutor = __esm({
       registerTool(tool) {
         this.tools.set(tool.name, tool);
       }
+      /**
+       * CLI-PARITY-P0-2: enter_plan_mode handler. Flips the executor into read-only
+       * `plan` mode (idempotent) and returns the research instructions. No approval:
+       * entering plan mode only tightens permissions.
+       */
+      async handleEnterPlanMode() {
+        if (this.mode !== "plan") {
+          this.applyModeChange("plan");
+        }
+        const tool = this.tools.get("enter_plan_mode");
+        return tool.execute({}, "");
+      }
+      /**
+       * CLI-PARITY-P0-2: exit_plan_mode handler. Validates the drafted plan,
+       * presents it through the existing approval UI (approvalCallback), and on
+       * approve flips `plan` → default/acceptEdits so execution can proceed. On deny
+       * the executor stays in plan mode and the model is told to revise.
+       */
+      async handleExitPlanMode(args2) {
+        const err = ExitPlanModeTool.validatePlan(args2);
+        if (err) return { content: err, isError: true };
+        if (this.mode !== "plan") {
+          return {
+            content: "You are not in Plan Mode, so there is nothing to exit. Continue with implementation."
+          };
+        }
+        const plan = String(args2.plan);
+        if (!this.approvalCallback) {
+          this.applyModeChange("default");
+          return {
+            content: `No interactive approval surface available \u2014 Plan Mode lifted (now in default mode). Proceed with the plan.
+
+## Approved Plan
+${plan}`
+          };
+        }
+        const decision = await this.approvalCallback({
+          tool: "exit_plan_mode",
+          command: plan,
+          reason: "The agent has finished planning and wants to start executing this plan. Approve to leave Plan Mode."
+        });
+        if (decision === "no") {
+          return {
+            content: "User rejected the plan. You remain in Plan Mode. Ask the user for specific feedback and revise the plan, then call exit_plan_mode again."
+          };
+        }
+        const targetMode = decision === "always" ? "acceptEdits" : "default";
+        this.applyModeChange(targetMode);
+        return {
+          content: `User approved the plan. Plan Mode lifted (now in ${targetMode} mode). You can now start executing. Begin with the first step.
+
+## Approved Plan
+${plan}`
+        };
+      }
       async execute(toolName, args2, projectRoot) {
         const tool = this.tools.get(toolName);
         if (!tool) {
@@ -5972,6 +6822,12 @@ var init_ToolExecutor = __esm({
           }
           return { content: `Error: unknown tool: ${toolName}`, isError: true };
         }
+        if (toolName === "enter_plan_mode") {
+          return this.handleEnterPlanMode();
+        }
+        if (toolName === "exit_plan_mode") {
+          return this.handleExitPlanMode(args2);
+        }
         if (this.mode === "plan") {
           if (APPROVAL_GATED.has(toolName)) {
             return {
@@ -6008,13 +6864,13 @@ ${blocker.stderr || "(empty)"}`,
             return { content: `Security Block: ${check2.reason}`, isError: true };
           }
         }
-        if (toolName === "run_command" || toolName === "bash_command") {
+        if (toolName === "run_command" || toolName === "bash_command" || toolName === "bash_background") {
           if (!args2.command) {
             return { content: `Error: ${toolName} requires a command argument`, isError: true };
           }
           const analysis = this.sandbox.analyzeCommand(args2.command);
           if (analysis.status === "blocked") {
-            const staleCmdKey = toolName === "bash_command" ? `bash_command:${(args2.command || "").trim().replace(/\s+/g, " ")}${args2.cwd ? `:cwd=${args2.cwd}` : ""}` : `run_command:${(args2.command || "").trim()}`;
+            const staleCmdKey = toolName === "run_command" ? `run_command:${(args2.command || "").trim()}` : `${toolName}:${(args2.command || "").trim().replace(/\s+/g, " ")}${args2.cwd ? `:cwd=${args2.cwd}` : ""}`;
             if (this.trustStore?.has(staleCmdKey)) {
               this.trustStore.delete(staleCmdKey).catch(() => {
               });
@@ -6029,10 +6885,10 @@ ${blocker.stderr || "(empty)"}`,
           let cmdKey = "";
           if (toolName === "run_command") {
             cmdKey = `run_command:${(args2.command || "").trim()}`;
-          } else if (toolName === "bash_command") {
+          } else if (toolName === "bash_command" || toolName === "bash_background") {
             const normalizedCmd = (args2.command || "").trim().replace(/\s+/g, " ");
             const cwdSuffix = args2.cwd ? `:cwd=${args2.cwd}` : "";
-            cmdKey = `bash_command:${normalizedCmd}${cwdSuffix}`;
+            cmdKey = `${toolName}:${normalizedCmd}${cwdSuffix}`;
           } else {
             cmdKey = `${toolName}:${(args2.path || args2.instruction || "").trim()}`;
           }
@@ -6056,7 +6912,7 @@ ${blocker.stderr || "(empty)"}`,
             }
           }
         }
-        if (toolName === "run_command" || toolName === "bash_command" || toolName === "edit_file" || toolName === "write_file" || toolName === "patch_file" || toolName === "multi_edit_file" || toolName === "notebook_edit_cell" || toolName === "move_file" || toolName === "delete_file") {
+        if (toolName === "run_command" || toolName === "bash_command" || toolName === "bash_background" || toolName === "edit_file" || toolName === "write_file" || toolName === "patch_file" || toolName === "multi_edit_file" || toolName === "notebook_edit_cell" || toolName === "move_file" || toolName === "delete_file") {
           const audit = await this.shadow.verifyAction(
             JSON.stringify({ tool: toolName, args: args2 }),
             `Execution context: ${projectRoot}`
@@ -6117,6 +6973,80 @@ Please approve the diff in the UI to sync this change locally.`
         }));
         return [...builtin, ...mcp];
       }
+      /**
+       * CLI-PARITY-P1-6: tool schemas filtered to a named agent's allowlist.
+       *
+       *  - `undefined` allowlist  → inherit the FULL builtin+MCP set (getToolSchemas).
+       *  - `[]`                    → no tools (read/reason-only agent).
+       *  - `['read_file', …]`      → ONLY those tools (silently drops names that
+       *                              don't resolve to a registered tool).
+       *
+       * `dispatch_agent` is always excluded from a subagent's view so a named agent
+       * cannot recursively spawn further named agents (avoids unbounded fan-out).
+       */
+      getToolSchemasForAllowlist(allow) {
+        const all = this.getToolSchemas();
+        if (allow === void 0) {
+          return all.filter((s) => s.name !== "dispatch_agent");
+        }
+        const allowSet = new Set(allow);
+        return all.filter((s) => s.name !== "dispatch_agent" && allowSet.has(s.name));
+      }
+      /**
+       * CLI-PARITY-P1-6: run a NAMED subagent to completion.
+       *
+       * Drives a bounded agentic loop against the backend using the agent's system
+       * prompt + model, advertising ONLY the agent's allowlisted tools.  Tool calls
+       * execute back through `this.execute(...)`, so the SAME permission/approval +
+       * shadow-audit gates apply — the allowlist narrows WHICH tools the agent may
+       * request; the permission system still governs WHETHER a given write runs.
+       *
+       * This is the mechanism that closes the "subagents are read-only" gap: a named
+       * agent whose frontmatter grants `write_file`/`edit_file`/`bash_command` can
+       * use them (subject to approval), whereas the anonymous dispatch path cannot.
+       */
+      async runNamedSubagent(req) {
+        const { agent, prompt: prompt4, model, chatId, onContent } = req;
+        const schemas = this.getToolSchemasForAllowlist(agent.tools);
+        const framedPrompt = `[You are the "${agent.name}" subagent. Operate strictly within this role.]
+${agent.systemPrompt}
+
+---
+
+${prompt4}`;
+        const MAX_SUBAGENT_ROUNDS = 12;
+        const queue = [framedPrompt];
+        let rounds = 0;
+        while (queue.length > 0 && rounds < MAX_SUBAGENT_ROUNDS) {
+          const current = queue.shift();
+          rounds++;
+          const stream = this.client.streamChat({
+            ...chatId ? { chat_id: chatId } : {},
+            prompt: current,
+            model,
+            tools: schemas,
+            project_root: this.projectRoot,
+            mode: this.mode
+          });
+          for await (const chunk of stream) {
+            if (chunk.content) onContent(chunk.content);
+            if (chunk.tool_use) {
+              const name = chunk.tool_use.name;
+              if (agent.tools !== void 0 && !agent.tools.includes(name)) {
+                queue.push(
+                  `[TOOL_RESULT]: ${JSON.stringify({
+                    content: `Tool "${name}" is not in the "${agent.name}" agent's allowlist; refused.`,
+                    isError: true
+                  })}`
+                );
+                continue;
+              }
+              const result = await this.execute(name, chunk.tool_use.args, this.projectRoot);
+              queue.push(`[TOOL_RESULT]: ${JSON.stringify(result)}`);
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -6162,8 +7092,8 @@ var init_Safety = __esm({
 });
 
 // ../core/src/ProjectConfig.ts
-import { homedir as homedir8 } from "os";
-import { join as join15, dirname as dirname3, parse as parsePath } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join16, dirname as dirname3, parse as parsePath } from "path";
 import { existsSync as existsSync11 } from "fs";
 import { readFile as readFile11 } from "fs/promises";
 async function readIfExists(path2) {
@@ -6177,7 +7107,7 @@ async function readIfExists(path2) {
 }
 async function findInDir(dir) {
   for (const filename of FILENAMES) {
-    const path2 = join15(dir, filename);
+    const path2 = join16(dir, filename);
     const content = await readIfExists(path2);
     if (content !== null) {
       return { path: path2, filename, content };
@@ -6200,9 +7130,9 @@ async function findProjectConfig(start) {
   return null;
 }
 async function findUserConfig() {
-  const home = homedir8();
+  const home = homedir9();
   if (!home) return null;
-  const userDir = join15(home, ".msapling");
+  const userDir = join16(home, ".msapling");
   return findInDir(userDir);
 }
 function buildCombined(user, project) {
@@ -6396,6 +7326,14 @@ var init_Agent = __esm({
       getMode() {
         return this.executor.getMode();
       }
+      /**
+       * CLI-PARITY-P0-2: Register a listener for model-driven mode changes
+       * (enter_plan_mode / exit_plan_mode) so the CLI can mirror the new mode into
+       * its own state + footer.
+       */
+      setOnModeChange(cb) {
+        this.executor.setOnModeChange(cb);
+      }
       setApprovalCallback(cb) {
         this.executor.setApprovalCallback(cb);
       }
@@ -6406,6 +7344,19 @@ var init_Agent = __esm({
         this.executor.setHookRunner(runner);
         this.hooks = runner;
       }
+      /** Expose the active HookRunner (e.g. for App-level session-start/end). */
+      getHookRunner() {
+        return this.hooks;
+      }
+      /**
+       * P1-7a: fire an observation-only lifecycle hook event without blocking.
+       * No-op when no HookRunner is wired. `name` is the descriptive string used
+       * for matcher evaluation (e.g. the subagent description); `payload` is the
+       * JSON event body delivered on the hook's stdin.
+       */
+      fireLifecycleHook(event, payload, name = "") {
+        this.hooks?.fireForget({ event, tool: name, payload, cwd: this.projectRoot });
+      }
       /**
        * CLI-PARITY-37: Wire a pre-loaded TrustStore so "always" approval decisions
        * are persisted across CLI restarts.  Must be called after `store.load()`.
@@ -6465,6 +7416,11 @@ var init_Agent = __esm({
               `
 [Agent: context budget reached \u2014 auto-compacting conversation (${this.contextBudget.summary()})]`
             );
+            this.fireLifecycleHook(
+              "pre-compact",
+              { chat_id: chatId, reason: "auto", budget: this.contextBudget.summary() },
+              "auto"
+            );
             rounds++;
             const compactionStream = this.client.streamChat({
               chat_id: chatId,
@@ -6547,6 +7503,7 @@ ${next}`;
         if (rounds >= MAX_WORKER_TURN_DEPTH) {
           throw new Error("runWorkerTurn exceeded MAX_DEPTH");
         }
+        this.fireLifecycleHook("stop", { chat_id: chatId, rounds }, "");
         return streamUsage;
       }
       async run(prompt4, model) {
@@ -6783,8 +7740,8 @@ var init_Mutex = __esm({
        */
       acquire() {
         let release3;
-        const next = new Promise((resolve20) => {
-          release3 = resolve20;
+        const next = new Promise((resolve21) => {
+          release3 = resolve21;
         });
         const entry = this._queue.then(() => release3);
         this._queue = this._queue.then(() => next);
@@ -6822,8 +7779,8 @@ var init_lockfile = __esm({
 });
 
 // ../core/src/TrustStore.ts
-import { join as join16, dirname as dirname4 } from "path";
-import { homedir as homedir9, platform as platform3 } from "os";
+import { join as join17, dirname as dirname4 } from "path";
+import { homedir as homedir10, platform as platform3 } from "os";
 import { existsSync as existsSync12, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFile12, writeFile as writeFile5, rename as rename2, chmod } from "fs/promises";
 import { randomBytes as randomBytes9 } from "crypto";
@@ -6834,7 +7791,7 @@ var init_TrustStore = __esm({
     init_esm_shims();
     init_Mutex();
     init_lockfile();
-    USER_SETTINGS_PATH = join16(homedir9(), ".msapling", "settings.json");
+    USER_SETTINGS_PATH = join17(homedir10(), ".msapling", "settings.json");
     TrustStore = class {
       /** Current in-memory set of trusted `tool:command` keys. */
       trusted = /* @__PURE__ */ new Set();
@@ -6991,9 +7948,118 @@ var init_TrustStore = __esm({
   }
 });
 
+// ../core/src/BackupIndex.ts
+import { join as join18 } from "path";
+import { homedir as homedir11 } from "os";
+import {
+  readFileSync as readFileSync3,
+  appendFileSync as appendFileSync2,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync3,
+  copyFileSync
+} from "fs";
+import { randomBytes as randomBytes10 } from "crypto";
+function _setBackupDirOverride(dir) {
+  _backupDirOverride = dir;
+}
+function getBackupDir() {
+  return _backupDirOverride ?? join18(homedir11(), ".msapling", "backups");
+}
+function getManifestPath() {
+  return join18(getBackupDir(), "manifest.jsonl");
+}
+function ensureBackupDir() {
+  const dir = getBackupDir();
+  if (!existsSync13(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+}
+function openTurn(label) {
+  ensureBackupDir();
+  _turnCounter += 1;
+  const turnId = `turn-${Date.now()}-${randomBytes10(4).toString("hex")}`;
+  const entry = {
+    turnId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    label: label ?? `Turn ${_turnCounter}`,
+    backups: []
+  };
+  _openTurns.set(turnId, entry);
+  return turnId;
+}
+function recordBackup(turnId, originalPath, backupPath) {
+  const entry = _openTurns.get(turnId);
+  if (!entry) return;
+  entry.backups.push({ originalPath, backupPath });
+}
+function closeTurn(turnId) {
+  const entry = _openTurns.get(turnId);
+  if (!entry) return;
+  _openTurns.delete(turnId);
+  entry.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    ensureBackupDir();
+    appendFileSync2(getManifestPath(), JSON.stringify(entry) + "\n", "utf8");
+  } catch {
+  }
+}
+function listCheckpoints() {
+  const mp = getManifestPath();
+  if (!existsSync13(mp)) return [];
+  let raw;
+  try {
+    raw = readFileSync3(mp, "utf8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return entries.reverse().slice(0, MAX_CHECKPOINTS);
+}
+function restoreCheckpoint(entry) {
+  const results = [];
+  for (const rec of entry.backups) {
+    if (!existsSync13(rec.backupPath)) {
+      results.push(`Skip (backup file missing): ${rec.originalPath}`);
+      continue;
+    }
+    try {
+      copyFileSync(rec.backupPath, rec.originalPath);
+      results.push(`Restored: ${rec.originalPath}`);
+    } catch (e) {
+      results.push(`Error restoring ${rec.originalPath}: ${e.message}`);
+    }
+  }
+  return results;
+}
+function manifestPath() {
+  return getManifestPath();
+}
+function backupDir() {
+  return getBackupDir();
+}
+var MAX_CHECKPOINTS, _backupDirOverride, _openTurns, _turnCounter;
+var init_BackupIndex = __esm({
+  "../core/src/BackupIndex.ts"() {
+    "use strict";
+    init_esm_shims();
+    MAX_CHECKPOINTS = 50;
+    _backupDirOverride = null;
+    _openTurns = /* @__PURE__ */ new Map();
+    _turnCounter = 0;
+  }
+});
+
 // ../core/src/Storage/vault.ts
-import { join as join17 } from "path";
-import { chmodSync, existsSync as existsSync13, renameSync as renameSync2, unlinkSync } from "fs";
+import { join as join19 } from "path";
+import { chmodSync, existsSync as existsSync14, renameSync as renameSync2, unlinkSync } from "fs";
 import { writeFile as writeFile6, readFile as readFile13 } from "fs/promises";
 import { createHash as createHash4 } from "crypto";
 async function getKeytar() {
@@ -7007,7 +8073,7 @@ async function getKeytar() {
   return _keytar;
 }
 async function saveToken(baseDir, token) {
-  const filePath = join17(baseDir, "vault", "token");
+  const filePath = join19(baseDir, "vault", "token");
   try {
     const kt = await getKeytar();
     if (!kt) throw new Error("keyring not loadable");
@@ -7016,12 +8082,12 @@ async function saveToken(baseDir, token) {
     throw new KeychainUnavailableError(e instanceof Error ? e.message : String(e));
   }
   try {
-    if (existsSync13(filePath)) unlinkSync(filePath);
+    if (existsSync14(filePath)) unlinkSync(filePath);
   } catch {
   }
 }
 async function loadToken(baseDir) {
-  const filePath = join17(baseDir, "vault", "token");
+  const filePath = join19(baseDir, "vault", "token");
   let kt = null;
   try {
     kt = await getKeytar();
@@ -7032,7 +8098,7 @@ async function loadToken(baseDir) {
     kt = null;
     console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)})`);
   }
-  if (existsSync13(filePath)) {
+  if (existsSync14(filePath)) {
     const legacyToken = (await readFile13(filePath, "utf8")).trim();
     if (!legacyToken) return null;
     if (kt) {
@@ -7051,7 +8117,7 @@ async function loadToken(baseDir) {
   return null;
 }
 async function clearToken(baseDir) {
-  const filePath = join17(baseDir, "vault", "token");
+  const filePath = join19(baseDir, "vault", "token");
   try {
     const kt = await getKeytar();
     if (kt) await kt.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
@@ -7059,7 +8125,7 @@ async function clearToken(baseDir) {
     console.debug(`Keychain unavailable for deletion (${e instanceof Error ? e.message : String(e)})`);
   }
   try {
-    if (existsSync13(filePath)) {
+    if (existsSync14(filePath)) {
       const fs3 = await import("fs/promises");
       await fs3.unlink(filePath);
     }
@@ -7081,8 +8147,8 @@ async function getOrCreateJournalKey() {
       const buf = Buffer.from(existing, "base64");
       if (buf.length === 32) return buf;
     }
-    const { randomBytes: randomBytes15 } = await import("crypto");
-    const key = randomBytes15(32);
+    const { randomBytes: randomBytes16 } = await import("crypto");
+    const key = randomBytes16(32);
     await kt.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_JOURNAL_ACCOUNT, key.toString("base64"));
     return key;
   } catch (e) {
@@ -7092,8 +8158,8 @@ async function getOrCreateJournalKey() {
 }
 async function writeVaultRef(baseDir, label, value) {
   const hash = createHash4("sha256").update(value, "utf8").digest("hex");
-  const objectPath = join17(baseDir, "vault", "objects", hash);
-  const refPath = join17(baseDir, "vault", "refs", label);
+  const objectPath = join19(baseDir, "vault", "objects", hash);
+  const refPath = join19(baseDir, "vault", "refs", label);
   const refTmp = `${refPath}.tmp`;
   await writeFile6(objectPath, value, "utf8");
   if (process.platform !== "win32") {
@@ -7104,11 +8170,11 @@ async function writeVaultRef(baseDir, label, value) {
   return hash;
 }
 async function readVaultRef(baseDir, label) {
-  const refPath = join17(baseDir, "vault", "refs", label);
-  if (!existsSync13(refPath)) return null;
+  const refPath = join19(baseDir, "vault", "refs", label);
+  if (!existsSync14(refPath)) return null;
   const hash = (await readFile13(refPath, "utf8")).trim();
-  const objectPath = join17(baseDir, "vault", "objects", hash);
-  if (!existsSync13(objectPath)) return null;
+  const objectPath = join19(baseDir, "vault", "objects", hash);
+  if (!existsSync14(objectPath)) return null;
   return readFile13(objectPath, "utf8");
 }
 var _keytar, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, KeychainUnavailableError, KEYCHAIN_JOURNAL_ACCOUNT;
@@ -7132,20 +8198,20 @@ var init_vault = __esm({
 });
 
 // ../core/src/Storage/recipes.ts
-import { join as join18 } from "path";
-import { existsSync as existsSync14, renameSync as renameSync3 } from "fs";
+import { join as join20 } from "path";
+import { existsSync as existsSync15, renameSync as renameSync3 } from "fs";
 import { writeFile as writeFile7, readFile as readFile14 } from "fs/promises";
 import { createHash as createHash5 } from "crypto";
 async function registerRecipe(baseDir, name, content) {
   const hash = createHash5("sha256").update(content, "utf8").digest("hex");
-  const objectPath = join18(baseDir, "cache", "recipes", "objects", hash);
-  const indexPath = join18(baseDir, "cache", "recipes", "index.json");
+  const objectPath = join20(baseDir, "cache", "recipes", "objects", hash);
+  const indexPath = join20(baseDir, "cache", "recipes", "index.json");
   const indexTmp = `${indexPath}.tmp`;
-  if (!existsSync14(objectPath)) {
+  if (!existsSync15(objectPath)) {
     await writeFile7(objectPath, content, "utf8");
   }
   let index = {};
-  if (existsSync14(indexPath)) {
+  if (existsSync15(indexPath)) {
     try {
       index = JSON.parse(await readFile14(indexPath, "utf8"));
     } catch {
@@ -7158,15 +8224,15 @@ async function registerRecipe(baseDir, name, content) {
   return hash;
 }
 async function resolveRecipe(baseDir, nameOrRef) {
-  const indexPath = join18(baseDir, "cache", "recipes", "index.json");
+  const indexPath = join20(baseDir, "cache", "recipes", "index.json");
   const atIdx = nameOrRef.indexOf("@");
   if (atIdx !== -1) {
     const hash2 = nameOrRef.slice(atIdx + 1);
-    const objectPath2 = join18(baseDir, "cache", "recipes", "objects", hash2);
-    if (!existsSync14(objectPath2)) return null;
+    const objectPath2 = join20(baseDir, "cache", "recipes", "objects", hash2);
+    if (!existsSync15(objectPath2)) return null;
     return { hash: hash2, content: await readFile14(objectPath2, "utf8") };
   }
-  if (!existsSync14(indexPath)) return null;
+  if (!existsSync15(indexPath)) return null;
   let index;
   try {
     index = JSON.parse(await readFile14(indexPath, "utf8"));
@@ -7175,8 +8241,8 @@ async function resolveRecipe(baseDir, nameOrRef) {
   }
   const hash = index[nameOrRef];
   if (!hash) return null;
-  const objectPath = join18(baseDir, "cache", "recipes", "objects", hash);
-  if (!existsSync14(objectPath)) return null;
+  const objectPath = join20(baseDir, "cache", "recipes", "objects", hash);
+  if (!existsSync15(objectPath)) return null;
   return { hash, content: await readFile14(objectPath, "utf8") };
 }
 var init_recipes = __esm({
@@ -7187,25 +8253,25 @@ var init_recipes = __esm({
 });
 
 // ../core/src/Storage/history.ts
-import { join as join19, basename } from "path";
-import { existsSync as existsSync15, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join21, basename } from "path";
+import { existsSync as existsSync16, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "fs";
 import { writeFile as writeFile8, readFile as readFile15, appendFile } from "fs/promises";
-import { createHash as createHash6, randomBytes as randomBytes10 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes11 } from "crypto";
 function hashLine(line) {
   return createHash6("sha256").update(line, "utf8").digest("hex");
 }
 async function appendHistoryEntry(baseDir, historyMutex, content) {
-  const path2 = join19(baseDir, "history", "shell_history.jsonl");
+  const path2 = join21(baseDir, "history", "shell_history.jsonl");
   return historyMutex.run(async () => {
     let release3 = null;
     try {
-      if (!existsSync15(path2)) {
+      if (!existsSync16(path2)) {
         await writeFile8(path2, "", "utf8");
       }
       release3 = await lock(path2, { retries: 5, retryWait: 50 });
       let prevHash = null;
       let seq = 1;
-      if (existsSync15(path2)) {
+      if (existsSync16(path2)) {
         const raw = (await readFile15(path2, "utf8")).trimEnd();
         if (raw.length > 0) {
           const lines = raw.split("\n");
@@ -7238,8 +8304,8 @@ async function appendHistoryEntry(baseDir, historyMutex, content) {
   });
 }
 async function loadHistoryEntries(baseDir) {
-  const path2 = join19(baseDir, "history", "shell_history.jsonl");
-  if (!existsSync15(path2)) return [];
+  const path2 = join21(baseDir, "history", "shell_history.jsonl");
+  if (!existsSync16(path2)) return [];
   const raw = await readFile15(path2, "utf8");
   const entries = [];
   for (const line of raw.split("\n")) {
@@ -7271,10 +8337,10 @@ async function verifyHistory(baseDir) {
   return breaks.length === 0 ? { ok: true } : { ok: false, breaks };
 }
 async function saveHistory(baseDir, historyMutex, history) {
-  const path2 = join19(baseDir, "history", "shell_history.json");
+  const path2 = join21(baseDir, "history", "shell_history.json");
   let release3;
   try {
-    if (!existsSync15(path2)) writeFileSync3(path2, "[]", "utf8");
+    if (!existsSync16(path2)) writeFileSync3(path2, "[]", "utf8");
     release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     await historyMutex.run(async () => {
       const tmpPath = `${path2}.tmp`;
@@ -7284,7 +8350,7 @@ async function saveHistory(baseDir, historyMutex, history) {
         renameSync4(tmpPath, path2);
       } catch (e) {
         try {
-          if (existsSync15(tmpPath)) {
+          if (existsSync16(tmpPath)) {
             const fs3 = await import("fs/promises");
             await fs3.unlink(tmpPath);
           }
@@ -7304,21 +8370,21 @@ async function saveHistory(baseDir, historyMutex, history) {
   }
 }
 async function loadHistory(baseDir, historyMutex) {
-  const path2 = join19(baseDir, "history", "shell_history.json");
-  if (!existsSync15(path2)) return [];
+  const path2 = join21(baseDir, "history", "shell_history.json");
+  if (!existsSync16(path2)) return [];
   let release3;
   try {
     release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     return historyMutex.run(async () => {
-      if (existsSync15(path2)) {
+      if (existsSync16(path2)) {
         const text = await readFile15(path2, "utf8");
         try {
           return JSON.parse(text);
         } catch (parseErr) {
           const filename = basename(path2) || "shell_history.json";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes10(4).toString("hex");
-          const corruptBackupPath = join19(
+          const suffix = randomBytes11(4).toString("hex");
+          const corruptBackupPath = join21(
             baseDir,
             "history",
             `${filename}.corrupt.${stamp}-${suffix}.bak`
@@ -7353,15 +8419,15 @@ var init_history = __esm({
 });
 
 // ../core/src/Storage/permissions.ts
-import { join as join20 } from "path";
-import { existsSync as existsSync16, renameSync as renameSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join22 } from "path";
+import { existsSync as existsSync17, renameSync as renameSync5, writeFileSync as writeFileSync4 } from "fs";
 import { writeFile as writeFile9, readFile as readFile16 } from "fs/promises";
-import { randomBytes as randomBytes11 } from "crypto";
+import { randomBytes as randomBytes12 } from "crypto";
 async function savePermissions(baseDir, permissionsMutex, permissions) {
-  const path2 = join20(baseDir, "vault", "permissions.json");
+  const path2 = join22(baseDir, "vault", "permissions.json");
   let release3;
   try {
-    if (!existsSync16(path2)) writeFileSync4(path2, "{}", "utf8");
+    if (!existsSync17(path2)) writeFileSync4(path2, "{}", "utf8");
     release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     await permissionsMutex.run(async () => {
       const tmpPath = `${path2}.tmp`;
@@ -7371,7 +8437,7 @@ async function savePermissions(baseDir, permissionsMutex, permissions) {
         renameSync5(tmpPath, path2);
       } catch (e) {
         try {
-          if (existsSync16(tmpPath)) {
+          if (existsSync17(tmpPath)) {
             const fs3 = await import("fs/promises");
             await fs3.unlink(tmpPath);
           }
@@ -7391,21 +8457,21 @@ async function savePermissions(baseDir, permissionsMutex, permissions) {
   }
 }
 async function loadPermissions(baseDir, permissionsMutex) {
-  const path2 = join20(baseDir, "vault", "permissions.json");
-  if (!existsSync16(path2)) return { trustedCommands: [], trustedPaths: [] };
+  const path2 = join22(baseDir, "vault", "permissions.json");
+  if (!existsSync17(path2)) return { trustedCommands: [], trustedPaths: [] };
   let release3;
   try {
     release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     return permissionsMutex.run(async () => {
-      if (existsSync16(path2)) {
+      if (existsSync17(path2)) {
         const text = await readFile16(path2, "utf8");
         try {
           return JSON.parse(text);
         } catch (parseErr) {
           const filename = path2.split("/").pop() || "permissions.json";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes11(4).toString("hex");
-          const corruptBackupPath = join20(
+          const suffix = randomBytes12(4).toString("hex");
+          const corruptBackupPath = join22(
             baseDir,
             "vault",
             `${filename}.corrupt.${stamp}-${suffix}.bak`
@@ -7440,11 +8506,11 @@ var init_permissions = __esm({
 });
 
 // ../core/src/Storage.ts
-import { join as join21 } from "path";
-import { homedir as homedir10 } from "os";
+import { join as join23 } from "path";
+import { homedir as homedir12 } from "os";
 import { chmodSync as chmodSync2 } from "fs";
 import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
-import { randomBytes as randomBytes12 } from "crypto";
+import { randomBytes as randomBytes13 } from "crypto";
 var StorageManager;
 var init_Storage = __esm({
   "../core/src/Storage.ts"() {
@@ -7471,7 +8537,7 @@ var init_Storage = __esm({
        */
       _ready;
       constructor() {
-        this.baseDir = join21(homedir10(), ".msapling");
+        this.baseDir = join23(homedir12(), ".msapling");
         this._ready = this.ensureDirs();
       }
       async ensureDirs() {
@@ -7488,7 +8554,7 @@ var init_Storage = __esm({
             "cache/recipes/objects"
           ];
           for (const sub of subdirs) {
-            await mkdir6(join21(this.baseDir, sub), { recursive: true });
+            await mkdir6(join23(this.baseDir, sub), { recursive: true });
           }
           if (process.platform !== "win32") {
             chmodSync2(this.baseDir, 448);
@@ -7565,8 +8631,8 @@ var init_Storage = __esm({
         await this._ready;
         const filename = filePath.split("/").pop() || "file";
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const suffix = randomBytes12(4).toString("hex");
-        const backupPath = join21(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+        const suffix = randomBytes13(4).toString("hex");
+        const backupPath = join23(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
         await writeFile10(backupPath, content, "utf8");
         if (process.platform !== "win32") {
           chmodSync2(backupPath, 384);
@@ -7597,15 +8663,15 @@ var init_journalCrypto = __esm({
 });
 
 // ../core/src/Settings.ts
-import { homedir as homedir11 } from "os";
-import { join as join22 } from "path";
-import { existsSync as existsSync17 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join24 } from "path";
+import { existsSync as existsSync18 } from "fs";
 import * as fs from "fs";
 import { readFile as readFile17 } from "fs/promises";
-import { randomBytes as randomBytes13 } from "crypto";
+import { randomBytes as randomBytes14 } from "crypto";
 function backupStaleFile(p) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const suffix = randomBytes13(4).toString("hex");
+  const suffix = randomBytes14(4).toString("hex");
   fs.renameSync(p, `${p}.broken-${stamp}-${suffix}`);
 }
 function ensureConfigDir(p) {
@@ -7628,7 +8694,7 @@ function ensureConfigDir(p) {
 }
 async function readJson(path2) {
   try {
-    if (!existsSync17(path2)) return null;
+    if (!existsSync18(path2)) return null;
     const text = await readFile17(path2, "utf8");
     if (!text.trim()) return null;
     return JSON.parse(text);
@@ -7683,9 +8749,9 @@ function mergeSettings(base, override) {
 }
 async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
   const sources = [];
-  const home = env.HOME || env.USERPROFILE || process.env.HOME || process.env.USERPROFILE || homedir11() || ".";
-  const userPath = join22(home, ".msapling", "settings.json");
-  const projectPath = join22(cwd, ".msapling", "settings.json");
+  const home = env.HOME || env.USERPROFILE || process.env.HOME || process.env.USERPROFILE || homedir13() || ".";
+  const userPath = join24(home, ".msapling", "settings.json");
+  const projectPath = join24(cwd, ".msapling", "settings.json");
   const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
   if (user) sources.push(userPath);
   if (project) sources.push(projectPath);
@@ -7738,7 +8804,7 @@ var init_Settings = __esm({
 });
 
 // ../core/src/mcp/client.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 var PROTOCOL_VERSION, CLIENT_INFO, MCPClientError, MCPClient, MCPRegistry;
 var init_client = __esm({
   "../core/src/mcp/client.ts"() {
@@ -7774,7 +8840,7 @@ var init_client = __esm({
         if (this.proc) return;
         const env = { ...process.env, ...this.config.env ?? {} };
         try {
-          this.proc = spawn8(this.config.command, this.config.args ?? [], {
+          this.proc = spawn9(this.config.command, this.config.args ?? [], {
             stdio: ["pipe", "pipe", "pipe"],
             env
           });
@@ -7848,7 +8914,7 @@ var init_client = __esm({
         if (!this.proc) throw new MCPClientError(`MCP server "${this.name}" not started`);
         const id = this.nextId++;
         const frame = { jsonrpc: "2.0", id, method, params };
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve21, reject) => {
           const timer = setTimeout(() => {
             this.pending.delete(id);
             reject(new MCPClientError(`MCP request ${method} timed out after ${timeoutMs}ms`));
@@ -7856,7 +8922,7 @@ var init_client = __esm({
           this.pending.set(id, {
             resolve: (v) => {
               clearTimeout(timer);
-              resolve20(v);
+              resolve21(v);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -7883,7 +8949,7 @@ var init_client = __esm({
         if (!this.proc?.stdout) return;
         const stdout = this.proc.stdout;
         const decoder = new TextDecoder();
-        return new Promise((resolve20) => {
+        return new Promise((resolve21) => {
           stdout.on("data", (chunk) => {
             this.buffer += decoder.decode(chunk, { stream: true });
             let idx;
@@ -7894,8 +8960,8 @@ var init_client = __esm({
               this.handleFrame(line);
             }
           });
-          stdout.on("end", () => resolve20());
-          stdout.on("error", () => resolve20());
+          stdout.on("end", () => resolve21());
+          stdout.on("error", () => resolve21());
         });
       }
       handleFrame(line) {
@@ -8035,16 +9101,23 @@ __export(src_exports2, {
   APPROVAL_GATED: () => APPROVAL_GATED,
   Agent: () => Agent,
   AsyncMutex: () => AsyncMutex,
+  BackgroundShellRegistry: () => BackgroundShellRegistry,
+  BashBackgroundTool: () => BashBackgroundTool,
   BashTool: () => BashTool,
   ContextBudget: () => ContextBudget,
   DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
   DeleteFileTool: () => DeleteFileTool,
   DispatchAgentTool: () => DispatchAgentTool,
+  EnterPlanModeTool: () => EnterPlanModeTool,
+  ExitPlanModeTool: () => ExitPlanModeTool,
   GlobFilesTool: () => GlobFilesTool,
   GrepSearchTool: () => GrepSearchTool,
   HookRunner: () => HookRunner,
   KeychainUnavailableError: () => KeychainUnavailableError,
+  KillBackgroundShellTool: () => KillBackgroundShellTool,
+  ListBackgroundShellsTool: () => ListBackgroundShellsTool,
   ListDirectoryTool: () => ListDirectoryTool,
+  MAX_PLAN_CHARS: () => MAX_PLAN_CHARS,
   MCPClient: () => MCPClient,
   MCPClientError: () => MCPClientError,
   MCPRegistry: () => MCPRegistry,
@@ -8053,25 +9126,43 @@ __export(src_exports2, {
   NotebookEditTool: () => NotebookEditTool,
   NotebookReadTool: () => NotebookReadTool,
   PatchFileTool: () => PatchFileTool,
+  ReadBackgroundShellTool: () => ReadBackgroundShellTool,
   StorageManager: () => StorageManager,
   SwarmManager: () => SwarmManager,
+  TOOL_NAME_ALIASES: () => TOOL_NAME_ALIASES,
   TodoReadTool: () => TodoReadTool,
   TodoStore: () => TodoStore,
   TodoWriteTool: () => TodoWriteTool,
   ToolExecutor: () => ToolExecutor,
   TrustStore: () => TrustStore,
   WebFetchTool: () => WebFetchTool,
+  WebSearchTool: () => WebSearchTool,
   WriteFileTool: () => WriteFileTool,
+  _setBackupDirOverride: () => _setBackupDirOverride,
+  backupDir: () => backupDir,
   buildCompactionPrompt: () => buildCompactionPrompt,
   buildHwContext: () => buildHwContext,
+  closeTurn: () => closeTurn,
+  discoverAgentFiles: () => discoverAgentFiles,
   ensureConfigDir: () => ensureConfigDir,
+  findNamedAgent: () => findNamedAgent,
+  formatBackgroundShells: () => formatBackgroundShells,
   formatCell: () => formatCell,
   formatNotebookHeader: () => formatNotebookHeader,
   formatTodos: () => formatTodos,
   getOrCreateJournalKey: () => getOrCreateJournalKey,
   initJournalEncryption: () => initJournalEncryption,
+  listCheckpoints: () => listCheckpoints,
+  loadNamedAgents: () => loadNamedAgents,
   loadProjectConfig: () => loadProjectConfig,
   loadSettings: () => loadSettings,
+  manifestPath: () => manifestPath,
+  normalizeToolName: () => normalizeToolName,
+  openTurn: () => openTurn,
+  parseAgentFile: () => parseAgentFile,
+  parseToolsValue: () => parseToolsValue,
+  recordBackup: () => recordBackup,
+  restoreCheckpoint: () => restoreCheckpoint,
   takeSnapshot: () => takeSnapshot
 });
 var init_src3 = __esm({
@@ -8080,9 +9171,11 @@ var init_src3 = __esm({
     init_esm_shims();
     init_ToolExecutor();
     init_Agent();
+    init_namedAgents();
     init_HardwareMonitor();
     init_TrustStore();
     init_ContextBudget();
+    init_BackupIndex();
     init_Storage();
     init_Storage();
     init_journalCrypto();
@@ -8099,7 +9192,10 @@ var init_src3 = __esm({
     init_TodoTools();
     init_DispatchAgentTool();
     init_WebFetchTool();
+    init_WebSearchTool();
+    init_PlanModeTools();
     init_BashTool();
+    init_BackgroundShellTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
     init_MultiEditFileTool();
@@ -8124,7 +9220,7 @@ function setRawModeGuarded(stdin, mode) {
   }
 }
 async function promptPassword(prompt4) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const stdin = process.stdin;
     const stdout = process.stdout;
     stdout.write(prompt4);
@@ -8138,7 +9234,7 @@ async function promptPassword(prompt4) {
       setRawModeGuarded(stdin, wasRaw);
       stdin.removeListener("data", onData);
       stdout.write("\n");
-      resolve20(value);
+      resolve21(value);
     };
     const onData = (chunk) => {
       try {
@@ -8240,7 +9336,7 @@ async function loginWithGithubDevice(context) {
   const deadline = Date.now() + expires_in * 1e3;
   let githubToken = null;
   while (Date.now() < deadline) {
-    await new Promise((resolve20) => setTimeout(resolve20, pollMs));
+    await new Promise((resolve21) => setTimeout(resolve21, pollMs));
     let tokenResp;
     try {
       tokenResp = await fetch(GITHUB_TOKEN_URL, {
@@ -8264,7 +9360,7 @@ async function loginWithGithubDevice(context) {
     if (tokenData.error === "authorization_pending") continue;
     if (tokenData.error === "slow_down") {
       pollMs += 5e3;
-      await new Promise((resolve20) => setTimeout(resolve20, 5e3));
+      await new Promise((resolve21) => setTimeout(resolve21, 5e3));
       continue;
     }
     context.addMessage("system", `GitHub auth error: ${tokenData.error_description || tokenData.error}`);
@@ -8609,9 +9705,9 @@ var init_unlock = __esm({
 });
 
 // src/commands/doctor.ts
-import { homedir as homedir12 } from "os";
-import { join as join23 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join25 } from "path";
+import { existsSync as existsSync20 } from "fs";
 import { readFile as readFile18 } from "fs/promises";
 async function checkApiHealth(client) {
   try {
@@ -8637,9 +9733,9 @@ async function checkAuthStatus(client) {
   }
 }
 async function checkSettingsFile() {
-  const settingsPath = join23(homedir12(), ".msapling", "settings.json");
+  const settingsPath = join25(homedir14(), ".msapling", "settings.json");
   try {
-    if (!existsSync19(settingsPath)) {
+    if (!existsSync20(settingsPath)) {
       return { ok: false, message: `Not found: ${settingsPath}` };
     }
     const text = await readFile18(settingsPath, "utf8");
@@ -9037,6 +10133,104 @@ var init_chat = __esm({
   }
 });
 
+// src/commands/resume.ts
+var resume_exports = {};
+__export(resume_exports, {
+  rehydrateChat: () => rehydrateChat,
+  resolveRecentChat: () => resolveRecentChat,
+  resumeCommand: () => resumeCommand
+});
+function labelFor2(i) {
+  return i < 9 ? String(i + 1) : LETTERS2[i - 9] ?? `#${i + 1}`;
+}
+function resolveRecentChat(arg, chats) {
+  const trimmed = arg.trim();
+  if (!trimmed) return { kind: "error", message: "empty argument" };
+  const idHit = chats.find((c) => c.id === trimmed);
+  if (idHit) return { kind: "ok", chat: idHit };
+  if (/^\d+$/.test(trimmed)) {
+    const n = parseInt(trimmed, 10);
+    if (n >= 1 && n <= chats.length) return { kind: "ok", chat: chats[n - 1] };
+    return { kind: "error", message: `no chat at index ${n} (have ${chats.length})` };
+  }
+  if (/^[a-zA-Z]$/.test(trimmed)) {
+    const idx = 9 + LETTERS2.indexOf(trimmed.toLowerCase());
+    if (idx >= 9 && idx < chats.length) return { kind: "ok", chat: chats[idx] };
+  }
+  return {
+    kind: "error",
+    message: `no recent chat matches '${trimmed}'. Run /resume (no args) for the list.`
+  };
+}
+async function rehydrateChat(chat, context) {
+  context.clearHistory();
+  context.setActiveChatId(chat.id);
+  let messages = [];
+  try {
+    messages = await context.client.getHistory(chat.id);
+  } catch (e) {
+    context.addMessage("error", `Resumed ${chat.id} but failed to load history: ${e?.message ?? e}`);
+  }
+  const label = chat.title ?? chat.id;
+  const where = chat.project ? ` in '${chat.project}'` : "";
+  context.addMessage("system", `Resumed chat "${label}"${where} (${messages.length} message(s) replayed).`);
+  for (const m of messages) {
+    const role = m.role === "user" ? "user" : m.role === "assistant" ? "assistant" : "system";
+    context.addMessage(role, m.content);
+  }
+  try {
+    await context.refreshOverview();
+  } catch {
+  }
+  return messages.length;
+}
+async function listAndResume(args2, context) {
+  let chats;
+  try {
+    chats = await context.client.listRecentChats(35);
+  } catch (e) {
+    context.addMessage("error", `Failed to list recent chats: ${e?.message ?? e}`);
+    return;
+  }
+  if (chats.length === 0) {
+    context.addMessage("system", "No prior chats found. Send a message to start one.");
+    return;
+  }
+  const arg = args2.join(" ").trim();
+  if (!arg) {
+    context.addMessage("system", "Recent chats \u2014 /resume <number|letter|id> to reopen:");
+    chats.forEach((c, i) => {
+      const star = c.id === context.activeChatId ? " \u2605" : "";
+      const project = c.project ? ` (${c.project})` : "";
+      const model = c.model ? ` [${c.model}]` : "";
+      context.addMessage("system", `  ${labelFor2(i)}. ${c.title ?? c.id}${project}${model}${star}`);
+    });
+    return;
+  }
+  const resolved = resolveRecentChat(arg, chats);
+  if (resolved.kind === "error") {
+    context.addMessage("error", resolved.message);
+    return;
+  }
+  await rehydrateChat(resolved.chat, context);
+}
+var LETTERS2, resumeCommand;
+var init_resume = __esm({
+  "src/commands/resume.ts"() {
+    "use strict";
+    init_esm_shims();
+    LETTERS2 = "abcdefghijklmnopqrstuvwxyz";
+    resumeCommand = {
+      name: "resume",
+      aliases: ["continue"],
+      args: "[number|letter|id]",
+      description: "List recent chats and reopen one \u2014 replays its history into the REPL",
+      category: "chat",
+      handler: async (args2, context) => listAndResume(args2, context)
+    };
+  }
+});
+
 // src/commands/broadcast.ts
 var broadcastCommand;
 var init_broadcast = __esm({
@@ -9216,7 +10410,7 @@ function setRawModeGuarded2(stdin, mode) {
   }
 }
 async function promptSecret(prompt4) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const stdin = process.stdin;
     const stdout = process.stdout;
     stdout.write(prompt4);
@@ -9229,12 +10423,12 @@ async function promptSecret(prompt4) {
         setRawModeGuarded2(stdin, wasRaw);
         stdin.removeListener("data", onData);
         stdout.write("\n");
-        resolve20(secret);
+        resolve21(secret);
       } else if (char === "") {
         setRawModeGuarded2(stdin, wasRaw);
         stdin.removeListener("data", onData);
         stdout.write("\n");
-        resolve20("");
+        resolve21("");
       } else if (char === "\x7F" || char === "\b") {
         secret = secret.slice(0, -1);
       } else if (char >= " " && char <= "~") {
@@ -9394,8 +10588,8 @@ var init_memories = __esm({
 
 // src/commands/mdrive.ts
 import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import { basename as basename2, resolve as resolve14, relative as relative14, isAbsolute as isAbsolute14, sep as sep3 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { basename as basename2, resolve as resolve15, relative as relative15, isAbsolute as isAbsolute15, sep as sep3 } from "path";
 function formatBytes(b) {
   if (!b) return "0";
   if (b < 1024) return `${b}`;
@@ -9403,10 +10597,10 @@ function formatBytes(b) {
   return `${(b / 1024 / 1024).toFixed(1)}M`;
 }
 function containLocalPath(targetPath, root = process.cwd()) {
-  const resolvedRoot = resolve14(root);
-  const resolved = isAbsolute14(targetPath) ? resolve14(targetPath) : resolve14(resolvedRoot, targetPath);
-  const rel = relative14(resolvedRoot, resolved);
-  if (rel === ".." || rel.startsWith(`..${sep3}`) || rel.startsWith("../") || isAbsolute14(rel)) {
+  const resolvedRoot = resolve15(root);
+  const resolved = isAbsolute15(targetPath) ? resolve15(targetPath) : resolve15(resolvedRoot, targetPath);
+  const rel = relative15(resolvedRoot, resolved);
+  if (rel === ".." || rel.startsWith(`..${sep3}`) || rel.startsWith("../") || isAbsolute15(rel)) {
     return null;
   }
   return resolved;
@@ -9487,7 +10681,7 @@ var init_mdrive = __esm({
               context.addMessage("error", `Refusing to read local file outside the working directory: ${local}`);
               return;
             }
-            if (!existsSync20(absLocal)) {
+            if (!existsSync21(absLocal)) {
               context.addMessage("error", `Local file not found: ${absLocal}`);
               return;
             }
@@ -9608,14 +10802,14 @@ var init_clear = __esm({
 });
 
 // src/commands/mode.ts
-import { homedir as homedir13 } from "os";
-import { join as join24 } from "path";
-import { existsSync as existsSync21 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join26 } from "path";
+import { existsSync as existsSync22 } from "fs";
 import { readFile as readFile20, writeFile as writeFile12, mkdir as mkdir7 } from "fs/promises";
 async function persistApprovalMode(mode, ttlMs) {
   try {
     let existing = {};
-    if (existsSync21(SETTINGS_PATH)) {
+    if (existsSync22(SETTINGS_PATH)) {
       const text = await readFile20(SETTINGS_PATH, "utf8");
       if (text.trim()) {
         existing = JSON.parse(text);
@@ -9627,8 +10821,8 @@ async function persistApprovalMode(mode, ttlMs) {
       ...ttlMs && { ttlMs }
     };
     existing.approvalMode = entry;
-    const settingsDir = join24(homedir13(), ".msapling");
-    if (!existsSync21(settingsDir)) {
+    const settingsDir = join26(homedir15(), ".msapling");
+    if (!existsSync22(settingsDir)) {
       await mkdir7(settingsDir, { recursive: true });
     }
     await writeFile12(SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf8");
@@ -9640,7 +10834,7 @@ var init_mode = __esm({
   "src/commands/mode.ts"() {
     "use strict";
     init_esm_shims();
-    SETTINGS_PATH = join24(homedir13(), ".msapling", "settings.json");
+    SETTINGS_PATH = join26(homedir15(), ".msapling", "settings.json");
     modeCommand = {
       name: "mode",
       args: "[default|plan|acceptEdits|bypassPermissions] [...options]",
@@ -9913,8 +11107,8 @@ var init_memory = __esm({
 });
 
 // src/commands/project.ts
-function labelFor2(i) {
-  return i < 9 ? String(i + 1) : LETTERS2[i - 9] ?? `#${i + 1}`;
+function labelFor3(i) {
+  return i < 9 ? String(i + 1) : LETTERS3[i - 9] ?? `#${i + 1}`;
 }
 function resolveProject(arg, list2) {
   const trimmed = arg.trim();
@@ -9927,7 +11121,7 @@ function resolveProject(arg, list2) {
     return { kind: "error", message: `no project at index ${n} (have ${list2.length})` };
   }
   if (/^[a-zA-Z]$/.test(trimmed)) {
-    const idx = 9 + LETTERS2.indexOf(trimmed.toLowerCase());
+    const idx = 9 + LETTERS3.indexOf(trimmed.toLowerCase());
     if (idx >= 9 && idx < list2.length) return { kind: "ok", id: list2[idx].id };
   }
   const lower = trimmed.toLowerCase();
@@ -9941,12 +11135,12 @@ function resolveProject(arg, list2) {
   }
   return { kind: "error", message: `no project matches '${trimmed}'. Run /project (no args) for the list.` };
 }
-var LETTERS2, projectCommand;
+var LETTERS3, projectCommand;
 var init_project = __esm({
   "src/commands/project.ts"() {
     "use strict";
     init_esm_shims();
-    LETTERS2 = "abcdefghijklmnopqrstuvwxyz";
+    LETTERS3 = "abcdefghijklmnopqrstuvwxyz";
     projectCommand = {
       name: "project",
       args: "[number|letter|name|id|config]",
@@ -10005,7 +11199,7 @@ var init_project = __esm({
           }
           context.addMessage("system", "Available Projects:");
           projects.forEach((p, i) => {
-            const label = labelFor2(i);
+            const label = labelFor3(i);
             const star = p.id === currentId ? " \u2605" : "";
             const usage = p.chat_count != null && p.chat_limit != null ? `  (${p.chat_count}/${p.chat_limit} chats)` : "";
             context.addMessage("system", `  ${label}. ${p.name ?? p.id}${usage}${star}`);
@@ -10062,8 +11256,8 @@ var init_compact = __esm({
 });
 
 // src/commands/init.ts
-import { join as join25 } from "path";
-import { existsSync as existsSync22 } from "fs";
+import { join as join27 } from "path";
+import { existsSync as existsSync23 } from "fs";
 import { writeFile as writeFile13 } from "fs/promises";
 var initCommand;
 var init_init = __esm({
@@ -10077,8 +11271,8 @@ var init_init = __esm({
       handler: async (args2, context) => {
         try {
           const cwd = process.cwd();
-          const path2 = join25(cwd, "MSAPLING.md");
-          if (existsSync22(path2)) {
+          const path2 = join27(cwd, "MSAPLING.md");
+          if (existsSync23(path2)) {
             context.addMessage("error", "MSAPLING.md already exists in current directory.");
             return;
           }
@@ -10104,7 +11298,7 @@ var init_init = __esm({
 });
 
 // src/commands/review.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { readFile as readFile21 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
@@ -10124,7 +11318,7 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync23(target)) {
+          if (existsSync24(target)) {
             content = await readFile21(target, "utf8");
           } else {
             content = `Review target: ${target}`;
@@ -10218,15 +11412,15 @@ var init_swarm = __esm({
 
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile22 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 function findRecipe(name, cwd) {
   for (const dir of RECIPE_DIRS) {
     for (const suffix of NAME_SUFFIXES) {
       for (const ext of FILE_EXTS) {
-        const p = join26(cwd, dir, `${name}${suffix}${ext}`);
-        if (existsSync24(p)) return p;
+        const p = join28(cwd, dir, `${name}${suffix}${ext}`);
+        if (existsSync25(p)) return p;
       }
     }
   }
@@ -10339,13 +11533,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync25, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync3, statSync as statSync7 } from "fs";
 import { readFile as readFile23 } from "fs/promises";
-import { join as join27, resolve as resolve15 } from "path";
+import { join as join29, resolve as resolve16 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
-    const full = resolve15(cwd, candidate);
-    if (existsSync25(full) && statSync5(full).isDirectory()) return full;
+    const full = resolve16(cwd, candidate);
+    if (existsSync26(full) && statSync7(full).isDirectory()) return full;
   }
   return null;
 }
@@ -10353,28 +11547,28 @@ function listAllSkills(root) {
   const out = [];
   let domains;
   try {
-    domains = readdirSync2(root);
+    domains = readdirSync3(root);
   } catch {
     return out;
   }
   for (const domain of domains) {
-    const dir = join27(root, domain);
+    const dir = join29(root, domain);
     let s;
     try {
-      s = statSync5(dir);
+      s = statSync7(dir);
     } catch {
       continue;
     }
     if (!s.isDirectory()) continue;
     let files;
     try {
-      files = readdirSync2(dir);
+      files = readdirSync3(dir);
     } catch {
       continue;
     }
     for (const f of files) {
       if (!f.endsWith(".md")) continue;
-      out.push({ domain, name: f.slice(0, -3), path: join27(dir, f) });
+      out.push({ domain, name: f.slice(0, -3), path: join29(dir, f) });
     }
   }
   return out.sort(
@@ -10463,9 +11657,9 @@ ${prompt4}`;
 });
 
 // src/commands/benchmark.ts
-import { homedir as homedir14 } from "os";
-import { join as join28 } from "path";
-import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir16 } from "os";
+import { join as join30 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
 import * as fs2 from "fs";
 function parseArgs(args2) {
   let models = null;
@@ -10584,10 +11778,10 @@ HW at start: ${hw.cores}-core ${hw.platform} | CPU ${hw.cpuPct}% | RAM ${hw.ramP
           `[HW at run time: CPU ${hwAtEnd.cpuPct}% / RAM ${hwAtEnd.ramPct}% | ${hw.ramGiB} GiB RAM, ${hw.cores} cores]`
         );
         try {
-          const dir = join28(homedir14(), ".msapling", "benchmarks");
-          mkdirSync4(dir, { recursive: true });
+          const dir = join30(homedir16(), ".msapling", "benchmarks");
+          mkdirSync5(dir, { recursive: true });
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-          const file = join28(dir, `${ts}.json`);
+          const file = join30(dir, `${ts}.json`);
           const run = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             rounds,
@@ -10616,7 +11810,7 @@ var init_hooks = __esm({
     init_src3();
     hooksCommand = {
       name: "hooks",
-      description: "List configured lifecycle hooks (pre-tool-use, post-tool-use, user-prompt-submit)",
+      description: "List configured lifecycle hooks (pre/post-tool-use, user-prompt-submit, session-start/end, stop, subagent-stop, pre-compact, notification)",
       category: "debug",
       handler: async (args2, context) => {
         const sub = args2[0]?.toLowerCase();
@@ -10833,22 +12027,22 @@ var init_theme = __esm({
 });
 
 // src/commands/theme.ts
-import { join as join29 } from "path";
-import { homedir as homedir15 } from "os";
-import { existsSync as existsSync26 } from "fs";
+import { join as join31 } from "path";
+import { homedir as homedir17 } from "os";
+import { existsSync as existsSync27 } from "fs";
 import { readFile as readFile24, writeFile as writeFile14 } from "fs/promises";
 async function persistTheme(storage, themeName) {
-  const settingsPath = join29(homedir15(), ".msapling", "settings.json");
+  const settingsPath = join31(homedir17(), ".msapling", "settings.json");
   let existing = {};
   try {
-    if (existsSync26(settingsPath)) {
+    if (existsSync27(settingsPath)) {
       const text = await readFile24(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
   } catch {
   }
   existing["theme"] = themeName;
-  ensureConfigDir(join29(homedir15(), ".msapling"));
+  ensureConfigDir(join31(homedir17(), ".msapling"));
   await writeFile14(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
@@ -10920,7 +12114,7 @@ var init_version = __esm({
       description: "Show version information for CLI and core packages",
       category: "debug",
       handler: async (_args, context) => {
-        const cliVersion = true ? "2.3.6-beta.45" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.47" : "(dev)";
         const coreVersion = true ? "2.3.6-beta.43" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -10929,7 +12123,7 @@ var init_version = __esm({
         context.addMessage("system", row2("Core (@msapling/core)", coreVersion));
         context.addMessage("system", row2("Runtime (Node/Bun)", runtime));
         try {
-          const ts = "2026-06-20T07:16:00.342Z";
+          const ts = "2026-06-20T08:11:43.445Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -10942,14 +12136,14 @@ var init_version = __esm({
 });
 
 // src/commands/feedback.ts
-import { join as join30 } from "path";
-import { existsSync as existsSync27 } from "fs";
+import { join as join32 } from "path";
+import { existsSync as existsSync28 } from "fs";
 import { readFile as readFile25 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    const pkgPath = join30(baseDir, "..", "..", "package.json");
-    if (!existsSync27(pkgPath)) return "unknown";
+    const pkgPath = join32(baseDir, "..", "..", "package.json");
+    if (!existsSync28(pkgPath)) return "unknown";
     const text = await readFile25(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
@@ -10990,8 +12184,8 @@ var init_feedback = __esm({
 });
 
 // src/commands/export.ts
-import { homedir as homedir16 } from "os";
-import { join as join31 } from "path";
+import { homedir as homedir18 } from "os";
+import { join as join33 } from "path";
 import { writeFile as writeFile15, mkdir as mkdir8 } from "fs/promises";
 function formatTimestamp(date) {
   return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
@@ -11041,10 +12235,10 @@ var init_export = __esm({
         let outputPath;
         let content;
         if (arg === "" || arg === "json") {
-          outputPath = join31(homedir16(), `msapling-export-${timestamp}.json`);
+          outputPath = join33(homedir18(), `msapling-export-${timestamp}.json`);
           content = buildJsonExport(history);
         } else if (arg === "markdown" || arg === "md") {
-          outputPath = join31(homedir16(), `msapling-export-${timestamp}.md`);
+          outputPath = join33(homedir18(), `msapling-export-${timestamp}.md`);
           content = buildMarkdownExport(history);
         } else {
           outputPath = arg;
@@ -11056,7 +12250,7 @@ var init_export = __esm({
           }
         }
         try {
-          const dir = join31(outputPath, "..");
+          const dir = join33(outputPath, "..");
           await mkdir8(dir, { recursive: true });
           await writeFile15(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
@@ -11251,16 +12445,16 @@ var init_plan = __esm({
 });
 
 // src/commands/note.ts
-import { homedir as homedir17 } from "os";
-import { join as join32 } from "path";
-import { existsSync as existsSync28 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join34 } from "path";
+import { existsSync as existsSync29 } from "fs";
 import { readFile as readFile26, writeFile as writeFile16 } from "fs/promises";
 function getNotesFilePath() {
-  return join32(homedir17(), ".msapling", "notes.json");
+  return join34(homedir19(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
-    if (!existsSync28(filePath)) return [];
+    if (!existsSync29(filePath)) return [];
     const raw = await readFile26(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
@@ -11270,7 +12464,7 @@ async function readNotes(filePath = getNotesFilePath()) {
   }
 }
 async function writeNotes(notes, filePath = getNotesFilePath()) {
-  const dir = join32(homedir17(), ".msapling");
+  const dir = join34(homedir19(), ".msapling");
   ensureConfigDir(dir);
   await writeFile16(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
@@ -11416,17 +12610,17 @@ var init_todo = __esm({
 });
 
 // src/commands/outputStyle.ts
-import { homedir as homedir18 } from "os";
-import { join as join33, basename as basename3, extname as extname3 } from "path";
-import { existsSync as existsSync29, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir20 } from "os";
+import { join as join35, basename as basename3, extname as extname3 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 function resolveHome() {
-  return process.env.HOME || process.env.USERPROFILE || homedir18();
+  return process.env.HOME || process.env.USERPROFILE || homedir20();
 }
 function stylesDir() {
-  return join33(resolveHome(), ".msapling", "output-styles");
+  return join35(resolveHome(), ".msapling", "output-styles");
 }
 function activeFile() {
-  return join33(stylesDir(), ".active");
+  return join35(stylesDir(), ".active");
 }
 function parseStyleFile(text) {
   const fm = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
@@ -11447,13 +12641,13 @@ function parseStyleFile(text) {
 }
 function listUserStyles() {
   const dir = stylesDir();
-  if (!existsSync29(dir)) return [];
+  if (!existsSync30(dir)) return [];
   const out = [];
-  for (const entry of readdirSync3(dir)) {
+  for (const entry of readdirSync4(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
-    const full = join33(dir, entry);
+    const full = join35(dir, entry);
     try {
-      const text = readFileSync2(full, "utf8");
+      const text = readFileSync4(full, "utf8");
       const { description, body } = parseStyleFile(text);
       out.push({
         name: basename3(entry, ".md"),
@@ -11479,15 +12673,15 @@ function findStyle(name) {
 function getActiveStyleName() {
   try {
     const f = activeFile();
-    if (!existsSync29(f)) return "default";
-    return readFileSync2(f, "utf8").trim() || "default";
+    if (!existsSync30(f)) return "default";
+    return readFileSync4(f, "utf8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setActiveStyleName(name) {
   const dir = stylesDir();
-  if (!existsSync29(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
   writeFileSync5(activeFile(), `${name}
 `, "utf8");
 }
@@ -11500,8 +12694,8 @@ function createUserStyle(name, description, body) {
     throw new Error(`Invalid style name "${name}" \u2014 use letters, digits, _ and - only.`);
   }
   const dir = stylesDir();
-  if (!existsSync29(dir)) mkdirSync5(dir, { recursive: true });
-  const target = join33(dir, `${name}.md`);
+  if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
+  const target = join35(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
 ---
@@ -12665,6 +13859,259 @@ Note: server may return a [server notice] caveat for v1-scaffold features.`
   }
 });
 
+// src/commands/rewind.ts
+var rewindCommand;
+var init_rewind = __esm({
+  "src/commands/rewind.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src3();
+    rewindCommand = {
+      name: "rewind",
+      aliases: ["checkpoint", "restore"],
+      args: "[n] [--confirm]",
+      description: "List file-edit checkpoints or restore files to a prior snapshot. Usage: /rewind (list) \xB7 /rewind <n> (preview) \xB7 /rewind <n> --confirm (restore).",
+      category: "chat",
+      handler(args2, context) {
+        const checkpoints = listCheckpoints();
+        if (args2.length === 0) {
+          if (checkpoints.length === 0) {
+            context.addMessage(
+              "system",
+              "No checkpoints found. File edits made by the agent will be listed here."
+            );
+            return;
+          }
+          const lines = [
+            `${checkpoints.length} checkpoint(s) \u2014 most recent first:`,
+            ""
+          ];
+          checkpoints.forEach((cp, idx) => {
+            const num = idx + 1;
+            const fileCount = cp.backups.length;
+            const when = new Date(cp.timestamp).toLocaleString();
+            lines.push(
+              `  ${num}. [${when}] ${cp.label}  (${fileCount} file${fileCount !== 1 ? "s" : ""})`
+            );
+          });
+          lines.push("");
+          lines.push("To preview a restore: /rewind <n>");
+          lines.push("To restore:           /rewind <n> --confirm");
+          context.addMessage("system", lines.join("\n"));
+          return;
+        }
+        const positional = args2.filter((a) => !a.startsWith("-"));
+        const hasConfirm = args2.includes("--confirm") || args2.includes("-y") || args2.includes("--yes");
+        if (positional.length === 0) {
+          context.addMessage("system", "Usage: /rewind <n> [--confirm]");
+          return;
+        }
+        const rawN = positional[0];
+        const n = parseInt(rawN, 10);
+        if (isNaN(n) || n < 1) {
+          context.addMessage(
+            "error",
+            `Invalid checkpoint number: "${rawN}". Run /rewind to list available checkpoints.`
+          );
+          return;
+        }
+        if (checkpoints.length === 0) {
+          context.addMessage("system", "No checkpoints available to restore.");
+          return;
+        }
+        if (n > checkpoints.length) {
+          context.addMessage(
+            "error",
+            `Checkpoint #${n} does not exist. ${checkpoints.length} checkpoint(s) available. Run /rewind to list them.`
+          );
+          return;
+        }
+        const target = checkpoints[n - 1];
+        if (!hasConfirm) {
+          const when = new Date(target.timestamp).toLocaleString();
+          const lines = [
+            `Checkpoint #${n}: ${target.label}  [${when}]`,
+            ""
+          ];
+          if (target.backups.length === 0) {
+            lines.push("  (no file edits recorded in this checkpoint)");
+          } else {
+            lines.push("Files that will be reverted:");
+            for (const rec of target.backups) {
+              lines.push(`  - ${rec.originalPath}`);
+            }
+          }
+          lines.push("");
+          lines.push(`To restore these files, run: /rewind ${n} --confirm`);
+          lines.push(
+            "Note: only file contents are restored (chat history is NOT truncated)."
+          );
+          context.addMessage("system", lines.join("\n"));
+          return;
+        }
+        if (target.backups.length === 0) {
+          context.addMessage(
+            "system",
+            `Checkpoint #${n} has no file edits \u2014 nothing to restore.`
+          );
+          return;
+        }
+        const results = restoreCheckpoint(target);
+        const restored = results.filter((r) => r.startsWith("Restored:"));
+        const skipped = results.filter((r) => r.startsWith("Skip"));
+        const errors = results.filter((r) => r.startsWith("Error"));
+        const summary = [
+          `Rewind to checkpoint #${n} complete.`,
+          "",
+          ...results
+        ];
+        if (errors.length > 0) {
+          summary.push("");
+          summary.push(
+            `${errors.length} error(s) occurred. Check that the backup files in ~/.msapling/backups/ are accessible.`
+          );
+        }
+        if (restored.length > 0 && errors.length === 0) {
+          summary.push("");
+          summary.push(
+            `${restored.length} file(s) restored successfully. Note: chat history was NOT truncated (follow-up: REWIND-FOLLOW-UP-01).`
+          );
+        }
+        context.addMessage("system", summary.join("\n"));
+      }
+    };
+  }
+});
+
+// src/commands/bashes.ts
+var bashesCommand;
+var init_bashes = __esm({
+  "src/commands/bashes.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src3();
+    bashesCommand = {
+      name: "bashes",
+      aliases: ["bg", "background"],
+      args: "[read <id> [n] | kill <id|all> | <id>]",
+      description: "List, inspect, or kill background shells",
+      category: "debug",
+      handler(args2, context) {
+        const sub = (args2[0] ?? "").toLowerCase();
+        if (sub === "kill") {
+          const target = args2[1] ?? "";
+          if (!target) {
+            context.addMessage("error", "Usage: /bashes kill <id|all>");
+            return;
+          }
+          if (target.toLowerCase() === "all") {
+            const running = BackgroundShellRegistry.list().filter((s) => s.status === "running");
+            BackgroundShellRegistry.killAll();
+            context.addMessage("system", `Killed ${running.length} running background shell(s).`);
+            return;
+          }
+          const result = BackgroundShellRegistry.kill(target);
+          if (result === "killed") context.addMessage("system", `Killed background shell ${target}.`);
+          else if (result === "already")
+            context.addMessage("system", `Background shell ${target} had already finished.`);
+          else context.addMessage("error", `No background shell with id "${target}".`);
+          return;
+        }
+        const explicitRead = sub === "read";
+        const id = explicitRead ? args2[1] : args2[0];
+        if (id) {
+          const lineArg = explicitRead ? args2[2] : args2[1];
+          const lines = lineArg && /^\d+$/.test(lineArg) ? parseInt(lineArg, 10) : void 0;
+          const read = BackgroundShellRegistry.readOutput(id, lines);
+          const info = BackgroundShellRegistry.get(id);
+          if (!read || !info) {
+            context.addMessage("error", `No background shell with id "${id}".`);
+            return;
+          }
+          const header = `[${info.id}] ${info.status.toUpperCase()}` + (info.exitCode !== void 0 && info.exitCode !== null ? ` exit=${info.exitCode}` : "") + `  $ ${info.command}
+`;
+          const body = read.output.trim() === "" ? "(no output yet)" : read.output;
+          const trunc = read.truncated ? "\n... [output buffer truncated to most recent 256 KB]" : "";
+          context.addMessage("system", header + body + trunc);
+          return;
+        }
+        context.addMessage("system", formatBackgroundShells(BackgroundShellRegistry.list()));
+      }
+    };
+  }
+});
+
+// src/commands/agents.ts
+import { homedir as homedir21 } from "os";
+function resolveHome2() {
+  return process.env.HOME || process.env.USERPROFILE || homedir21();
+}
+function describeTools(agent) {
+  if (agent.tools === void 0) return "all (inherits full tool set)";
+  if (agent.tools.length === 0) return "none (read/reason only)";
+  return agent.tools.join(", ");
+}
+var agentsCommand;
+var init_agents = __esm({
+  "src/commands/agents.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src3();
+    agentsCommand = {
+      name: "agents",
+      aliases: ["agent"],
+      args: "[name]",
+      description: "List named subagents (.msapling/agents/*.md), or show one. Named agents have their own system prompt, model, and tool allowlist.",
+      category: "swarm",
+      handler: (args2, context) => {
+        const cwd = process.cwd();
+        const home = resolveHome2();
+        if (args2.length >= 1 && args2[0] !== "list" && args2[0] !== "ls") {
+          const ref = args2[0];
+          const agent = findNamedAgent(ref, cwd, home);
+          if (!agent) {
+            context.addMessage(
+              "error",
+              `No named agent "${ref}". Run /agents (no args) to list available agents.`
+            );
+            return;
+          }
+          context.addMessage("system", `Agent: ${agent.name}  [${agent.scope}]`);
+          context.addMessage("system", `  description: ${agent.description}`);
+          context.addMessage("system", `  model:       ${agent.model ?? "(inherit session model)"}`);
+          context.addMessage("system", `  tools:       ${describeTools(agent)}`);
+          context.addMessage("system", `  source:      ${agent.path}`);
+          context.addMessage("system", "  \u2500\u2500\u2500 system prompt \u2500\u2500\u2500");
+          context.addMessage("system", agent.systemPrompt || "(empty)");
+          context.addMessage(
+            "system",
+            `Run it: the model can call dispatch_agent with agent="${agent.name}".`
+          );
+          return;
+        }
+        const agents = loadNamedAgents(cwd, home);
+        if (agents.length === 0) {
+          context.addMessage(
+            "system",
+            "No named agents found. Create one at .msapling/agents/<name>.md (project) or ~/.msapling/agents/<name>.md (global). Frontmatter: name, description, model (optional), tools (optional allowlist); body = the system prompt."
+          );
+          return;
+        }
+        context.addMessage("system", `Named subagents (${agents.length}):`);
+        for (const a of agents) {
+          const model = a.model ? ` model=${a.model}` : "";
+          const toolCount = a.tools === void 0 ? "tools=all" : `tools=${a.tools.length}`;
+          context.addMessage(
+            "system",
+            `  ${a.name.padEnd(20)} [${a.scope}] ${toolCount}${model}  \u2014 ${a.description}`
+          );
+        }
+        context.addMessage("system", "Run /agents <name> to see an agent in full.");
+      }
+    };
+  }
+});
+
 // src/commands/index.ts
 var commands_exports = {};
 __export(commands_exports, {
@@ -12689,6 +14136,7 @@ var init_commands = __esm({
     init_exit();
     init_help();
     init_chat();
+    init_resume();
     init_broadcast();
     init_ollama();
     init_keys();
@@ -12735,6 +14183,9 @@ var init_commands = __esm({
     init_diag();
     init_parallel();
     init_remoteAgent();
+    init_rewind();
+    init_bashes();
+    init_agents();
     commands = [
       loginCommand,
       logoutCommand,
@@ -12752,6 +14203,7 @@ var init_commands = __esm({
       helpCommand,
       chatCommand,
       chatsCommand,
+      resumeCommand,
       broadcastCommand,
       ollamaCommand,
       keysCommand,
@@ -12797,7 +14249,10 @@ var init_commands = __esm({
       syncCommand,
       diagCommand,
       parallelCommand,
-      remoteAgentCommand
+      remoteAgentCommand,
+      rewindCommand,
+      bashesCommand,
+      agentsCommand
     ];
   }
 });
@@ -12867,15 +14322,15 @@ var exec_exports = {};
 __export(exec_exports, {
   runExec: () => runExec
 });
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { readFile as readFile29 } from "fs/promises";
-import { homedir as homedir20 } from "os";
-import { join as join35 } from "path";
+import { homedir as homedir23 } from "os";
+import { join as join37 } from "path";
 async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
-    const p = join35(homedir20(), ".msapling", "settings.json");
-    if (!existsSync32(p)) return out;
+    const p = join37(homedir23(), ".msapling", "settings.json");
+    if (!existsSync33(p)) return out;
     const raw = JSON.parse(await readFile29(p, "utf8"));
     const parsed = parseApprovalMode(raw, Date.now());
     if (parsed.kind === "ok") out.mode = parsed.mode;
@@ -13111,7 +14566,7 @@ var init_format = __esm({
 });
 
 // src/commands/billing/open-browser.ts
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 async function openBrowser(url) {
   const platform5 = process.platform;
   let cmd;
@@ -13126,13 +14581,13 @@ async function openBrowser(url) {
     cmd = "xdg-open";
     args2 = [url];
   }
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     try {
-      const child = spawn10(cmd, args2, { stdio: "ignore", detached: true });
+      const child = spawn11(cmd, args2, { stdio: "ignore", detached: true });
       child.unref();
     } catch {
     }
-    resolve20();
+    resolve21();
   });
 }
 var init_open_browser = __esm({
@@ -13222,7 +14677,7 @@ var init_checkout = __esm({
 // src/commands/billing/sub.ts
 import * as readline from "readline";
 function prompt(rl, question) {
-  return new Promise((resolve20) => rl.question(question, resolve20));
+  return new Promise((resolve21) => rl.question(question, resolve21));
 }
 async function runSub(argv) {
   const subCmd = argv[0] ?? "";
@@ -13348,11 +14803,11 @@ var init_sub = __esm({
 // src/commands/billing/topup.ts
 import * as readline2 from "readline";
 function prompt2(rl, question) {
-  return new Promise((resolve20) => rl.question(question, resolve20));
+  return new Promise((resolve21) => rl.question(question, resolve21));
 }
 function promptDefault(rl, question, defaultVal) {
   return new Promise(
-    (resolve20) => rl.question(`${question} [${defaultVal}]: `, (ans) => resolve20(ans.trim() || defaultVal))
+    (resolve21) => rl.question(`${question} [${defaultVal}]: `, (ans) => resolve21(ans.trim() || defaultVal))
   );
 }
 async function runTopup(argv) {
@@ -13487,7 +14942,7 @@ var init_redeem = __esm({
 // src/commands/billing/gift.ts
 import * as readline3 from "readline";
 function prompt3(rl, question) {
-  return new Promise((resolve20) => rl.question(question, resolve20));
+  return new Promise((resolve21) => rl.question(question, resolve21));
 }
 async function runGift(argv) {
   const subCmd = argv[0] ?? "";
@@ -13733,11 +15188,11 @@ var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
-import { homedir as homedir21, platform as platform4, tmpdir } from "os";
-import { join as join36 } from "path";
-import { existsSync as existsSync33, statSync as statSync6 } from "fs";
+import { homedir as homedir24, platform as platform4, tmpdir } from "os";
+import { join as join38 } from "path";
+import { existsSync as existsSync34, statSync as statSync8 } from "fs";
 import { readdir as readdir3, mkdir as mkdir9, rm as rm3 } from "fs/promises";
-import { exec } from "child_process";
+import { exec as exec2 } from "child_process";
 import { promisify } from "util";
 async function checkNodeVersion() {
   const version = process.version;
@@ -13758,8 +15213,8 @@ async function checkNodeVersion() {
   };
 }
 async function checkConfigDir() {
-  const configDir = join36(homedir21(), ".msapling");
-  if (!existsSync33(configDir)) {
+  const configDir = join38(homedir24(), ".msapling");
+  if (!existsSync34(configDir)) {
     return {
       name: "Config directory",
       status: "WARN",
@@ -13767,7 +15222,7 @@ async function checkConfigDir() {
       remediation: `mkdir -p "${configDir}" && chmod 700 "${configDir}"`
     };
   }
-  const stats = statSync6(configDir);
+  const stats = statSync8(configDir);
   if (!stats.isDirectory()) {
     return {
       name: "Config directory",
@@ -13828,7 +15283,7 @@ async function checkPathConflicts() {
   const timedOutDirs = [];
   const DIR_TIMEOUT_MS = 1500;
   for (const dir of paths) {
-    if (!dir || !existsSync33(dir)) continue;
+    if (!dir || !existsSync34(dir)) continue;
     try {
       const files = await Promise.race([
         readdir3(dir),
@@ -13841,7 +15296,7 @@ async function checkPathConflicts() {
       ]);
       for (const file of files) {
         if (file === "msapling" || file === "msapling.exe" || file === "msapling.py") {
-          const fullPath = join36(dir, file);
+          const fullPath = join38(dir, file);
           conflicts.push(fullPath);
         }
       }
@@ -13959,9 +15414,9 @@ async function checkTokenValidity() {
 }
 async function checkOsSpecific() {
   if (platform4() === "win32") {
-    const testDir = join36(tmpdir(), `msapling-longpath-test-${Date.now()}`);
+    const testDir = join38(tmpdir(), `msapling-longpath-test-${Date.now()}`);
     const longDirName = "A".repeat(260);
-    const testPath = join36(testDir, longDirName);
+    const testPath = join38(testDir, longDirName);
     try {
       await mkdir9(testDir, { recursive: true });
       try {
@@ -14115,7 +15570,7 @@ var init_doctor2 = __esm({
     "use strict";
     init_esm_shims();
     init_doctorRedact();
-    execAsync = promisify(exec);
+    execAsync = promisify(exec2);
   }
 });
 
@@ -14161,21 +15616,21 @@ var init_registry_merger = __esm({
 });
 
 // ../core/src/mcp/local_tools.ts
-import { spawn as spawn11 } from "child_process";
+import { spawn as spawn12 } from "child_process";
 import { readdir as readdir4, stat as stat4, realpath as realpath3 } from "fs/promises";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 function asResult(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
 }
 async function runCommand(command, cwd) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     let p;
     const timeout = setTimeout(() => {
       if (p) p.kill();
-      resolve20({ stdout: "", stderr: "Command timed out after 30s", exit_code: -1 });
+      resolve21({ stdout: "", stderr: "Command timed out after 30s", exit_code: -1 });
     }, 3e4);
     try {
-      p = spawn11("sh", ["-c", command], {
+      p = spawn12("sh", ["-c", command], {
         cwd: cwd || process.cwd(),
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 3e4
@@ -14190,15 +15645,15 @@ async function runCommand(command, cwd) {
       });
       p.on("error", (e) => {
         clearTimeout(timeout);
-        resolve20({ stdout, stderr: stderr + (e?.message ?? ""), exit_code: -1 });
+        resolve21({ stdout, stderr: stderr + (e?.message ?? ""), exit_code: -1 });
       });
       p.on("exit", (code) => {
         clearTimeout(timeout);
-        resolve20({ stdout, stderr, exit_code: code });
+        resolve21({ stdout, stderr, exit_code: code });
       });
     } catch (e) {
       clearTimeout(timeout);
-      resolve20({
+      resolve21({
         stdout: "",
         stderr: e?.message ?? "Failed to spawn process",
         exit_code: -1
@@ -14265,7 +15720,7 @@ async function callLocalTool(name, args2, projectRoot) {
       const command = String(args2.command ?? "");
       let cwd = projectRoot;
       if (args2.cwd) {
-        cwd = resolve17(projectRoot, String(args2.cwd));
+        cwd = resolve18(projectRoot, String(args2.cwd));
         try {
           const resolvedCwd = await realpath3(cwd);
           const resolvedRoot = await realpath3(projectRoot);
@@ -14302,7 +15757,7 @@ ${res.stderr}`
         return asResult("path is required", true);
       }
       try {
-        const resolvedPath = await realpath3(resolve17(projectRoot, pathArg));
+        const resolvedPath = await realpath3(resolve18(projectRoot, pathArg));
         const resolvedRoot = await realpath3(projectRoot);
         if (!resolvedPath.startsWith(resolvedRoot)) {
           return asResult("Error: path attempts to escape project root", true);
@@ -14321,7 +15776,7 @@ ${res.stderr}`
     }
     case "local_glob": {
       const pattern = String(args2.pattern ?? "");
-      let cwd = args2.cwd ? resolve17(projectRoot, String(args2.cwd)) : projectRoot;
+      let cwd = args2.cwd ? resolve18(projectRoot, String(args2.cwd)) : projectRoot;
       if (!pattern) {
         return asResult("pattern is required", true);
       }
@@ -14350,7 +15805,7 @@ ${res.stderr}`
       }
       if (path2) {
         try {
-          const resolvedPath = await realpath3(resolve17(projectRoot, path2));
+          const resolvedPath = await realpath3(resolve18(projectRoot, path2));
           const resolvedRoot = await realpath3(projectRoot);
           if (!resolvedPath.startsWith(resolvedRoot)) {
             return asResult("Error: path attempts to escape project root", true);
@@ -14370,7 +15825,7 @@ ${res.stderr}`
         return asResult("cwd is required", true);
       }
       try {
-        const resolvedCwd = await realpath3(resolve17(projectRoot, cwdArg));
+        const resolvedCwd = await realpath3(resolve18(projectRoot, cwdArg));
         const resolvedRoot = await realpath3(projectRoot);
         if (!resolvedCwd.startsWith(resolvedRoot)) {
           return asResult("Error: cwd attempts to escape project root", true);
@@ -14396,7 +15851,7 @@ ${status2.porcelain || "(clean)"}`
         return asResult("cwd is required", true);
       }
       try {
-        const resolvedCwd = await realpath3(resolve17(projectRoot, cwdArg));
+        const resolvedCwd = await realpath3(resolve18(projectRoot, cwdArg));
         const resolvedRoot = await realpath3(projectRoot);
         if (!resolvedCwd.startsWith(resolvedRoot)) {
           return asResult("Error: cwd attempts to escape project root", true);
@@ -14590,13 +16045,13 @@ var init_base = __esm({
           editLength++;
         };
         if (callback) {
-          (function exec2() {
+          (function exec3() {
             setTimeout(function() {
               if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
                 return callback(void 0);
               }
               if (!execEditLength()) {
-                exec2();
+                exec3();
               }
             }, 0);
           })();
@@ -15638,8 +17093,8 @@ var init_libesm = __esm({
 });
 
 // ../core/src/mcp/catalog.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync3, statSync as statSync7 } from "fs";
-import { join as join37, relative as relative15 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync9 } from "fs";
+import { join as join39, relative as relative16 } from "path";
 function buildFileTree(root, maxFiles) {
   const SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "build", "dist", ".venv", "venv", ".next", "__pycache__", ".dart_tool", ".bun", "target"]);
   const SOURCE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".kt", ".swift", ".dart", ".rb", ".cs", ".cpp", ".c", ".h", ".md", ".json", ".yaml", ".yml", ".toml", ".sh", ".sql"]);
@@ -15649,17 +17104,17 @@ function buildFileTree(root, maxFiles) {
     const dir = queue.shift();
     let entries;
     try {
-      entries = readdirSync4(dir);
+      entries = readdirSync5(dir);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (out.length >= maxFiles) break;
       if (SKIP_DIRS2.has(name)) continue;
-      const full = join37(dir, name);
+      const full = join39(dir, name);
       let s;
       try {
-        s = statSync7(full);
+        s = statSync9(full);
       } catch {
         continue;
       }
@@ -15680,12 +17135,12 @@ function readFilesAsContext(root, files, maxKB) {
   for (const f of files) {
     let body;
     try {
-      body = readFileSync3(f, "utf8");
+      body = readFileSync5(f, "utf8");
     } catch {
       continue;
     }
     if (body.length > cap) body = body.slice(0, cap) + "\n[...truncated]";
-    const rel = relative15(root, f).replace(/\\/g, "/");
+    const rel = relative16(root, f).replace(/\\/g, "/");
     parts.push(`### ${rel}
 
 \`\`\`
@@ -15887,7 +17342,7 @@ var init_types = __esm({
 });
 
 // ../core/src/mcp/handlers.ts
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 async function callTool(name, args2, client, getIsProCached) {
   switch (name) {
     case "msapling_chat": {
@@ -15985,7 +17440,7 @@ ${r.response ?? ""}`;
       return asResult2(JSON.stringify(result));
     }
     case "msapling_project_context": {
-      const root = resolve19(String(args2.path ?? "."));
+      const root = resolve20(String(args2.path ?? "."));
       const maxFiles = Number.isFinite(args2.max_files) ? Number(args2.max_files) : 30;
       const maxKB = Number.isFinite(args2.max_file_size_kb) ? Number(args2.max_file_size_kb) : 50;
       const files = buildFileTree(root, maxFiles);
@@ -16240,13 +17695,13 @@ var init_server = __esm({
         if (inflight === 0) {
           return [];
         }
-        const forcedResponses = await new Promise((resolve20) => {
-          this._drainResolve = () => resolve20([]);
+        const forcedResponses = await new Promise((resolve21) => {
+          this._drainResolve = () => resolve21([]);
           setTimeout(() => {
             this._drainResolve = null;
             const remaining = Array.from(this._inflightCalls.values());
             if (remaining.length === 0) {
-              resolve20([]);
+              resolve21([]);
               return;
             }
             process.stderr.write(
@@ -16262,7 +17717,7 @@ var init_server = __esm({
               }
             }));
             this._inflightCalls.clear();
-            resolve20(errorResponses);
+            resolve21(errorResponses);
           }, DRAIN_TIMEOUT_MS);
         });
         return forcedResponses;
@@ -16462,7 +17917,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 var Header = () => /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, marginBottom: 1, children: [
   /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
     "\u25CF MSapling CLI v",
-    "2.3.6-beta.45"
+    "2.3.6-beta.47"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -16867,19 +18322,19 @@ function createIdleAwarePoll(pollingIntervalRef, lastActivityRef, client, setUse
 init_esm_shims();
 init_commands();
 init_plan();
-import { spawn as spawn9 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 
 // src/state/persistentState.ts
 init_esm_shims();
-import { homedir as homedir19 } from "os";
-import { join as join34, dirname as dirname5 } from "path";
-import { existsSync as existsSync30, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join36, dirname as dirname5 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync7 } from "fs";
 import { readFile as readFile27, writeFile as writeFile17, rename as rename3 } from "fs/promises";
-import { randomBytes as randomBytes14 } from "crypto";
-var STATE_PATH = join34(homedir19(), ".msapling", "state.json");
+import { randomBytes as randomBytes15 } from "crypto";
+var STATE_PATH = join36(homedir22(), ".msapling", "state.json");
 async function loadPersistentState(statePath = STATE_PATH) {
   try {
-    if (!existsSync30(statePath)) return { version: 1 };
+    if (!existsSync31(statePath)) return { version: 1 };
     const text = await readFile27(statePath, "utf8");
     const parsed = JSON.parse(text);
     if (parsed.version !== 1) return { version: 1 };
@@ -16895,7 +18350,7 @@ async function loadPersistentState(statePath = STATE_PATH) {
 async function savePersistentState(state, statePath = STATE_PATH) {
   try {
     const dir = dirname5(statePath);
-    if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
+    if (!existsSync31(dir)) mkdirSync7(dir, { recursive: true });
     const existing = await loadPersistentState(statePath);
     const merged = {
       version: 1,
@@ -16903,7 +18358,7 @@ async function savePersistentState(state, statePath = STATE_PATH) {
       lastChatId: state.lastChatId ?? existing.lastChatId
     };
     const pid = process.pid;
-    const rand = randomBytes14(4).toString("hex");
+    const rand = randomBytes15(4).toString("hex");
     const tmp = `${statePath}.tmp.${pid}.${rand}`;
     await writeFile17(tmp, JSON.stringify(merged, null, 2), "utf8");
     await rename3(tmp, statePath);
@@ -16990,7 +18445,7 @@ ${prompt4}` : prompt4;
       ctx.addMessage("system", "\u26A0 Local shell command executed without MCP/tool-level safety controls. Ensure command is trusted.");
       try {
         const shellArgv = process.platform === "win32" ? ["cmd.exe", "/c", execCmd] : ["sh", "-c", execCmd];
-        const proc = spawn9(shellArgv[0], shellArgv.slice(1), {
+        const proc = spawn10(shellArgv[0], shellArgv.slice(1), {
           stdio: ["inherit", "pipe", "pipe"]
         });
         let stdout = "";
@@ -17001,9 +18456,9 @@ ${prompt4}` : prompt4;
         if (proc.stderr) proc.stderr.on("data", (chunk) => {
           stderr += chunk.toString();
         });
-        await new Promise((resolve20, reject) => {
+        await new Promise((resolve21, reject) => {
           proc.on("close", (code) => {
-            if (code === 0 || code === null) resolve20();
+            if (code === 0 || code === null) resolve21();
             else reject(new Error(`Process exited with code ${code}`));
           });
           proc.on("error", reject);
@@ -17042,9 +18497,9 @@ ${prompt4}` : prompt4;
         for (const mention of fileMentions) {
           const filePath = mention.slice(1);
           try {
-            const { existsSync: existsSync34 } = await import("fs");
+            const { existsSync: existsSync35 } = await import("fs");
             const { readFile: readFile30 } = await import("fs/promises");
-            if (existsSync34(filePath)) {
+            if (existsSync35(filePath)) {
               const content = await readFile30(filePath, "utf8");
               const MAX_LEN = 32768;
               const truncated = content.length > MAX_LEN ? content.slice(0, MAX_LEN) + "\n...[TRUNCATED]" : content;
@@ -17106,7 +18561,7 @@ init_src3();
 init_src();
 init_parseApprovalMode();
 import { readFile as readFile28 } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 async function initSession(ctx) {
   try {
     const journalEncrypted = await initJournalEncryption();
@@ -17131,10 +18586,10 @@ async function initSession(ctx) {
       ctx.setShellEscapeEnabled(settings.shellEscapeEnabled !== false);
     }
     try {
-      const { homedir: homedir22 } = await import("os");
-      const { join: join39 } = await import("path");
-      const userSettingsPath = join39(homedir22(), ".msapling", "settings.json");
-      if (existsSync31(userSettingsPath)) {
+      const { homedir: homedir25 } = await import("os");
+      const { join: join41 } = await import("path");
+      const userSettingsPath = join41(homedir25(), ".msapling", "settings.json");
+      if (existsSync32(userSettingsPath)) {
         const userText = await readFile28(userSettingsPath, "utf8");
         let parsed;
         try {
@@ -17263,7 +18718,7 @@ function useTerminalResize() {
 
 // src/App.tsx
 import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
-var App = ({ compact: compact2 = false }) => {
+var App = ({ compact: compact2 = false, continueSession: continueSession2 = false }) => {
   const [user, setUser] = useState4(null);
   const [input, setInput] = useState4("");
   const [history, setHistory] = useState4([]);
@@ -17285,18 +18740,32 @@ var App = ({ compact: compact2 = false }) => {
   const { columns: termResizeCols, rows: termResizeRows } = useTerminalResize();
   const storage = useRef(new StorageManager()).current;
   const client = useRef(new MSaplingClient()).current;
+  const agentRef = useRef(null);
   const requestApproval = useCallback2((request) => {
-    return new Promise((resolve20) => {
-      setPendingApproval({ request, resolve: resolve20 });
+    agentRef.current?.fireLifecycleHook(
+      "notification",
+      { kind: "approval-request", tool: request.tool, command: request.command, reason: request.reason },
+      request.tool
+    );
+    return new Promise((resolve21) => {
+      setPendingApproval({ request, resolve: resolve21 });
     });
   }, []);
   const agent = useRef(new Agent(client, process.cwd(), requestApproval)).current;
+  agentRef.current = agent;
   const trustStore = useRef(new TrustStore()).current;
   const lastActivityRef = useRef(Date.now());
   const pollingIntervalRef = useRef(null);
   useEffect4(() => {
     agent.setApprovalCallback(requestApproval);
   }, [agent, requestApproval]);
+  useEffect4(() => {
+    agent.setOnModeChange((m) => {
+      setModeState(m);
+      addMessage("system", `Mode changed to: ${m} (via plan-mode tool)`);
+    });
+    return () => agent.setOnModeChange(null);
+  }, [agent]);
   const resolveApproval = useCallback2((decision) => {
     setPendingApproval((current) => {
       current?.resolve(decision);
@@ -17358,21 +18827,53 @@ var App = ({ compact: compact2 = false }) => {
     }
   }, [client, activeChatId, activeProjectId, setProjectId, handle401]);
   useEffect4(() => {
-    initSession({
-      agent,
-      client,
-      storage,
-      trustStore,
-      setActiveModel,
-      setMode,
-      setStatus,
-      addMessage,
-      refreshOverview,
-      setShellEscapeEnabled,
-      // CLI-PORT-STATE-04: restore persisted project/chat on cold start.
-      setProjectId,
-      setActiveChatId
-    });
+    (async () => {
+      await initSession({
+        agent,
+        client,
+        storage,
+        trustStore,
+        setActiveModel,
+        setMode,
+        setStatus,
+        addMessage,
+        refreshOverview,
+        setShellEscapeEnabled,
+        // CLI-PORT-STATE-04: restore persisted project/chat on cold start.
+        setProjectId,
+        setActiveChatId
+      });
+      if (continueSession2) {
+        try {
+          const { rehydrateChat: rehydrateChat2 } = await Promise.resolve().then(() => (init_resume(), resume_exports));
+          const recent = await client.listRecentChats(1);
+          if (recent.length > 0) {
+            await rehydrateChat2(recent[0], {
+              client,
+              setActiveChatId,
+              clearHistory,
+              addMessage,
+              refreshOverview
+            });
+          } else {
+            addMessage("system", "--continue: no prior chats to resume.");
+          }
+        } catch (e) {
+          addMessage("system", `--continue: could not resume most-recent chat: ${e?.message ?? e}`);
+        }
+      }
+      agent.fireLifecycleHook("session-start", {
+        cwd: process.cwd(),
+        compact: compact2,
+        continued: continueSession2,
+        chat_id: activeChatId
+      });
+    })();
+  }, []);
+  useEffect4(() => {
+    return () => {
+      agent.fireLifecycleHook("session-end", { cwd: process.cwd() });
+    };
   }, []);
   useEffect4(() => {
     if (!user) return;
@@ -17505,14 +19006,14 @@ var App = ({ compact: compact2 = false }) => {
 
 // src/runtime/bootstrap.ts
 init_esm_shims();
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join38 } from "path";
+import { dirname as dirname6, join as join40 } from "path";
 function readCliVersion2() {
   const here = dirname6(fileURLToPath2(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync4(join38(here, rel), "utf8"));
+      const pkg = JSON.parse(readFileSync6(join40(here, rel), "utf8"));
       if (pkg.name && pkg.version) {
         return { name: pkg.name, version: pkg.version };
       }
@@ -17531,6 +19032,7 @@ function handleCliArgs(args2) {
     console.log("msapling \u2014 MSapling CLI (React/Ink)");
     console.log("Usage: msapling                  start interactive REPL");
     console.log("       msapling --compact        start REPL in compact mode (no footer, thin separators)");
+    console.log("       msapling --continue       resume your most-recent chat (alias: -c); replays its history");
     console.log('       msapling --exec "<cmd>"   run one slash command non-interactively and exit');
     console.log("       msapling mcp serve        run as MCP stdio server (Claude Code / Cursor / Windsurf integration)");
     console.log("       msapling doctor           run diagnostic health checks");
@@ -17617,6 +19119,7 @@ function handleCliArgs(args2) {
 }
 
 // src/index.tsx
+init_src3();
 import { jsx as jsx9 } from "react/jsx-runtime";
 var index_default = App;
 function restoreTerminalMode() {
@@ -17642,12 +19145,19 @@ msapling: fatal ${label}: ${msg}`);
 if (!process.env.NODE_ENV?.includes("test")) {
   process.on("uncaughtException", (err) => handleFatal("uncaught exception", err));
   process.on("unhandledRejection", (reason) => handleFatal("unhandled rejection", reason));
+  process.on("exit", () => {
+    try {
+      BackgroundShellRegistry.killAll();
+    } catch {
+    }
+  });
 }
 var args = process.argv.slice(2);
 var compact = args.includes("--compact");
+var continueSession = args.includes("--continue") || args.includes("-c");
 var shouldRenderRepl = handleCliArgs(args);
 if (shouldRenderRepl && !process.env.NODE_ENV?.includes("test")) {
-  render(/* @__PURE__ */ jsx9(App, { compact }));
+  render(/* @__PURE__ */ jsx9(App, { compact, continueSession }));
 }
 export {
   App,