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

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) => ({
@@ -5356,17 +5397,17 @@ async function backupFile(absPath) {
   try {
     const { readFile: readFile30, writeFile: writeFile19, mkdir: mkdir10 } = await import("fs/promises");
     const { homedir: homedir25 } = await import("os");
-    const { join: join41 } = await import("path");
+    const { join: join42 } = 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 = join41(
+    const backupPath = join42(
       homedir25(),
       ".msapling",
       "backups",
       `${filename}.backup-${stamp}-${suffix}.bak`
     );
-    await mkdir10(join41(homedir25(), ".msapling", "backups"), { recursive: true });
+    await mkdir10(join42(homedir25(), ".msapling", "backups"), { recursive: true });
     const content = await readFile30(absPath, "utf8");
     await writeFile19(backupPath, content, "utf8");
     return backupPath;
@@ -5976,10 +6017,10 @@ var init_Sandbox = __esm({
        * to a minimal platform default so subprocess spawn never sees an empty PATH.
        */
       static curatePath(rawPath) {
-        const sep4 = process.platform === "win32" ? ";" : ":";
-        const entries = (rawPath ?? "").split(sep4);
+        const sep5 = process.platform === "win32" ? ";" : ":";
+        const entries = (rawPath ?? "").split(sep5);
         const kept = entries.filter((e) => _Sandbox.isSafePathEntry(e));
-        if (kept.length > 0) return kept.join(sep4);
+        if (kept.length > 0) return kept.join(sep5);
         return process.platform === "win32" ? "C:\\Windows\\System32;C:\\Windows" : "/usr/local/bin:/usr/bin:/bin";
       }
       getRestrictedEnv(pathOverride) {
@@ -6553,6 +6594,124 @@ var init_ResourceGovernor = __esm({
   }
 });
 
+// ../core/src/SessionStats.ts
+function getSessionStats() {
+  if (!singleton) singleton = new SessionStats();
+  return singleton;
+}
+function _resetSessionStatsSingleton() {
+  singleton = null;
+}
+function fmtDuration(ms) {
+  const s = Math.floor(ms / 1e3);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  const parts = [];
+  if (h) parts.push(`${h}h`);
+  if (m || h) parts.push(`${m}m`);
+  parts.push(`${sec}s`);
+  return parts.join(" ");
+}
+function renderSessionStats(snap) {
+  const lines = [];
+  lines.push("=== Session Stats ===");
+  lines.push(`  Duration:       ${fmtDuration(snap.wallMs)}`);
+  const toolNames = Object.keys(snap.tools).sort();
+  lines.push("");
+  lines.push(`  Tool calls:     ${snap.totalToolCalls}`);
+  if (toolNames.length === 0) {
+    lines.push("    (no tools invoked yet)");
+  } else {
+    for (const name of toolNames) {
+      const t = snap.tools[name];
+      const avg = t.count > 0 ? t.totalMs / t.count : 0;
+      const errStr = t.errors > 0 ? `, ${t.errors} err` : "";
+      lines.push(
+        `    - ${name}: ${t.count}\xD7 (avg ${avg.toFixed(0)}ms, total ${t.totalMs.toFixed(0)}ms${errStr})`
+      );
+    }
+  }
+  const a = snap.approvals;
+  if (a.approved || a.denied || a.autoApproved) {
+    lines.push("");
+    lines.push("  Approvals:");
+    lines.push(`    - approved:      ${a.approved}`);
+    lines.push(`    - denied:        ${a.denied}`);
+    lines.push(`    - auto (trusted):${a.autoApproved}`);
+  }
+  const u = snap.usage;
+  const totalTokens = u.promptTokens + u.completionTokens;
+  lines.push("");
+  lines.push("  Usage:");
+  lines.push(`    - turns:         ${u.turns}`);
+  lines.push(`    - prompt tokens: ${u.promptTokens.toLocaleString()}`);
+  lines.push(`    - output tokens: ${u.completionTokens.toLocaleString()}`);
+  lines.push(`    - total tokens:  ${totalTokens.toLocaleString()}`);
+  lines.push(`    - cost (USD):    $${u.costUsd.toFixed(4)}`);
+  if (u.turns > 0) {
+    lines.push(`    - avg cost/turn: $${(u.costUsd / u.turns).toFixed(4)}`);
+  }
+  return lines;
+}
+var SessionStats, singleton;
+var init_SessionStats = __esm({
+  "../core/src/SessionStats.ts"() {
+    "use strict";
+    init_esm_shims();
+    SessionStats = class {
+      startedAt = Date.now();
+      tools = /* @__PURE__ */ new Map();
+      usage = { costUsd: 0, promptTokens: 0, completionTokens: 0, turns: 0 };
+      approvals = { approved: 0, denied: 0, autoApproved: 0 };
+      /** Record a single tool invocation's outcome + latency. */
+      recordTool(name, latencyMs, isError) {
+        const cur = this.tools.get(name) ?? { count: 0, errors: 0, totalMs: 0 };
+        cur.count += 1;
+        if (isError) cur.errors += 1;
+        cur.totalMs += Math.max(0, latencyMs);
+        this.tools.set(name, cur);
+      }
+      /** Record an approval-gate outcome for a tool call. */
+      recordApproval(kind) {
+        this.approvals[kind] += 1;
+      }
+      /** Record backend usage from a completed agent turn. */
+      recordUsage(costUsd, promptTokens, completionTokens) {
+        if (Number.isFinite(costUsd)) this.usage.costUsd += costUsd;
+        if (Number.isFinite(promptTokens)) this.usage.promptTokens += promptTokens;
+        if (Number.isFinite(completionTokens)) this.usage.completionTokens += completionTokens;
+        this.usage.turns += 1;
+      }
+      /** Immutable snapshot for rendering. */
+      snapshot() {
+        const tools = {};
+        let totalToolCalls = 0;
+        for (const [name, s] of this.tools) {
+          tools[name] = { ...s };
+          totalToolCalls += s.count;
+        }
+        return {
+          startedAt: this.startedAt,
+          wallMs: Date.now() - this.startedAt,
+          tools,
+          totalToolCalls,
+          usage: { ...this.usage },
+          approvals: { ...this.approvals }
+        };
+      }
+      /** Reset everything (used by tests and a potential /stats reset). */
+      reset() {
+        this.startedAt = Date.now();
+        this.tools.clear();
+        this.usage = { costUsd: 0, promptTokens: 0, completionTokens: 0, turns: 0 };
+        this.approvals = { approved: 0, denied: 0, autoApproved: 0 };
+      }
+    };
+    singleton = null;
+  }
+});
+
 // ../core/src/agent/ToolExecutor.ts
 import { readFile as readFile10 } from "fs/promises";
 var APPROVAL_GATED, ToolExecutor;
@@ -6587,6 +6746,7 @@ var init_ToolExecutor = __esm({
     init_ShadowService();
     init_Hooks();
     init_ResourceGovernor();
+    init_SessionStats();
     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();
@@ -6900,8 +7060,10 @@ ${blocker.stderr || "(empty)"}`,
               reason: `${toolName} requested by agent in '${this.mode}' mode`
             });
             if (decision === "no") {
+              getSessionStats().recordApproval("denied");
               return { content: `User denied ${toolName} approval.`, isError: true };
             }
+            getSessionStats().recordApproval("approved");
             if (decision === "always") {
               if (this.trustStore) {
                 this.trustStore.add(cmdKey).catch(() => {
@@ -6910,6 +7072,8 @@ ${blocker.stderr || "(empty)"}`,
                 this.sessionTrust.add(cmdKey);
               }
             }
+          } else {
+            getSessionStats().recordApproval("autoApproved");
           }
         }
         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") {
@@ -6941,10 +7105,20 @@ Please approve the diff in the UI to sync this change locally.`
         const governor = await getGlobalGovernor();
         await governor.acquireTool();
         let result;
+        const startedAt = Date.now();
+        let threw = false;
         try {
           result = await tool.execute(args2, projectRoot);
+        } catch (e) {
+          threw = true;
+          throw e;
         } finally {
           governor.releaseTool();
+          getSessionStats().recordTool(
+            toolName,
+            Date.now() - startedAt,
+            threw || !!(result && result.isError)
+          );
         }
         if (this.hooks) {
           this.hooks.fire({
@@ -7153,13 +7327,14 @@ async function loadProjectConfig(cwd = process.cwd()) {
   const [user, project] = await Promise.all([findUserConfig(), findProjectConfig(cwd)]);
   return { user, project, combined: buildCombined(user, project) };
 }
-var FILENAMES, TRUNCATE_AT;
+var FILENAMES, TRUNCATE_AT, PROJECT_CONFIG_FILENAMES;
 var init_ProjectConfig = __esm({
   "../core/src/ProjectConfig.ts"() {
     "use strict";
     init_esm_shims();
     FILENAMES = ["MSAPLING.md", "CLAUDE.md", "GEMINI.md", "AGENTS.md"];
     TRUNCATE_AT = 32e3;
+    PROJECT_CONFIG_FILENAMES = FILENAMES;
   }
 });
 
@@ -7407,8 +7582,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) {
@@ -7452,14 +7634,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,
@@ -7468,11 +7661,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);
@@ -7489,11 +7687,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)}`);
@@ -9125,8 +9351,10 @@ __export(src_exports2, {
   MultiEditFileTool: () => MultiEditFileTool,
   NotebookEditTool: () => NotebookEditTool,
   NotebookReadTool: () => NotebookReadTool,
+  PROJECT_CONFIG_FILENAMES: () => PROJECT_CONFIG_FILENAMES,
   PatchFileTool: () => PatchFileTool,
   ReadBackgroundShellTool: () => ReadBackgroundShellTool,
+  SessionStats: () => SessionStats,
   StorageManager: () => StorageManager,
   SwarmManager: () => SwarmManager,
   TOOL_NAME_ALIASES: () => TOOL_NAME_ALIASES,
@@ -9138,6 +9366,7 @@ __export(src_exports2, {
   WebFetchTool: () => WebFetchTool,
   WebSearchTool: () => WebSearchTool,
   WriteFileTool: () => WriteFileTool,
+  _resetSessionStatsSingleton: () => _resetSessionStatsSingleton,
   _setBackupDirOverride: () => _setBackupDirOverride,
   backupDir: () => backupDir,
   buildCompactionPrompt: () => buildCompactionPrompt,
@@ -9151,6 +9380,7 @@ __export(src_exports2, {
   formatNotebookHeader: () => formatNotebookHeader,
   formatTodos: () => formatTodos,
   getOrCreateJournalKey: () => getOrCreateJournalKey,
+  getSessionStats: () => getSessionStats,
   initJournalEncryption: () => initJournalEncryption,
   listCheckpoints: () => listCheckpoints,
   loadNamedAgents: () => loadNamedAgents,
@@ -9162,6 +9392,7 @@ __export(src_exports2, {
   parseAgentFile: () => parseAgentFile,
   parseToolsValue: () => parseToolsValue,
   recordBackup: () => recordBackup,
+  renderSessionStats: () => renderSessionStats,
   restoreCheckpoint: () => restoreCheckpoint,
   takeSnapshot: () => takeSnapshot
 });
@@ -9180,6 +9411,7 @@ var init_src3 = __esm({
     init_Storage();
     init_journalCrypto();
     init_Mutex();
+    init_SessionStats();
     init_ProjectConfig();
     init_Settings();
     init_client();
@@ -11255,40 +11487,405 @@ var init_compact = __esm({
   }
 });
 
+// src/runtime/codebaseScan.ts
+import { existsSync as existsSync23, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync7 } from "fs";
+import { join as join27, relative as relative16, sep as sep4, basename as basename3 } from "path";
+function parseGitignore(content) {
+  const patterns = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("!"));
+  const matchers = patterns.map((raw) => {
+    let p = raw;
+    const dirOnly = p.endsWith("/");
+    if (dirOnly) p = p.slice(0, -1);
+    const anchored = p.startsWith("/");
+    if (anchored) p = p.slice(1);
+    const re = new RegExp(
+      "^" + p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(//g, ".*").replace(/\?/g, "[^/]") + "$"
+    );
+    return { re, dirOnly, anchored, base: p };
+  });
+  return (relPath, isDir) => {
+    const posix = relPath.split(sep4).join("/");
+    for (const m of matchers) {
+      if (m.dirOnly && !isDir) continue;
+      if (m.anchored) {
+        if (m.re.test(posix)) return true;
+      } else {
+        if (m.re.test(posix)) return true;
+        if (m.re.test(basename3(posix))) return true;
+        const segs = posix.split("/");
+        for (let i = 0; i < segs.length; i++) {
+          if (m.re.test(segs[i])) return true;
+        }
+      }
+    }
+    return false;
+  };
+}
+function loadIgnore(root) {
+  try {
+    const gi = join27(root, ".gitignore");
+    if (existsSync23(gi)) {
+      return parseGitignore(readFileSync4(gi, "utf8"));
+    }
+  } catch {
+  }
+  return () => false;
+}
+function readJsonSafe(path2) {
+  try {
+    return JSON.parse(readFileSync4(path2, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function detectStacks(root) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const probe of STACK_PROBES) {
+    const hit = probe.detect(root);
+    if (hit && !seen.has(hit.name)) {
+      seen.add(hit.name);
+      found.push(hit);
+    }
+  }
+  return found;
+}
+function inferCommands(root, stacks) {
+  const cmds = { extra: {} };
+  for (const stack of stacks) {
+    if (stack.manifest === "package.json") {
+      const pkg = readJsonSafe(join27(root, "package.json"));
+      const scripts = pkg?.scripts ?? {};
+      const pm = stack.packageManager ?? "npm";
+      const runScript = (name) => pm === "npm" ? `npm run ${name}` : `${pm} run ${name}`;
+      if (scripts.build) cmds.build = runScript("build");
+      if (scripts.test) cmds.test = pm === "npm" ? "npm test" : `${pm} test`;
+      if (scripts.start) cmds.run = pm === "npm" ? "npm start" : `${pm} start`;
+      else if (scripts.dev) cmds.run = runScript("dev");
+      if (scripts.lint) cmds.lint = runScript("lint");
+      for (const name of ["typecheck", "format", "e2e", "coverage"]) {
+        if (scripts[name]) cmds.extra[name] = runScript(name);
+      }
+    } else if (stack.name === "Python") {
+      cmds.test = cmds.test ?? "pytest";
+      if (stack.packageManager === "poetry") cmds.run = cmds.run ?? "poetry run python -m <module>";
+    } else if (stack.name === "Go") {
+      cmds.build = cmds.build ?? "go build ./...";
+      cmds.test = cmds.test ?? "go test ./...";
+      cmds.run = cmds.run ?? "go run .";
+    } else if (stack.name === "Rust") {
+      cmds.build = cmds.build ?? "cargo build";
+      cmds.test = cmds.test ?? "cargo test";
+      cmds.run = cmds.run ?? "cargo run";
+    } else if (stack.name === "Java / Maven") {
+      cmds.build = cmds.build ?? "mvn package";
+      cmds.test = cmds.test ?? "mvn test";
+    } else if (stack.name === "Java / Kotlin (Gradle)") {
+      cmds.build = cmds.build ?? "gradle build";
+      cmds.test = cmds.test ?? "gradle test";
+    } else if (stack.name === "Ruby") {
+      cmds.test = cmds.test ?? "bundle exec rspec";
+    } else if (stack.name === "PHP") {
+      cmds.test = cmds.test ?? "composer test";
+    }
+  }
+  return cmds;
+}
+function detectEntryPoints(root, stacks) {
+  const out = [];
+  for (const stack of stacks) {
+    if (stack.manifest === "package.json") {
+      const pkg = readJsonSafe(join27(root, "package.json"));
+      if (pkg?.main && existsSync23(join27(root, pkg.main))) out.push(pkg.main);
+      if (typeof pkg?.bin === "string" && existsSync23(join27(root, pkg.bin))) out.push(pkg.bin);
+      else if (pkg?.bin && typeof pkg.bin === "object") {
+        for (const v of Object.values(pkg.bin)) {
+          if (typeof v === "string" && existsSync23(join27(root, v))) out.push(v);
+        }
+      }
+    }
+  }
+  for (const c of ENTRY_CANDIDATES) {
+    if (existsSync23(join27(root, c)) && !out.includes(c)) out.push(c);
+  }
+  return out.slice(0, 8);
+}
+function scanCodebase(root, opts = {}) {
+  const maxFiles = opts.maxFiles ?? DEFAULT_MAX_FILES;
+  const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const ignored = loadIgnore(root);
+  let fileCount = 0;
+  let dirCount = 0;
+  let truncated = false;
+  const keyDirs = /* @__PURE__ */ new Set();
+  const walk = (dir, depth) => {
+    if (truncated || depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (fileCount >= maxFiles) {
+        truncated = true;
+        return;
+      }
+      const abs = join27(dir, name);
+      let isDir = false;
+      try {
+        isDir = statSync7(abs).isDirectory();
+      } catch {
+        continue;
+      }
+      const rel = relative16(root, abs);
+      if (isDir) {
+        if (ALWAYS_IGNORE_DIRS.has(name)) continue;
+        if (name.startsWith(".") && depth >= 1) continue;
+        if (ignored(rel, true)) continue;
+        dirCount++;
+        if (depth === 0) keyDirs.add(rel.split(sep4).join("/"));
+        walk(abs, depth + 1);
+      } else {
+        if (ignored(rel, false)) continue;
+        fileCount++;
+      }
+    }
+  };
+  walk(root, 0);
+  const stacks = detectStacks(root);
+  const commands2 = inferCommands(root, stacks);
+  const entryPoints = detectEntryPoints(root, stacks);
+  return {
+    root,
+    stacks,
+    keyDirs: Array.from(keyDirs).sort(),
+    entryPoints,
+    commands: commands2,
+    fileCount,
+    dirCount,
+    truncated
+  };
+}
+function renderMemoryFile(scan, title = "Project Memory") {
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push("");
+  lines.push(
+    "> Auto-generated by `/init` (deep codebase scan). Edit freely \u2014 re-running `/init` refreshes the scanned sections but preserves this file if you have customized it."
+  );
+  lines.push("");
+  lines.push("## Stack");
+  if (scan.stacks.length === 0) {
+    lines.push("- No recognized manifest found (no package.json / pyproject.toml / go.mod / Cargo.toml / etc.).");
+  } else {
+    for (const s of scan.stacks) {
+      const pm = s.packageManager ? ` (${s.packageManager})` : "";
+      lines.push(`- **${s.name}**${pm} \u2014 detected via \`${s.manifest}\``);
+    }
+  }
+  lines.push("");
+  lines.push("## Commands");
+  const c = scan.commands;
+  const cmdRows = [
+    ["Build", c.build],
+    ["Test", c.test],
+    ["Run", c.run],
+    ["Lint", c.lint]
+  ];
+  const anyCmd = cmdRows.some(([, v]) => v) || Object.keys(c.extra).length > 0;
+  if (!anyCmd) {
+    lines.push("- No build/test/run commands could be inferred from the manifests.");
+  } else {
+    for (const [label, val] of cmdRows) {
+      if (val) lines.push(`- **${label}:** \`${val}\``);
+    }
+    for (const [name, val] of Object.entries(c.extra)) {
+      lines.push(`- **${name}:** \`${val}\``);
+    }
+  }
+  lines.push("");
+  lines.push("## Structure");
+  lines.push(
+    `- ${scan.dirCount} directories, ${scan.fileCount} files scanned${scan.truncated ? " (scan capped \u2014 large repo)" : ""}.`
+  );
+  if (scan.keyDirs.length > 0) {
+    lines.push("- Key directories:");
+    for (const d of scan.keyDirs) lines.push(`  - \`${d}/\``);
+  }
+  lines.push("");
+  lines.push("## Entry points");
+  if (scan.entryPoints.length === 0) {
+    lines.push("- No obvious entry point detected.");
+  } else {
+    for (const e of scan.entryPoints) lines.push(`- \`${e}\``);
+  }
+  lines.push("");
+  lines.push("## Guidelines");
+  lines.push("- Follow the existing code style and conventions in this repository.");
+  lines.push("- Run the test command above before considering a change complete.");
+  lines.push("");
+  return lines.join("\n");
+}
+var DEFAULT_MAX_FILES, DEFAULT_MAX_DEPTH, ALWAYS_IGNORE_DIRS, STACK_PROBES, ENTRY_CANDIDATES;
+var init_codebaseScan = __esm({
+  "src/runtime/codebaseScan.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_MAX_FILES = 5e3;
+    DEFAULT_MAX_DEPTH = 6;
+    ALWAYS_IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".hg",
+      ".svn",
+      "dist",
+      "build",
+      "out",
+      "target",
+      ".next",
+      ".nuxt",
+      ".cache",
+      "coverage",
+      ".venv",
+      "venv",
+      "__pycache__",
+      ".idea",
+      ".vscode",
+      "vendor",
+      ".bun",
+      ".turbo"
+    ]);
+    STACK_PROBES = [
+      {
+        manifest: "package.json",
+        detect: (root) => {
+          const path2 = join27(root, "package.json");
+          if (!existsSync23(path2)) return null;
+          const pkg = readJsonSafe(path2);
+          let pm = "npm";
+          if (existsSync23(join27(root, "bun.lock")) || existsSync23(join27(root, "bun.lockb"))) pm = "bun";
+          else if (existsSync23(join27(root, "pnpm-lock.yaml"))) pm = "pnpm";
+          else if (existsSync23(join27(root, "yarn.lock"))) pm = "yarn";
+          const hasTs = existsSync23(join27(root, "tsconfig.json")) || !!(pkg?.devDependencies?.typescript || pkg?.dependencies?.typescript);
+          return {
+            name: hasTs ? "Node.js / TypeScript" : "Node.js / JavaScript",
+            manifest: "package.json",
+            packageManager: pm
+          };
+        }
+      },
+      {
+        manifest: "pyproject.toml",
+        detect: (root) => {
+          if (!existsSync23(join27(root, "pyproject.toml"))) return null;
+          let pm = "pip";
+          if (existsSync23(join27(root, "poetry.lock"))) pm = "poetry";
+          else if (existsSync23(join27(root, "uv.lock"))) pm = "uv";
+          return { name: "Python", manifest: "pyproject.toml", packageManager: pm };
+        }
+      },
+      {
+        manifest: "requirements.txt",
+        detect: (root) => {
+          if (!existsSync23(join27(root, "requirements.txt"))) return null;
+          return { name: "Python", manifest: "requirements.txt", packageManager: "pip" };
+        }
+      },
+      {
+        manifest: "go.mod",
+        detect: (root) => existsSync23(join27(root, "go.mod")) ? { name: "Go", manifest: "go.mod", packageManager: "go" } : null
+      },
+      {
+        manifest: "Cargo.toml",
+        detect: (root) => existsSync23(join27(root, "Cargo.toml")) ? { name: "Rust", manifest: "Cargo.toml", packageManager: "cargo" } : null
+      },
+      {
+        manifest: "pom.xml",
+        detect: (root) => existsSync23(join27(root, "pom.xml")) ? { name: "Java / Maven", manifest: "pom.xml", packageManager: "maven" } : null
+      },
+      {
+        manifest: "build.gradle",
+        detect: (root) => existsSync23(join27(root, "build.gradle")) || existsSync23(join27(root, "build.gradle.kts")) ? { name: "Java / Kotlin (Gradle)", manifest: "build.gradle", packageManager: "gradle" } : null
+      },
+      {
+        manifest: "Gemfile",
+        detect: (root) => existsSync23(join27(root, "Gemfile")) ? { name: "Ruby", manifest: "Gemfile", packageManager: "bundler" } : null
+      },
+      {
+        manifest: "composer.json",
+        detect: (root) => existsSync23(join27(root, "composer.json")) ? { name: "PHP", manifest: "composer.json", packageManager: "composer" } : null
+      }
+    ];
+    ENTRY_CANDIDATES = [
+      "src/index.ts",
+      "src/index.tsx",
+      "src/index.js",
+      "src/main.ts",
+      "src/main.tsx",
+      "src/main.py",
+      "src/main.rs",
+      "index.ts",
+      "index.js",
+      "main.py",
+      "main.go",
+      "app.py",
+      "manage.py",
+      "cmd/main.go",
+      "src/main/java"
+    ];
+  }
+});
+
 // src/commands/init.ts
-import { join as join27 } from "path";
-import { existsSync as existsSync23 } from "fs";
+import { join as join28 } from "path";
+import { existsSync as existsSync24 } from "fs";
 import { writeFile as writeFile13 } from "fs/promises";
+function resolveTargetFile(cwd) {
+  for (const filename2 of PROJECT_CONFIG_FILENAMES) {
+    const path2 = join28(cwd, filename2);
+    if (existsSync24(path2)) return { path: path2, filename: filename2, existed: true };
+  }
+  const filename = PROJECT_CONFIG_FILENAMES[0];
+  return { path: join28(cwd, filename), filename, existed: false };
+}
 var initCommand;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_esm_shims();
+    init_src3();
+    init_codebaseScan();
     initCommand = {
       name: "init",
-      description: "Create MSAPLING.md (or CLAUDE.md-compat) in cwd with project-detected boilerplate",
+      args: "[--force]",
+      description: "Scan the codebase (stack, commands, structure, entry points) and write/refresh a project-memory file (MSAPLING.md/CLAUDE.md/\u2026)",
       category: "project",
       handler: async (args2, context) => {
         try {
           const cwd = process.cwd();
-          const path2 = join27(cwd, "MSAPLING.md");
-          if (existsSync23(path2)) {
-            context.addMessage("error", "MSAPLING.md already exists in current directory.");
+          const force = args2.includes("--force");
+          const target = resolveTargetFile(cwd);
+          if (target.existed && !force) {
+            context.addMessage(
+              "error",
+              `${target.filename} already exists. Re-run \`/init --force\` to refresh it from a fresh codebase scan.`
+            );
             return;
           }
-          const content = `# MSapling Project Configuration
-
-## Build
-- \`npm run build\` or equivalent.
-
-## Test
-- \`npm test\` or equivalent.
-
-## Guidelines
-- Follow existing code style.
-`;
-          await writeFile13(path2, content, "utf8");
-          context.addMessage("system", `Created MSAPLING.md at ${path2}`);
+          context.addMessage("system", `Scanning codebase at ${cwd} ...`);
+          const scan = scanCodebase(cwd);
+          const title = target.filename === "MSAPLING.md" ? "MSapling Project Memory" : "Project Memory";
+          const content = renderMemoryFile(scan, title);
+          await writeFile13(target.path, content, "utf8");
+          const stackSummary = scan.stacks.length > 0 ? scan.stacks.map((s) => s.name).join(", ") : "unknown stack";
+          context.addMessage(
+            "system",
+            `${target.existed ? "Refreshed" : "Created"} ${target.filename} at ${target.path}
+  Stack: ${stackSummary}
+  Scanned: ${scan.dirCount} dirs, ${scan.fileCount} files${scan.truncated ? " (capped)" : ""}
+  Entry points: ${scan.entryPoints.length > 0 ? scan.entryPoints.join(", ") : "none detected"}`
+          );
         } catch (e) {
           context.addMessage("error", `Failed to initialize project: ${e.message}`);
         }
@@ -11298,7 +11895,7 @@ var init_init = __esm({
 });
 
 // src/commands/review.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile21 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
@@ -11318,7 +11915,7 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync24(target)) {
+          if (existsSync25(target)) {
             content = await readFile21(target, "utf8");
           } else {
             content = `Review target: ${target}`;
@@ -11412,15 +12009,15 @@ var init_swarm = __esm({
 
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { readFile as readFile22 } from "fs/promises";
-import { join as join28 } from "path";
+import { join as join29 } 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 = join28(cwd, dir, `${name}${suffix}${ext}`);
-        if (existsSync25(p)) return p;
+        const p = join29(cwd, dir, `${name}${suffix}${ext}`);
+        if (existsSync26(p)) return p;
       }
     }
   }
@@ -11533,13 +12130,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync26, readdirSync as readdirSync3, statSync as statSync7 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync4, statSync as statSync8 } from "fs";
 import { readFile as readFile23 } from "fs/promises";
-import { join as join29, resolve as resolve16 } from "path";
+import { join as join30, resolve as resolve16 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
     const full = resolve16(cwd, candidate);
-    if (existsSync26(full) && statSync7(full).isDirectory()) return full;
+    if (existsSync27(full) && statSync8(full).isDirectory()) return full;
   }
   return null;
 }
@@ -11547,28 +12144,28 @@ function listAllSkills(root) {
   const out = [];
   let domains;
   try {
-    domains = readdirSync3(root);
+    domains = readdirSync4(root);
   } catch {
     return out;
   }
   for (const domain of domains) {
-    const dir = join29(root, domain);
+    const dir = join30(root, domain);
     let s;
     try {
-      s = statSync7(dir);
+      s = statSync8(dir);
     } catch {
       continue;
     }
     if (!s.isDirectory()) continue;
     let files;
     try {
-      files = readdirSync3(dir);
+      files = readdirSync4(dir);
     } catch {
       continue;
     }
     for (const f of files) {
       if (!f.endsWith(".md")) continue;
-      out.push({ domain, name: f.slice(0, -3), path: join29(dir, f) });
+      out.push({ domain, name: f.slice(0, -3), path: join30(dir, f) });
     }
   }
   return out.sort(
@@ -11658,7 +12255,7 @@ ${prompt4}`;
 
 // src/commands/benchmark.ts
 import { homedir as homedir16 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { mkdirSync as mkdirSync5 } from "fs";
 import * as fs2 from "fs";
 function parseArgs(args2) {
@@ -11675,7 +12272,7 @@ function parseArgs(args2) {
 }
 function formatTable(results) {
   const header = `${"Model".padEnd(40)} ${"TTFT(ms)".padStart(9)} ${"TPS".padStart(7)} ${"Tokens".padStart(8)} ${"Cost($)".padStart(9)}`;
-  const sep4 = "-".repeat(header.length);
+  const sep5 = "-".repeat(header.length);
   const rows = results.map((r) => {
     const model = r.model.slice(0, 39).padEnd(40);
     const ttft = r.ttft_ms != null ? r.ttft_ms.toFixed(0).padStart(9) : "    -    ";
@@ -11685,7 +12282,7 @@ function formatTable(results) {
     const err = r.error ? `  \u26A0 ${r.error}` : "";
     return `${model} ${ttft} ${tps} ${tok} ${cost}${err}`;
   });
-  return [sep4, header, sep4, ...rows, sep4].join("\n");
+  return [sep5, header, sep5, ...rows, sep5].join("\n");
 }
 var DEFAULT_PROMPTS, benchmarkCommand;
 var init_benchmark = __esm({
@@ -11778,10 +12375,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 = join30(homedir16(), ".msapling", "benchmarks");
+          const dir = join31(homedir16(), ".msapling", "benchmarks");
           mkdirSync5(dir, { recursive: true });
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-          const file = join30(dir, `${ts}.json`);
+          const file = join31(dir, `${ts}.json`);
           const run = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             rounds,
@@ -12027,22 +12624,22 @@ var init_theme = __esm({
 });
 
 // src/commands/theme.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { homedir as homedir17 } from "os";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { readFile as readFile24, writeFile as writeFile14 } from "fs/promises";
 async function persistTheme(storage, themeName) {
-  const settingsPath = join31(homedir17(), ".msapling", "settings.json");
+  const settingsPath = join32(homedir17(), ".msapling", "settings.json");
   let existing = {};
   try {
-    if (existsSync27(settingsPath)) {
+    if (existsSync28(settingsPath)) {
       const text = await readFile24(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
   } catch {
   }
   existing["theme"] = themeName;
-  ensureConfigDir(join31(homedir17(), ".msapling"));
+  ensureConfigDir(join32(homedir17(), ".msapling"));
   await writeFile14(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
@@ -12114,7 +12711,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.47" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.49" : "(dev)";
         const coreVersion = true ? "2.3.6-beta.43" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -12123,7 +12720,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-20T08:11:43.445Z";
+          const ts = "2026-06-20T08:28:18.242Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -12136,14 +12733,14 @@ var init_version = __esm({
 });
 
 // src/commands/feedback.ts
-import { join as join32 } from "path";
-import { existsSync as existsSync28 } from "fs";
+import { join as join33 } from "path";
+import { existsSync as existsSync29 } from "fs";
 import { readFile as readFile25 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    const pkgPath = join32(baseDir, "..", "..", "package.json");
-    if (!existsSync28(pkgPath)) return "unknown";
+    const pkgPath = join33(baseDir, "..", "..", "package.json");
+    if (!existsSync29(pkgPath)) return "unknown";
     const text = await readFile25(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
@@ -12185,7 +12782,7 @@ var init_feedback = __esm({
 
 // src/commands/export.ts
 import { homedir as homedir18 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } 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);
@@ -12235,10 +12832,10 @@ var init_export = __esm({
         let outputPath;
         let content;
         if (arg === "" || arg === "json") {
-          outputPath = join33(homedir18(), `msapling-export-${timestamp}.json`);
+          outputPath = join34(homedir18(), `msapling-export-${timestamp}.json`);
           content = buildJsonExport(history);
         } else if (arg === "markdown" || arg === "md") {
-          outputPath = join33(homedir18(), `msapling-export-${timestamp}.md`);
+          outputPath = join34(homedir18(), `msapling-export-${timestamp}.md`);
           content = buildMarkdownExport(history);
         } else {
           outputPath = arg;
@@ -12250,7 +12847,7 @@ var init_export = __esm({
           }
         }
         try {
-          const dir = join33(outputPath, "..");
+          const dir = join34(outputPath, "..");
           await mkdir8(dir, { recursive: true });
           await writeFile15(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
@@ -12446,15 +13043,15 @@ var init_plan = __esm({
 
 // src/commands/note.ts
 import { homedir as homedir19 } from "os";
-import { join as join34 } from "path";
-import { existsSync as existsSync29 } from "fs";
+import { join as join35 } from "path";
+import { existsSync as existsSync30 } from "fs";
 import { readFile as readFile26, writeFile as writeFile16 } from "fs/promises";
 function getNotesFilePath() {
-  return join34(homedir19(), ".msapling", "notes.json");
+  return join35(homedir19(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
-    if (!existsSync29(filePath)) return [];
+    if (!existsSync30(filePath)) return [];
     const raw = await readFile26(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
@@ -12464,7 +13061,7 @@ async function readNotes(filePath = getNotesFilePath()) {
   }
 }
 async function writeNotes(notes, filePath = getNotesFilePath()) {
-  const dir = join34(homedir19(), ".msapling");
+  const dir = join35(homedir19(), ".msapling");
   ensureConfigDir(dir);
   await writeFile16(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
@@ -12611,16 +13208,16 @@ var init_todo = __esm({
 
 // src/commands/outputStyle.ts
 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";
+import { join as join36, basename as basename4, extname as extname3 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync6, readdirSync as readdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 function resolveHome() {
   return process.env.HOME || process.env.USERPROFILE || homedir20();
 }
 function stylesDir() {
-  return join35(resolveHome(), ".msapling", "output-styles");
+  return join36(resolveHome(), ".msapling", "output-styles");
 }
 function activeFile() {
-  return join35(stylesDir(), ".active");
+  return join36(stylesDir(), ".active");
 }
 function parseStyleFile(text) {
   const fm = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
@@ -12641,16 +13238,16 @@ function parseStyleFile(text) {
 }
 function listUserStyles() {
   const dir = stylesDir();
-  if (!existsSync30(dir)) return [];
+  if (!existsSync31(dir)) return [];
   const out = [];
-  for (const entry of readdirSync4(dir)) {
+  for (const entry of readdirSync5(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
-    const full = join35(dir, entry);
+    const full = join36(dir, entry);
     try {
-      const text = readFileSync4(full, "utf8");
+      const text = readFileSync5(full, "utf8");
       const { description, body } = parseStyleFile(text);
       out.push({
-        name: basename3(entry, ".md"),
+        name: basename4(entry, ".md"),
         description,
         body,
         source: "user",
@@ -12673,15 +13270,15 @@ function findStyle(name) {
 function getActiveStyleName() {
   try {
     const f = activeFile();
-    if (!existsSync30(f)) return "default";
-    return readFileSync4(f, "utf8").trim() || "default";
+    if (!existsSync31(f)) return "default";
+    return readFileSync5(f, "utf8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setActiveStyleName(name) {
   const dir = stylesDir();
-  if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
+  if (!existsSync31(dir)) mkdirSync6(dir, { recursive: true });
   writeFileSync5(activeFile(), `${name}
 `, "utf8");
 }
@@ -12694,8 +13291,8 @@ function createUserStyle(name, description, body) {
     throw new Error(`Invalid style name "${name}" \u2014 use letters, digits, _ and - only.`);
   }
   const dir = stylesDir();
-  if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
-  const target = join35(dir, `${name}.md`);
+  if (!existsSync31(dir)) mkdirSync6(dir, { recursive: true });
+  const target = join36(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
 ---
@@ -14112,6 +14709,32 @@ var init_agents = __esm({
   }
 });
 
+// src/commands/stats.ts
+var statsCommand;
+var init_stats = __esm({
+  "src/commands/stats.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src3();
+    statsCommand = {
+      name: "stats",
+      args: "[--json]",
+      description: "Show this session's tool, token, cost, and approval stats",
+      category: "debug",
+      handler: (args2, context) => {
+        const snap = getSessionStats().snapshot();
+        if (args2.includes("--json")) {
+          context.addMessage("system", JSON.stringify(snap, null, 2));
+          return;
+        }
+        for (const line of renderSessionStats(snap)) {
+          context.addMessage("system", line);
+        }
+      }
+    };
+  }
+});
+
 // src/commands/index.ts
 var commands_exports = {};
 __export(commands_exports, {
@@ -14186,6 +14809,7 @@ var init_commands = __esm({
     init_rewind();
     init_bashes();
     init_agents();
+    init_stats();
     commands = [
       loginCommand,
       logoutCommand,
@@ -14252,7 +14876,8 @@ var init_commands = __esm({
       remoteAgentCommand,
       rewindCommand,
       bashesCommand,
-      agentsCommand
+      agentsCommand,
+      statsCommand
     ];
   }
 });
@@ -14322,15 +14947,15 @@ var exec_exports = {};
 __export(exec_exports, {
   runExec: () => runExec
 });
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { readFile as readFile29 } from "fs/promises";
 import { homedir as homedir23 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
-    const p = join37(homedir23(), ".msapling", "settings.json");
-    if (!existsSync33(p)) return out;
+    const p = join38(homedir23(), ".msapling", "settings.json");
+    if (!existsSync34(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;
@@ -15189,8 +15814,8 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 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 { join as join39 } from "path";
+import { existsSync as existsSync35, statSync as statSync9 } from "fs";
 import { readdir as readdir3, mkdir as mkdir9, rm as rm3 } from "fs/promises";
 import { exec as exec2 } from "child_process";
 import { promisify } from "util";
@@ -15213,8 +15838,8 @@ async function checkNodeVersion() {
   };
 }
 async function checkConfigDir() {
-  const configDir = join38(homedir24(), ".msapling");
-  if (!existsSync34(configDir)) {
+  const configDir = join39(homedir24(), ".msapling");
+  if (!existsSync35(configDir)) {
     return {
       name: "Config directory",
       status: "WARN",
@@ -15222,7 +15847,7 @@ async function checkConfigDir() {
       remediation: `mkdir -p "${configDir}" && chmod 700 "${configDir}"`
     };
   }
-  const stats = statSync8(configDir);
+  const stats = statSync9(configDir);
   if (!stats.isDirectory()) {
     return {
       name: "Config directory",
@@ -15283,7 +15908,7 @@ async function checkPathConflicts() {
   const timedOutDirs = [];
   const DIR_TIMEOUT_MS = 1500;
   for (const dir of paths) {
-    if (!dir || !existsSync34(dir)) continue;
+    if (!dir || !existsSync35(dir)) continue;
     try {
       const files = await Promise.race([
         readdir3(dir),
@@ -15296,7 +15921,7 @@ async function checkPathConflicts() {
       ]);
       for (const file of files) {
         if (file === "msapling" || file === "msapling.exe" || file === "msapling.py") {
-          const fullPath = join38(dir, file);
+          const fullPath = join39(dir, file);
           conflicts.push(fullPath);
         }
       }
@@ -15414,9 +16039,9 @@ async function checkTokenValidity() {
 }
 async function checkOsSpecific() {
   if (platform4() === "win32") {
-    const testDir = join38(tmpdir(), `msapling-longpath-test-${Date.now()}`);
+    const testDir = join39(tmpdir(), `msapling-longpath-test-${Date.now()}`);
     const longDirName = "A".repeat(260);
-    const testPath = join38(testDir, longDirName);
+    const testPath = join39(testDir, longDirName);
     try {
       await mkdir9(testDir, { recursive: true });
       try {
@@ -17093,8 +17718,8 @@ var init_libesm = __esm({
 });
 
 // ../core/src/mcp/catalog.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync5, statSync as statSync9 } from "fs";
-import { join as join39, relative as relative16 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync6, statSync as statSync10 } from "fs";
+import { join as join40, relative as relative17 } 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"]);
@@ -17104,17 +17729,17 @@ function buildFileTree(root, maxFiles) {
     const dir = queue.shift();
     let entries;
     try {
-      entries = readdirSync5(dir);
+      entries = readdirSync6(dir);
     } catch {
       continue;
     }
     for (const name of entries) {
       if (out.length >= maxFiles) break;
       if (SKIP_DIRS2.has(name)) continue;
-      const full = join39(dir, name);
+      const full = join40(dir, name);
       let s;
       try {
-        s = statSync9(full);
+        s = statSync10(full);
       } catch {
         continue;
       }
@@ -17135,12 +17760,12 @@ function readFilesAsContext(root, files, maxKB) {
   for (const f of files) {
     let body;
     try {
-      body = readFileSync5(f, "utf8");
+      body = readFileSync6(f, "utf8");
     } catch {
       continue;
     }
     if (body.length > cap) body = body.slice(0, cap) + "\n[...truncated]";
-    const rel = relative16(root, f).replace(/\\/g, "/");
+    const rel = relative17(root, f).replace(/\\/g, "/");
     parts.push(`### ${rel}
 
 \`\`\`
@@ -17917,7 +18542,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.47"
+    "2.3.6-beta.49"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -18320,6 +18945,7 @@ function createIdleAwarePoll(pollingIntervalRef, lastActivityRef, client, setUse
 
 // src/state/commandHandler.ts
 init_esm_shims();
+init_src3();
 init_commands();
 init_plan();
 import { spawn as spawn10 } from "child_process";
@@ -18327,14 +18953,14 @@ import { spawn as spawn10 } from "child_process";
 // src/state/persistentState.ts
 init_esm_shims();
 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 { join as join37, dirname as dirname5 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync7 } from "fs";
 import { readFile as readFile27, writeFile as writeFile17, rename as rename3 } from "fs/promises";
 import { randomBytes as randomBytes15 } from "crypto";
-var STATE_PATH = join36(homedir22(), ".msapling", "state.json");
+var STATE_PATH = join37(homedir22(), ".msapling", "state.json");
 async function loadPersistentState(statePath = STATE_PATH) {
   try {
-    if (!existsSync31(statePath)) return { version: 1 };
+    if (!existsSync32(statePath)) return { version: 1 };
     const text = await readFile27(statePath, "utf8");
     const parsed = JSON.parse(text);
     if (parsed.version !== 1) return { version: 1 };
@@ -18350,7 +18976,7 @@ async function loadPersistentState(statePath = STATE_PATH) {
 async function savePersistentState(state, statePath = STATE_PATH) {
   try {
     const dir = dirname5(statePath);
-    if (!existsSync31(dir)) mkdirSync7(dir, { recursive: true });
+    if (!existsSync32(dir)) mkdirSync7(dir, { recursive: true });
     const existing = await loadPersistentState(statePath);
     const merged = {
       version: 1,
@@ -18419,6 +19045,11 @@ ${prompt4}` : prompt4;
               if (usage !== null) {
                 ctx.setLastCost(usage.cost_usd);
                 ctx.setSessionCost((prev) => prev + usage.cost_usd);
+                getSessionStats().recordUsage(
+                  usage.cost_usd,
+                  usage.prompt_tokens,
+                  usage.completion_tokens
+                );
               }
               ctx.setContextBudgetSnap(snapshotBudget(ctx.agent.getContextBudget()));
             } catch (e) {
@@ -18497,9 +19128,9 @@ ${prompt4}` : prompt4;
         for (const mention of fileMentions) {
           const filePath = mention.slice(1);
           try {
-            const { existsSync: existsSync35 } = await import("fs");
+            const { existsSync: existsSync36 } = await import("fs");
             const { readFile: readFile30 } = await import("fs/promises");
-            if (existsSync35(filePath)) {
+            if (existsSync36(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;
@@ -18525,6 +19156,7 @@ ${finalCmd}`;
       if (usage !== null) {
         ctx.setLastCost(usage.cost_usd);
         ctx.setSessionCost((prev) => prev + usage.cost_usd);
+        getSessionStats().recordUsage(usage.cost_usd, usage.prompt_tokens, usage.completion_tokens);
       }
       ctx.setContextBudgetSnap(snapshotBudget(ctx.agent.getContextBudget()));
     } catch (e) {
@@ -18561,7 +19193,7 @@ init_src3();
 init_src();
 init_parseApprovalMode();
 import { readFile as readFile28 } from "fs/promises";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 async function initSession(ctx) {
   try {
     const journalEncrypted = await initJournalEncryption();
@@ -18587,9 +19219,9 @@ async function initSession(ctx) {
     }
     try {
       const { homedir: homedir25 } = await import("os");
-      const { join: join41 } = await import("path");
-      const userSettingsPath = join41(homedir25(), ".msapling", "settings.json");
-      if (existsSync32(userSettingsPath)) {
+      const { join: join42 } = await import("path");
+      const userSettingsPath = join42(homedir25(), ".msapling", "settings.json");
+      if (existsSync33(userSettingsPath)) {
         const userText = await readFile28(userSettingsPath, "utf8");
         let parsed;
         try {
@@ -19006,14 +19638,14 @@ var App = ({ compact: compact2 = false, continueSession: continueSession2 = fals
 
 // src/runtime/bootstrap.ts
 init_esm_shims();
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join40 } from "path";
+import { dirname as dirname6, join as join41 } from "path";
 function readCliVersion2() {
   const here = dirname6(fileURLToPath2(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync6(join40(here, rel), "utf8"));
+      const pkg = JSON.parse(readFileSync7(join41(here, rel), "utf8"));
       if (pkg.name && pkg.version) {
         return { name: pkg.name, version: pkg.version };
       }