@mtreeai/msapling-cli 2.3.6-beta.46 → 2.3.6-beta.48

package/dist/index.js

@@ -1032,6 +1032,47 @@ var init_src = __esm({
           body: JSON.stringify({ query, max_results: maxResults })
         });
       }
+      /**
+       * CLI-LOOP-01: cached backend capability map (from GET /chat/health). `null`
+       * until first probed. Cached for the client's lifetime — capabilities are a
+       * deploy-time property of the backend, so a single probe per session suffices.
+       */
+      _capabilities = null;
+      _capabilitiesProbe = null;
+      /**
+       * CLI-LOOP-01: fetch (and cache) the backend capability map from
+       * GET /chat/health. Returns an empty object when the backend is older / the
+       * probe fails, so callers degrade to legacy behavior rather than throwing.
+       *
+       * Concurrent callers share a single in-flight probe.
+       */
+      async getCapabilities(force = false) {
+        if (this._capabilities && !force) return this._capabilities;
+        if (this._capabilitiesProbe && !force) return this._capabilitiesProbe;
+        this._capabilitiesProbe = (async () => {
+          try {
+            const data = await this.request("/api/chat/health");
+            const caps = data && typeof data === "object" && data.capabilities && typeof data.capabilities === "object" ? data.capabilities : {};
+            this._capabilities = caps;
+            return caps;
+          } catch {
+            this._capabilities = {};
+            return this._capabilities;
+          } finally {
+            this._capabilitiesProbe = null;
+          }
+        })();
+        return this._capabilitiesProbe;
+      }
+      /**
+       * CLI-LOOP-01: convenience — does the backend accept the additive structured
+       * `tool_results` array (native parallel multi-tool-use)? When false the Agent
+       * loop uses the legacy `[TOOL_RESULT]`-per-prompt path.
+       */
+      async supportsStructuredToolResults() {
+        const caps = await this.getCapabilities();
+        return caps.structured_tool_results === true;
+      }
       async getHistory(chatId) {
         const data = await this.request(`/api/projects/chat/${chatId}/history`);
         return data.messages.map((m) => ({
@@ -2194,7 +2235,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) {
@@ -2274,9 +2315,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");
@@ -2434,7 +2475,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}`));
@@ -2442,7 +2483,7 @@ ${content}`;
           this.pendingRequests.set(id, {
             resolve: (response) => {
               clearTimeout(timeoutHandle);
-              resolve20(response);
+              resolve21(response);
             },
             reject: (error) => {
               clearTimeout(timeoutHandle);
@@ -2595,9 +2636,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}` };
           }
@@ -2676,27 +2717,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 = "";
@@ -2707,17 +2763,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 {
@@ -2737,7 +2800,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";
@@ -2825,9 +2888,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"],
@@ -2843,6 +2910,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.'
           }
         }
       };
@@ -2870,6 +2945,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 {
@@ -2877,9 +2954,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) {
@@ -2899,15 +2981,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 ? `
@@ -3400,13 +3495,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;
@@ -3422,6 +3668,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.'
@@ -3440,12 +3690,19 @@ var init_DispatchAgentTool = __esm({
       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) {
@@ -3462,9 +3719,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(
@@ -3473,10 +3740,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
@@ -4051,12 +4336,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");
@@ -4090,8 +4375,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) {
@@ -4246,9 +4838,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
@@ -4316,10 +4908,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 [];
@@ -4440,9 +5032,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
@@ -4499,13 +5091,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 {
@@ -4575,10 +5167,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({
@@ -4672,9 +5264,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
@@ -4742,13 +5334,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 {
@@ -4776,14 +5368,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 };
@@ -4792,8 +5384,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 {
@@ -4804,18 +5396,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;
@@ -4875,7 +5467,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);
@@ -4883,11 +5475,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
@@ -4908,7 +5500,7 @@ var init_MoveFileTool = __esm({
               isError: true
             };
           }
-          if (!statSync3(absDst).isDirectory()) {
+          if (!statSync4(absDst).isDirectory()) {
             backedUpTo = await backupFile(absDst);
           }
         }
@@ -4967,7 +5559,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;
@@ -5002,15 +5594,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
@@ -5043,13 +5635,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 {
@@ -5191,7 +5783,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";
@@ -5250,7 +5842,7 @@ var init_Sandbox = __esm({
         "sc"
       ]);
       constructor(projectRoot, opts) {
-        this.projectRoot = resolve13(projectRoot);
+        this.projectRoot = resolve14(projectRoot);
         this.realpathSyncFn = opts?.realpathSync ?? realpathSync;
       }
       setPermissions(state) {
@@ -5265,15 +5857,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 };
@@ -5291,15 +5883,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 };
@@ -5331,7 +5923,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);
@@ -5339,7 +5931,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 };
           }
@@ -5347,7 +5939,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"]);
@@ -5446,7 +6038,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;
@@ -5486,10 +6078,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);
@@ -5586,7 +6178,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;
@@ -5603,55 +6195,34 @@ 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 = !NON_BLOCKING_EVENTS.has(ctx.event) && !!entry.blocking && (exitCode === null || exitCode !== 0);
-      resolve20({ command, exitCode, stdout, stderr, timedOut, blocked });
+      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 NON_BLOCKING_EVENTS, DEFAULT_TIMEOUT_MS3, MAX_OUTPUT_BYTES3, HookRunner;
@@ -5869,9 +6440,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;
@@ -5886,7 +6457,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;
@@ -5967,7 +6538,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++;
       }
       /**
@@ -5986,7 +6557,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++;
       }
       /**
@@ -6044,6 +6615,7 @@ var init_ToolExecutor = __esm({
     init_WebFetchTool();
     init_WebSearchTool();
     init_BashTool();
+    init_BackgroundShellTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
     init_MultiEditFileTool();
@@ -6056,9 +6628,14 @@ var init_ToolExecutor = __esm({
     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;
@@ -6093,6 +6670,8 @@ var init_ToolExecutor = __esm({
        */
       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();
@@ -6121,11 +6700,20 @@ var init_ToolExecutor = __esm({
               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());
@@ -6317,13 +6905,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(() => {
               });
@@ -6338,10 +6926,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()}`;
           }
@@ -6365,7 +6953,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}`
@@ -6426,6 +7014,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)}`);
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -6471,8 +7133,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) {
@@ -6486,7 +7148,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 };
@@ -6509,9 +7171,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) {
@@ -6786,8 +7448,15 @@ var init_Agent = __esm({
         }
         const config = await this.getProjectConfig();
         const MAX_WORKER_TURN_DEPTH = 25;
+        let structuredToolResults = false;
+        try {
+          structuredToolResults = await this.client.supportsStructuredToolResults();
+        } catch {
+          structuredToolResults = false;
+        }
         const queue = [prompt4];
         let rounds = 0;
+        let toolCallSeq = 0;
         let streamUsage = null;
         while (queue.length > 0 && rounds < MAX_WORKER_TURN_DEPTH) {
           if (this.contextBudget.needsCompaction() && queue.length > 0) {
@@ -6831,14 +7500,25 @@ var init_Agent = __esm({
             this.contextBudget.reset();
             if (compactionSummary) {
               const next = queue[0];
-              queue[0] = `[CONTEXT_SUMMARY]: ${compactionSummary}
+              if (typeof next === "string") {
+                queue[0] = `[CONTEXT_SUMMARY]: ${compactionSummary}
 
 ${next}`;
+              } else {
+                queue[0] = {
+                  ...next,
+                  prompt: `[CONTEXT_SUMMARY]: ${compactionSummary}
+
+${next.prompt}`
+                };
+              }
             }
             continue;
           }
-          const currentPrompt = queue.shift();
+          const currentItem = queue.shift();
           rounds++;
+          const currentPrompt = typeof currentItem === "string" ? currentItem : currentItem.prompt;
+          const currentToolResults = typeof currentItem === "string" ? void 0 : currentItem.toolResults;
           const stream = this.chatWithFallback(
             {
               chat_id: chatId,
@@ -6847,11 +7527,16 @@ ${next}`;
               tools: this.executor.getToolSchemas(),
               project_root: this.projectRoot,
               mode: this.executor.getMode(),
+              // CLI-LOOP-01: carry the concurrently-executed tool_results from the
+              // previous turn as a structured batch. Only set in the capability-
+              // enabled path; absent => backend sees the legacy single-prompt turn.
+              ...currentToolResults && currentToolResults.length > 0 ? { tool_results: currentToolResults } : {},
               ...config.combined ? { project_context: config.combined } : {}
             },
             chatId,
             currentPrompt
           );
+          const pendingToolCalls = [];
           for await (const chunk of stream) {
             if (chunk.content) {
               onContent(chunk.content);
@@ -6868,11 +7553,39 @@ ${next}`;
               });
             }
             if (chunk.tool_use) {
-              const result = await this.executor.execute(
-                chunk.tool_use.name,
-                chunk.tool_use.args,
-                this.projectRoot
-              );
+              const id = chunk.tool_use.id ?? `call_${rounds}_${toolCallSeq++}`;
+              pendingToolCalls.push({ id, name: chunk.tool_use.name, args: chunk.tool_use.args });
+            }
+          }
+          if (pendingToolCalls.length === 0) {
+            continue;
+          }
+          if (structuredToolResults) {
+            const toolResults = await Promise.all(
+              pendingToolCalls.map(async (call) => {
+                try {
+                  const result = await this.executor.execute(call.name, call.args, this.projectRoot);
+                  const redactedContent = SafetyGuard.redact(result.content);
+                  return {
+                    tool_use_id: call.id,
+                    name: call.name,
+                    content: redactedContent,
+                    is_error: !!result.isError
+                  };
+                } catch (e) {
+                  return {
+                    tool_use_id: call.id,
+                    name: call.name,
+                    content: SafetyGuard.redact(`Tool execution failed: ${e?.message ?? String(e)}`),
+                    is_error: true
+                  };
+                }
+              })
+            );
+            queue.push({ prompt: "", toolResults });
+          } else {
+            for (const call of pendingToolCalls) {
+              const result = await this.executor.execute(call.name, call.args, this.projectRoot);
               const redactedContent = SafetyGuard.redact(result.content);
               const redactedResult = { ...result, content: redactedContent };
               queue.push(`[TOOL_RESULT]: ${JSON.stringify(redactedResult)}`);
@@ -7119,8 +7832,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);
@@ -7158,8 +7871,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";
@@ -7170,7 +7883,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();
@@ -7327,9 +8040,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() {
@@ -7343,7 +8165,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");
@@ -7352,12 +8174,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();
@@ -7368,7 +8190,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) {
@@ -7387,7 +8209,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);
@@ -7395,7 +8217,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);
     }
@@ -7417,8 +8239,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) {
@@ -7428,8 +8250,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") {
@@ -7440,11 +8262,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;
@@ -7468,20 +8290,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 {
@@ -7494,15 +8316,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"));
@@ -7511,8 +8333,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({
@@ -7523,25 +8345,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");
@@ -7574,8 +8396,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")) {
@@ -7607,10 +8429,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`;
@@ -7620,7 +8442,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);
           }
@@ -7640,21 +8462,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`
@@ -7689,15 +8511,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`;
@@ -7707,7 +8529,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);
           }
@@ -7727,21 +8549,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`
@@ -7776,11 +8598,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"() {
@@ -7807,7 +8629,7 @@ var init_Storage = __esm({
        */
       _ready;
       constructor() {
-        this.baseDir = join21(homedir10(), ".msapling");
+        this.baseDir = join23(homedir12(), ".msapling");
         this._ready = this.ensureDirs();
       }
       async ensureDirs() {
@@ -7824,7 +8646,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);
@@ -7901,8 +8723,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);
@@ -7933,15 +8755,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) {
@@ -7964,7 +8786,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);
@@ -8019,9 +8841,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);
@@ -8074,7 +8896,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"() {
@@ -8110,7 +8932,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
           });
@@ -8184,7 +9006,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`));
@@ -8192,7 +9014,7 @@ var init_client = __esm({
           this.pending.set(id, {
             resolve: (v) => {
               clearTimeout(timer);
-              resolve20(v);
+              resolve21(v);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -8219,7 +9041,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;
@@ -8230,8 +9052,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) {
@@ -8371,6 +9193,8 @@ __export(src_exports2, {
   APPROVAL_GATED: () => APPROVAL_GATED,
   Agent: () => Agent,
   AsyncMutex: () => AsyncMutex,
+  BackgroundShellRegistry: () => BackgroundShellRegistry,
+  BashBackgroundTool: () => BashBackgroundTool,
   BashTool: () => BashTool,
   ContextBudget: () => ContextBudget,
   DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
@@ -8382,6 +9206,8 @@ __export(src_exports2, {
   GrepSearchTool: () => GrepSearchTool,
   HookRunner: () => HookRunner,
   KeychainUnavailableError: () => KeychainUnavailableError,
+  KillBackgroundShellTool: () => KillBackgroundShellTool,
+  ListBackgroundShellsTool: () => ListBackgroundShellsTool,
   ListDirectoryTool: () => ListDirectoryTool,
   MAX_PLAN_CHARS: () => MAX_PLAN_CHARS,
   MCPClient: () => MCPClient,
@@ -8392,8 +9218,10 @@ __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,
@@ -8402,16 +9230,31 @@ __export(src_exports2, {
   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({
@@ -8420,9 +9263,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();
@@ -8442,6 +9287,7 @@ var init_src3 = __esm({
     init_WebSearchTool();
     init_PlanModeTools();
     init_BashTool();
+    init_BackgroundShellTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
     init_MultiEditFileTool();
@@ -8466,7 +9312,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);
@@ -8480,7 +9326,7 @@ async function promptPassword(prompt4) {
       setRawModeGuarded(stdin, wasRaw);
       stdin.removeListener("data", onData);
       stdout.write("\n");
-      resolve20(value);
+      resolve21(value);
     };
     const onData = (chunk) => {
       try {
@@ -8582,7 +9428,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, {
@@ -8606,7 +9452,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}`);
@@ -8951,9 +9797,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 {
@@ -8979,9 +9825,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");
@@ -9656,7 +10502,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);
@@ -9669,12 +10515,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 <= "~") {
@@ -9834,8 +10680,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}`;
@@ -9843,10 +10689,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;
@@ -9927,7 +10773,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;
             }
@@ -10048,14 +10894,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);
@@ -10067,8 +10913,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");
@@ -10080,7 +10926,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]",
@@ -10502,8 +11348,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({
@@ -10517,8 +11363,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;
           }
@@ -10544,7 +11390,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({
@@ -10564,7 +11410,7 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync23(target)) {
+          if (existsSync24(target)) {
             content = await readFile21(target, "utf8");
           } else {
             content = `Review target: ${target}`;
@@ -10658,15 +11504,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;
       }
     }
   }
@@ -10779,13 +11625,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;
 }
@@ -10793,28 +11639,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(
@@ -10903,9 +11749,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;
@@ -11024,10 +11870,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,
@@ -11273,22 +12119,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;
@@ -11360,7 +12206,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.46" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.48" : "(dev)";
         const coreVersion = true ? "2.3.6-beta.43" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -11369,7 +12215,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:22:28.613Z";
+          const ts = "2026-06-20T08:17:10.331Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -11382,14 +12228,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";
@@ -11430,8 +12276,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);
@@ -11481,10 +12327,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;
@@ -11496,7 +12342,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}`);
@@ -11691,16 +12537,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 [];
@@ -11710,7 +12556,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");
 }
@@ -11856,17 +12702,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?/);
@@ -11887,13 +12733,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"),
@@ -11919,15 +12765,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");
 }
@@ -11940,8 +12786,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, " ")}
 ---
@@ -13105,6 +13951,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, {
@@ -13176,6 +14275,9 @@ var init_commands = __esm({
     init_diag();
     init_parallel();
     init_remoteAgent();
+    init_rewind();
+    init_bashes();
+    init_agents();
     commands = [
       loginCommand,
       logoutCommand,
@@ -13239,7 +14341,10 @@ var init_commands = __esm({
       syncCommand,
       diagCommand,
       parallelCommand,
-      remoteAgentCommand
+      remoteAgentCommand,
+      rewindCommand,
+      bashesCommand,
+      agentsCommand
     ];
   }
 });
@@ -13309,15 +14414,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;
@@ -13553,7 +14658,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;
@@ -13568,13 +14673,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({
@@ -13664,7 +14769,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] ?? "";
@@ -13790,11 +14895,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) {
@@ -13929,7 +15034,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] ?? "";
@@ -14175,11 +15280,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;
@@ -14200,8 +15305,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",
@@ -14209,7 +15314,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",
@@ -14270,7 +15375,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),
@@ -14283,7 +15388,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);
         }
       }
@@ -14401,9 +15506,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 {
@@ -14557,7 +15662,7 @@ var init_doctor2 = __esm({
     "use strict";
     init_esm_shims();
     init_doctorRedact();
-    execAsync = promisify(exec);
+    execAsync = promisify(exec2);
   }
 });
 
@@ -14603,21 +15708,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
@@ -14632,15 +15737,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
@@ -14707,7 +15812,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);
@@ -14744,7 +15849,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);
@@ -14763,7 +15868,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);
       }
@@ -14792,7 +15897,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);
@@ -14812,7 +15917,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);
@@ -14838,7 +15943,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);
@@ -15032,13 +16137,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);
           })();
@@ -16080,8 +17185,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"]);
@@ -16091,17 +17196,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;
       }
@@ -16122,12 +17227,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}
 
 \`\`\`
@@ -16329,7 +17434,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": {
@@ -16427,7 +17532,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);
@@ -16682,13 +17787,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(
@@ -16704,7 +17809,7 @@ var init_server = __esm({
               }
             }));
             this._inflightCalls.clear();
-            resolve20(errorResponses);
+            resolve21(errorResponses);
           }, DRAIN_TIMEOUT_MS);
         });
         return forcedResponses;
@@ -16904,7 +18009,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.46"
+    "2.3.6-beta.48"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -17309,19 +18414,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 };
@@ -17337,7 +18442,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,
@@ -17345,7 +18450,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);
@@ -17432,7 +18537,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 = "";
@@ -17443,9 +18548,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);
@@ -17484,9 +18589,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;
@@ -17548,7 +18653,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();
@@ -17573,10 +18678,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 {
@@ -17734,8 +18839,8 @@ var App = ({ compact: compact2 = false, continueSession: continueSession2 = fals
       { kind: "approval-request", tool: request.tool, command: request.command, reason: request.reason },
       request.tool
     );
-    return new Promise((resolve20) => {
-      setPendingApproval({ request, resolve: resolve20 });
+    return new Promise((resolve21) => {
+      setPendingApproval({ request, resolve: resolve21 });
     });
   }, []);
   const agent = useRef(new Agent(client, process.cwd(), requestApproval)).current;
@@ -17993,14 +19098,14 @@ var App = ({ compact: compact2 = false, continueSession: continueSession2 = fals
 
 // 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 };
       }
@@ -18106,6 +19211,7 @@ function handleCliArgs(args2) {
 }
 
 // src/index.tsx
+init_src3();
 import { jsx as jsx9 } from "react/jsx-runtime";
 var index_default = App;
 function restoreTerminalMode() {
@@ -18131,6 +19237,12 @@ 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");