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

package/dist/index.js

@@ -1017,6 +1017,21 @@ var init_src = __esm({
         const data = overviewData;
         return this.mapUser(data, billingData);
       }
+      /**
+       * CLI-PARITY-P0-3: Web search via the backend proxy (POST /api/web/search).
+       *
+       * Provider API keys (Tavily/Serper) stay server-side; the CLI only ever sees
+       * normalised result rows. Mirrors the WebSearchTool surface so the agent can
+       * search the live web without local credentials. Backend fails open with an
+       * empty result set + provider "none" rather than 500 when no provider is
+       * available, so callers can degrade gracefully.
+       */
+      async webSearch(query, maxResults = 5) {
+        return await this.request("/api/web/search", {
+          method: "POST",
+          body: JSON.stringify({ query, max_results: maxResults })
+        });
+      }
       async getHistory(chatId) {
         const data = await this.request(`/api/projects/chat/${chatId}/history`);
         return data.messages.map((m) => ({
@@ -1268,6 +1283,30 @@ var init_src = __esm({
         const data = await this.request(`/api/projects/${encodeURIComponent(projectId)}/chats`);
         return Array.isArray(data) ? data : data.chats ?? [];
       }
+      // P0-4 (CLI-RESUME-01): list the user's recent chats across ALL projects for
+      // `/resume` + `msapling --continue`. The /api/projects/ tree keys projects by
+      // NAME and nests each project's `chats` array ({id, title, model, created_at,
+      // updated_at?}). We flatten the tree, stamp each chat with its project name,
+      // and sort by recency (updated_at, then created_at) so the most-recently
+      // touched chat is first. Backend doesn't expose a flat "recent chats" route,
+      // so this client-side flatten is the canonical path (mirrors chat.ts).
+      async listRecentChats(limit = 20) {
+        const data = await this.request("/api/projects/");
+        const flat = [];
+        for (const [projectName, bucket] of Object.entries(data.projects ?? {})) {
+          for (const chat of bucket?.chats ?? []) {
+            if (!chat?.id) continue;
+            flat.push({ ...chat, project: projectName });
+          }
+        }
+        const recencyKey = (c) => {
+          const raw = c.updated_at ?? c.created_at;
+          const t = raw ? Date.parse(raw) : NaN;
+          return Number.isNaN(t) ? 0 : t;
+        };
+        flat.sort((a, b) => recencyKey(b) - recencyKey(a));
+        return flat.slice(0, Math.max(1, limit));
+      }
       // CLI-CHAT-CREATE-01 (Iter 34): create a new chat in a project. Per LAB
       // projects.py:365 — POST /api/projects/chat/new with
       // {project_name, slot_label?, chat_name?, model?, client_type?}.
@@ -3400,11 +3439,20 @@ var init_DispatchAgentTool = __esm({
       client;
       parentChatId;
       projectRoot;
+      onSubagentStop;
       constructor(options) {
         super();
         this.client = options.client;
         this.parentChatId = options.parentChatId ?? void 0;
         this.projectRoot = options.projectRoot;
+        this.onSubagentStop = options.onSubagentStop;
+      }
+      /** Fire the subagent-stop callback defensively — it must never throw. */
+      signalStop(info) {
+        try {
+          this.onSubagentStop?.(info);
+        } catch {
+        }
       }
       async execute(args2, _projectRoot) {
         if (!args2?.prompt || typeof args2.prompt !== "string" || args2.prompt.trim() === "") {
@@ -3444,12 +3492,14 @@ var init_DispatchAgentTool = __esm({
         try {
           await Promise.race([streamPromise, timeoutPromise]);
         } catch (e) {
+          this.signalStop({ description, ok: false, chars: response.length, error: e?.message });
           return {
             content: `dispatch_agent error [${description}]: ${e.message}`,
             isError: true
           };
         }
         if (!response.trim()) {
+          this.signalStop({ description, ok: false, chars: 0, error: "empty response" });
           return {
             content: `dispatch_agent [${description}]: Sub-agent returned an empty response.`,
             isError: true
@@ -3461,6 +3511,7 @@ var init_DispatchAgentTool = __esm({
 
 ... [TRUNCATED: Sub-agent response exceeded ${MAX_RESPONSE_CHARS} characters]`;
         }
+        this.signalStop({ description, ok: true, chars: finalResponse.length });
         return {
           content: `[dispatch_agent: ${description}]
 
@@ -3776,6 +3827,83 @@ Content-Type: ${contentType}
   }
 });
 
+// ../core/src/tools/WebSearchTool.ts
+var DEFAULT_MAX_RESULTS, MAX_RESULTS_CEILING, MAX_SNIPPET_CHARS, WebSearchTool;
+var init_WebSearchTool = __esm({
+  "../core/src/tools/WebSearchTool.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_BaseTool();
+    DEFAULT_MAX_RESULTS = 5;
+    MAX_RESULTS_CEILING = 10;
+    MAX_SNIPPET_CHARS = 500;
+    WebSearchTool = class extends BaseTool {
+      name = "web_search";
+      description = "Search the live web for current information and return a ranked list of result titles, URLs, and snippets. Use this to find documentation, recent events, library versions, error explanations, or any topic where you need up-to-date sources you do not already have a URL for. Pair with web_fetch to read a specific result in full. Runs through the MSapling backend so no API keys are needed client-side.";
+      parameters = {
+        type: "object",
+        required: ["query"],
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query. Be specific for better results."
+          },
+          max_results: {
+            type: "number",
+            description: `Maximum number of results to return. Default: ${DEFAULT_MAX_RESULTS}. Max: ${MAX_RESULTS_CEILING}.`
+          }
+        }
+      };
+      client;
+      constructor(options) {
+        super();
+        this.client = options.client;
+      }
+      async execute(args2, _projectRoot) {
+        const rawQuery = args2?.query;
+        if (!rawQuery || typeof rawQuery !== "string" || rawQuery.trim() === "") {
+          return {
+            content: 'Error: web_search requires a non-empty "query" argument.',
+            isError: true
+          };
+        }
+        const query = rawQuery.trim();
+        let maxResults = DEFAULT_MAX_RESULTS;
+        if (typeof args2?.max_results === "number" && args2.max_results > 0) {
+          maxResults = Math.min(Math.floor(args2.max_results), MAX_RESULTS_CEILING);
+        }
+        let resp;
+        try {
+          resp = await this.client.webSearch(query, maxResults);
+        } catch (e) {
+          return {
+            content: `Error: web_search failed \u2014 ${e?.message ?? String(e)}`,
+            isError: true
+          };
+        }
+        const results = Array.isArray(resp?.results) ? resp.results : [];
+        if (results.length === 0) {
+          return {
+            content: `[web_search] No results for "${query}" (provider: ${resp?.provider ?? "none"}). Try rephrasing the query or use web_fetch if you already have a URL.`
+          };
+        }
+        const confidence = results[0]?.confidence ?? 0;
+        const confidenceLabel = confidence >= 0.9 ? "high" : "low (scraped)";
+        const header = `[web_search: ${results.length} result(s) for "${query}" \u2014 provider: ${resp.provider}, confidence: ${confidenceLabel}]
+
+`;
+        const body = results.map((r, i) => {
+          const snippet = (r.snippet || "").slice(0, MAX_SNIPPET_CHARS);
+          return `${i + 1}. ${r.title || "(untitled)"}
+   ${r.url || ""}
+   ${snippet}`;
+        }).join("\n\n");
+        return { content: header + body };
+      }
+    };
+  }
+});
+
 // ../core/src/tools/BashTool.ts
 import { resolve as resolve7, normalize as normalize6, relative as relative7, isAbsolute as isAbsolute7 } from "path";
 import { spawn as spawn5 } from "child_process";
@@ -4953,6 +5081,65 @@ Backup: ${backedUpTo}`;
   }
 });
 
+// ../core/src/tools/PlanModeTools.ts
+var MAX_PLAN_CHARS, EnterPlanModeTool, ExitPlanModeTool;
+var init_PlanModeTools = __esm({
+  "../core/src/tools/PlanModeTools.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_BaseTool();
+    MAX_PLAN_CHARS = 2e4;
+    EnterPlanModeTool = class extends BaseTool {
+      name = "enter_plan_mode";
+      description = "Switch into Plan Mode for a complex task that needs exploration before any changes. In Plan Mode you may ONLY use read-only tools (read_file, grep, glob, list_directory, web_fetch, web_search, etc.) \u2014 file writes and shell commands are blocked. Use this when the task is non-trivial and you should design an approach first. When your plan is ready, call exit_plan_mode to present it for the user's approval before executing.";
+      parameters = {
+        type: "object",
+        properties: {}
+      };
+      async execute(_args, _projectRoot) {
+        return {
+          content: "Entered Plan Mode. This is a READ-ONLY exploration and design phase.\n1. Thoroughly explore the codebase to understand existing patterns.\n2. Identify similar features and architectural approaches.\n3. Consider multiple approaches and their trade-offs.\n4. Design a concrete implementation strategy.\n5. When ready, call exit_plan_mode with your finished plan for approval.\nDo NOT write or edit files or run commands until the plan is approved."
+        };
+      }
+    };
+    ExitPlanModeTool = class _ExitPlanModeTool extends BaseTool {
+      name = "exit_plan_mode";
+      description = "Present your finished implementation plan to the user for approval and exit Plan Mode. Only call this once you have a concrete plan. The plan is shown to the user; if they approve, Plan Mode is lifted and you may begin making changes. If they reject, you remain in Plan Mode and should revise the plan based on their feedback. Pass the full plan as Markdown in `plan`.";
+      parameters = {
+        type: "object",
+        required: ["plan"],
+        properties: {
+          plan: {
+            type: "string",
+            description: "The full implementation plan, formatted as Markdown. Describe the steps you will take, the files you will change, and any trade-offs."
+          }
+        }
+      };
+      /** Validate the plan argument. Returns an error string or null when valid. */
+      static validatePlan(args2) {
+        const plan = args2?.plan;
+        if (!plan || typeof plan !== "string" || plan.trim() === "") {
+          return 'Error: exit_plan_mode requires a non-empty "plan" argument (the implementation plan to present for approval).';
+        }
+        if (plan.length > MAX_PLAN_CHARS) {
+          return `Error: plan is too long (${plan.length} chars; max ${MAX_PLAN_CHARS}). Summarize the plan.`;
+        }
+        return null;
+      }
+      async execute(args2, _projectRoot) {
+        const err = _ExitPlanModeTool.validatePlan(args2);
+        if (err) return { content: err, isError: true };
+        return {
+          content: `Plan recorded. (No interactive approval surface available \u2014 use /mode default or /mode acceptEdits to leave Plan Mode and begin execution.)
+
+## Plan
+${String(args2.plan)}`
+        };
+      }
+    };
+  }
+});
+
 // ../core/src/MDrive.ts
 import { createHash as createHash2 } from "crypto";
 var MDriveService;
@@ -5430,7 +5617,7 @@ async function runOne(entry, ctx) {
       if (settled) return;
       settled = true;
       clearTimeout(killer);
-      const blocked = !!entry.blocking && (exitCode === null || exitCode !== 0);
+      const blocked = !NON_BLOCKING_EVENTS.has(ctx.event) && !!entry.blocking && (exitCode === null || exitCode !== 0);
       resolve20({ command, exitCode, stdout, stderr, timedOut, blocked });
     };
     const killer = setTimeout(() => {
@@ -5467,11 +5654,20 @@ async function runOne(entry, ctx) {
     }
   });
 }
-var DEFAULT_TIMEOUT_MS3, MAX_OUTPUT_BYTES3, HookRunner;
+var NON_BLOCKING_EVENTS, DEFAULT_TIMEOUT_MS3, MAX_OUTPUT_BYTES3, HookRunner;
 var init_Hooks = __esm({
   "../core/src/Hooks.ts"() {
     "use strict";
     init_esm_shims();
+    NON_BLOCKING_EVENTS = /* @__PURE__ */ new Set([
+      "post-tool-use",
+      "session-start",
+      "session-end",
+      "stop",
+      "subagent-stop",
+      "pre-compact",
+      "notification"
+    ]);
     DEFAULT_TIMEOUT_MS3 = 5e3;
     MAX_OUTPUT_BYTES3 = 32e3;
     HookRunner = class {
@@ -5499,6 +5695,18 @@ var init_Hooks = __esm({
         }
         return outcomes;
       }
+      /**
+       * P1-7a: fire an observation-only lifecycle event without awaiting or
+       * blocking the caller. Errors are swallowed so a misbehaving hook can never
+       * break session start/stop/teardown. Returns immediately; the hook chain
+       * runs in the background. No-op if no hooks are registered for the event.
+       */
+      fireForget(ctx) {
+        const entries = this.hooks[ctx.event];
+        if (!entries || entries.length === 0) return;
+        void this.fire(ctx).catch(() => {
+        });
+      }
       /** Convenience: did any outcome block? */
       static anyBlocked(outcomes) {
         return outcomes.find((o) => o.blocked) ?? null;
@@ -5834,12 +6042,14 @@ var init_ToolExecutor = __esm({
     init_PatchFileTool();
     init_DispatchAgentTool();
     init_WebFetchTool();
+    init_WebSearchTool();
     init_BashTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
     init_MultiEditFileTool();
     init_MoveFileTool();
     init_DeleteFileTool();
+    init_PlanModeTools();
     init_MDrive();
     init_Sandbox();
     init_Voice();
@@ -5875,6 +6085,13 @@ var init_ToolExecutor = __esm({
       sessionTrust = /* @__PURE__ */ new Set();
       mcpRegistry = null;
       hooks = null;
+      /**
+       * CLI-PARITY-P0-2: Notifier fired whenever a tool flips the permission mode
+       * (enter_plan_mode / exit_plan_mode). Lets the CLI keep its React `mode`
+       * state + footer in sync with a model-driven mode change. Optional — when
+       * unset the mode still flips internally; only the UI display would lag.
+       */
+      onModeChange = null;
       constructor(client, projectRoot) {
         this.sandbox = new Sandbox(projectRoot);
         this.mdrive = new MDriveService(client);
@@ -5894,15 +6111,28 @@ var init_ToolExecutor = __esm({
         this.registerTool(new PatchFileTool());
         this.registerTool(new DispatchAgentTool({
           client,
-          projectRoot
+          projectRoot,
+          // P1-7a (CLI-HOOKS-LIFECYCLE-01): fire the subagent-stop lifecycle hook
+          // when a dispatched sub-agent finishes. Observation-only / non-blocking.
+          onSubagentStop: (info) => {
+            this.hooks?.fireForget({
+              event: "subagent-stop",
+              tool: info.description,
+              payload: info,
+              cwd: projectRoot
+            });
+          }
         }));
         this.registerTool(new WebFetchTool());
+        this.registerTool(new WebSearchTool({ client }));
         this.registerTool(new BashTool());
         this.registerTool(new NotebookReadTool());
         this.registerTool(new NotebookEditTool());
         this.registerTool(new MultiEditFileTool());
         this.registerTool(new MoveFileTool());
         this.registerTool(new DeleteFileTool());
+        this.registerTool(new EnterPlanModeTool());
+        this.registerTool(new ExitPlanModeTool());
       }
       setToolsEnabled(enabled) {
         this.toolsEnabled = enabled;
@@ -5913,6 +6143,24 @@ var init_ToolExecutor = __esm({
       getMode() {
         return this.mode;
       }
+      /**
+       * CLI-PARITY-P0-2: Register a callback invoked when a tool changes the
+       * permission mode (enter_plan_mode / exit_plan_mode), so the CLI can mirror
+       * the new mode into its React state. Does not affect the internal mode.
+       */
+      setOnModeChange(cb) {
+        this.onModeChange = cb;
+      }
+      /** Internal: flip the mode AND notify any registered listener. */
+      applyModeChange(mode) {
+        this.mode = mode;
+        if (this.onModeChange) {
+          try {
+            this.onModeChange(mode);
+          } catch {
+          }
+        }
+      }
       setApprovalCallback(cb) {
         this.approvalCallback = cb;
       }
@@ -5957,6 +6205,61 @@ var init_ToolExecutor = __esm({
       registerTool(tool) {
         this.tools.set(tool.name, tool);
       }
+      /**
+       * CLI-PARITY-P0-2: enter_plan_mode handler. Flips the executor into read-only
+       * `plan` mode (idempotent) and returns the research instructions. No approval:
+       * entering plan mode only tightens permissions.
+       */
+      async handleEnterPlanMode() {
+        if (this.mode !== "plan") {
+          this.applyModeChange("plan");
+        }
+        const tool = this.tools.get("enter_plan_mode");
+        return tool.execute({}, "");
+      }
+      /**
+       * CLI-PARITY-P0-2: exit_plan_mode handler. Validates the drafted plan,
+       * presents it through the existing approval UI (approvalCallback), and on
+       * approve flips `plan` → default/acceptEdits so execution can proceed. On deny
+       * the executor stays in plan mode and the model is told to revise.
+       */
+      async handleExitPlanMode(args2) {
+        const err = ExitPlanModeTool.validatePlan(args2);
+        if (err) return { content: err, isError: true };
+        if (this.mode !== "plan") {
+          return {
+            content: "You are not in Plan Mode, so there is nothing to exit. Continue with implementation."
+          };
+        }
+        const plan = String(args2.plan);
+        if (!this.approvalCallback) {
+          this.applyModeChange("default");
+          return {
+            content: `No interactive approval surface available \u2014 Plan Mode lifted (now in default mode). Proceed with the plan.
+
+## Approved Plan
+${plan}`
+          };
+        }
+        const decision = await this.approvalCallback({
+          tool: "exit_plan_mode",
+          command: plan,
+          reason: "The agent has finished planning and wants to start executing this plan. Approve to leave Plan Mode."
+        });
+        if (decision === "no") {
+          return {
+            content: "User rejected the plan. You remain in Plan Mode. Ask the user for specific feedback and revise the plan, then call exit_plan_mode again."
+          };
+        }
+        const targetMode = decision === "always" ? "acceptEdits" : "default";
+        this.applyModeChange(targetMode);
+        return {
+          content: `User approved the plan. Plan Mode lifted (now in ${targetMode} mode). You can now start executing. Begin with the first step.
+
+## Approved Plan
+${plan}`
+        };
+      }
       async execute(toolName, args2, projectRoot) {
         const tool = this.tools.get(toolName);
         if (!tool) {
@@ -5972,6 +6275,12 @@ var init_ToolExecutor = __esm({
           }
           return { content: `Error: unknown tool: ${toolName}`, isError: true };
         }
+        if (toolName === "enter_plan_mode") {
+          return this.handleEnterPlanMode();
+        }
+        if (toolName === "exit_plan_mode") {
+          return this.handleExitPlanMode(args2);
+        }
         if (this.mode === "plan") {
           if (APPROVAL_GATED.has(toolName)) {
             return {
@@ -6396,6 +6705,14 @@ var init_Agent = __esm({
       getMode() {
         return this.executor.getMode();
       }
+      /**
+       * CLI-PARITY-P0-2: Register a listener for model-driven mode changes
+       * (enter_plan_mode / exit_plan_mode) so the CLI can mirror the new mode into
+       * its own state + footer.
+       */
+      setOnModeChange(cb) {
+        this.executor.setOnModeChange(cb);
+      }
       setApprovalCallback(cb) {
         this.executor.setApprovalCallback(cb);
       }
@@ -6406,6 +6723,19 @@ var init_Agent = __esm({
         this.executor.setHookRunner(runner);
         this.hooks = runner;
       }
+      /** Expose the active HookRunner (e.g. for App-level session-start/end). */
+      getHookRunner() {
+        return this.hooks;
+      }
+      /**
+       * P1-7a: fire an observation-only lifecycle hook event without blocking.
+       * No-op when no HookRunner is wired. `name` is the descriptive string used
+       * for matcher evaluation (e.g. the subagent description); `payload` is the
+       * JSON event body delivered on the hook's stdin.
+       */
+      fireLifecycleHook(event, payload, name = "") {
+        this.hooks?.fireForget({ event, tool: name, payload, cwd: this.projectRoot });
+      }
       /**
        * CLI-PARITY-37: Wire a pre-loaded TrustStore so "always" approval decisions
        * are persisted across CLI restarts.  Must be called after `store.load()`.
@@ -6465,6 +6795,11 @@ var init_Agent = __esm({
               `
 [Agent: context budget reached \u2014 auto-compacting conversation (${this.contextBudget.summary()})]`
             );
+            this.fireLifecycleHook(
+              "pre-compact",
+              { chat_id: chatId, reason: "auto", budget: this.contextBudget.summary() },
+              "auto"
+            );
             rounds++;
             const compactionStream = this.client.streamChat({
               chat_id: chatId,
@@ -6547,6 +6882,7 @@ ${next}`;
         if (rounds >= MAX_WORKER_TURN_DEPTH) {
           throw new Error("runWorkerTurn exceeded MAX_DEPTH");
         }
+        this.fireLifecycleHook("stop", { chat_id: chatId, rounds }, "");
         return streamUsage;
       }
       async run(prompt4, model) {
@@ -8040,11 +8376,14 @@ __export(src_exports2, {
   DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
   DeleteFileTool: () => DeleteFileTool,
   DispatchAgentTool: () => DispatchAgentTool,
+  EnterPlanModeTool: () => EnterPlanModeTool,
+  ExitPlanModeTool: () => ExitPlanModeTool,
   GlobFilesTool: () => GlobFilesTool,
   GrepSearchTool: () => GrepSearchTool,
   HookRunner: () => HookRunner,
   KeychainUnavailableError: () => KeychainUnavailableError,
   ListDirectoryTool: () => ListDirectoryTool,
+  MAX_PLAN_CHARS: () => MAX_PLAN_CHARS,
   MCPClient: () => MCPClient,
   MCPClientError: () => MCPClientError,
   MCPRegistry: () => MCPRegistry,
@@ -8061,6 +8400,7 @@ __export(src_exports2, {
   ToolExecutor: () => ToolExecutor,
   TrustStore: () => TrustStore,
   WebFetchTool: () => WebFetchTool,
+  WebSearchTool: () => WebSearchTool,
   WriteFileTool: () => WriteFileTool,
   buildCompactionPrompt: () => buildCompactionPrompt,
   buildHwContext: () => buildHwContext,
@@ -8099,6 +8439,8 @@ var init_src3 = __esm({
     init_TodoTools();
     init_DispatchAgentTool();
     init_WebFetchTool();
+    init_WebSearchTool();
+    init_PlanModeTools();
     init_BashTool();
     init_NotebookReadTool();
     init_NotebookEditTool();
@@ -9037,6 +9379,104 @@ var init_chat = __esm({
   }
 });
 
+// src/commands/resume.ts
+var resume_exports = {};
+__export(resume_exports, {
+  rehydrateChat: () => rehydrateChat,
+  resolveRecentChat: () => resolveRecentChat,
+  resumeCommand: () => resumeCommand
+});
+function labelFor2(i) {
+  return i < 9 ? String(i + 1) : LETTERS2[i - 9] ?? `#${i + 1}`;
+}
+function resolveRecentChat(arg, chats) {
+  const trimmed = arg.trim();
+  if (!trimmed) return { kind: "error", message: "empty argument" };
+  const idHit = chats.find((c) => c.id === trimmed);
+  if (idHit) return { kind: "ok", chat: idHit };
+  if (/^\d+$/.test(trimmed)) {
+    const n = parseInt(trimmed, 10);
+    if (n >= 1 && n <= chats.length) return { kind: "ok", chat: chats[n - 1] };
+    return { kind: "error", message: `no chat at index ${n} (have ${chats.length})` };
+  }
+  if (/^[a-zA-Z]$/.test(trimmed)) {
+    const idx = 9 + LETTERS2.indexOf(trimmed.toLowerCase());
+    if (idx >= 9 && idx < chats.length) return { kind: "ok", chat: chats[idx] };
+  }
+  return {
+    kind: "error",
+    message: `no recent chat matches '${trimmed}'. Run /resume (no args) for the list.`
+  };
+}
+async function rehydrateChat(chat, context) {
+  context.clearHistory();
+  context.setActiveChatId(chat.id);
+  let messages = [];
+  try {
+    messages = await context.client.getHistory(chat.id);
+  } catch (e) {
+    context.addMessage("error", `Resumed ${chat.id} but failed to load history: ${e?.message ?? e}`);
+  }
+  const label = chat.title ?? chat.id;
+  const where = chat.project ? ` in '${chat.project}'` : "";
+  context.addMessage("system", `Resumed chat "${label}"${where} (${messages.length} message(s) replayed).`);
+  for (const m of messages) {
+    const role = m.role === "user" ? "user" : m.role === "assistant" ? "assistant" : "system";
+    context.addMessage(role, m.content);
+  }
+  try {
+    await context.refreshOverview();
+  } catch {
+  }
+  return messages.length;
+}
+async function listAndResume(args2, context) {
+  let chats;
+  try {
+    chats = await context.client.listRecentChats(35);
+  } catch (e) {
+    context.addMessage("error", `Failed to list recent chats: ${e?.message ?? e}`);
+    return;
+  }
+  if (chats.length === 0) {
+    context.addMessage("system", "No prior chats found. Send a message to start one.");
+    return;
+  }
+  const arg = args2.join(" ").trim();
+  if (!arg) {
+    context.addMessage("system", "Recent chats \u2014 /resume <number|letter|id> to reopen:");
+    chats.forEach((c, i) => {
+      const star = c.id === context.activeChatId ? " \u2605" : "";
+      const project = c.project ? ` (${c.project})` : "";
+      const model = c.model ? ` [${c.model}]` : "";
+      context.addMessage("system", `  ${labelFor2(i)}. ${c.title ?? c.id}${project}${model}${star}`);
+    });
+    return;
+  }
+  const resolved = resolveRecentChat(arg, chats);
+  if (resolved.kind === "error") {
+    context.addMessage("error", resolved.message);
+    return;
+  }
+  await rehydrateChat(resolved.chat, context);
+}
+var LETTERS2, resumeCommand;
+var init_resume = __esm({
+  "src/commands/resume.ts"() {
+    "use strict";
+    init_esm_shims();
+    LETTERS2 = "abcdefghijklmnopqrstuvwxyz";
+    resumeCommand = {
+      name: "resume",
+      aliases: ["continue"],
+      args: "[number|letter|id]",
+      description: "List recent chats and reopen one \u2014 replays its history into the REPL",
+      category: "chat",
+      handler: async (args2, context) => listAndResume(args2, context)
+    };
+  }
+});
+
 // src/commands/broadcast.ts
 var broadcastCommand;
 var init_broadcast = __esm({
@@ -9913,8 +10353,8 @@ var init_memory = __esm({
 });
 
 // src/commands/project.ts
-function labelFor2(i) {
-  return i < 9 ? String(i + 1) : LETTERS2[i - 9] ?? `#${i + 1}`;
+function labelFor3(i) {
+  return i < 9 ? String(i + 1) : LETTERS3[i - 9] ?? `#${i + 1}`;
 }
 function resolveProject(arg, list2) {
   const trimmed = arg.trim();
@@ -9927,7 +10367,7 @@ function resolveProject(arg, list2) {
     return { kind: "error", message: `no project at index ${n} (have ${list2.length})` };
   }
   if (/^[a-zA-Z]$/.test(trimmed)) {
-    const idx = 9 + LETTERS2.indexOf(trimmed.toLowerCase());
+    const idx = 9 + LETTERS3.indexOf(trimmed.toLowerCase());
     if (idx >= 9 && idx < list2.length) return { kind: "ok", id: list2[idx].id };
   }
   const lower = trimmed.toLowerCase();
@@ -9941,12 +10381,12 @@ function resolveProject(arg, list2) {
   }
   return { kind: "error", message: `no project matches '${trimmed}'. Run /project (no args) for the list.` };
 }
-var LETTERS2, projectCommand;
+var LETTERS3, projectCommand;
 var init_project = __esm({
   "src/commands/project.ts"() {
     "use strict";
     init_esm_shims();
-    LETTERS2 = "abcdefghijklmnopqrstuvwxyz";
+    LETTERS3 = "abcdefghijklmnopqrstuvwxyz";
     projectCommand = {
       name: "project",
       args: "[number|letter|name|id|config]",
@@ -10005,7 +10445,7 @@ var init_project = __esm({
           }
           context.addMessage("system", "Available Projects:");
           projects.forEach((p, i) => {
-            const label = labelFor2(i);
+            const label = labelFor3(i);
             const star = p.id === currentId ? " \u2605" : "";
             const usage = p.chat_count != null && p.chat_limit != null ? `  (${p.chat_count}/${p.chat_limit} chats)` : "";
             context.addMessage("system", `  ${label}. ${p.name ?? p.id}${usage}${star}`);
@@ -10616,7 +11056,7 @@ var init_hooks = __esm({
     init_src3();
     hooksCommand = {
       name: "hooks",
-      description: "List configured lifecycle hooks (pre-tool-use, post-tool-use, user-prompt-submit)",
+      description: "List configured lifecycle hooks (pre/post-tool-use, user-prompt-submit, session-start/end, stop, subagent-stop, pre-compact, notification)",
       category: "debug",
       handler: async (args2, context) => {
         const sub = args2[0]?.toLowerCase();
@@ -10920,7 +11360,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.44" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.46" : "(dev)";
         const coreVersion = true ? "2.3.6-beta.43" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -10929,7 +11369,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:08:23.320Z";
+          const ts = "2026-06-20T07:22:28.613Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -12689,6 +13129,7 @@ var init_commands = __esm({
     init_exit();
     init_help();
     init_chat();
+    init_resume();
     init_broadcast();
     init_ollama();
     init_keys();
@@ -12752,6 +13193,7 @@ var init_commands = __esm({
       helpCommand,
       chatCommand,
       chatsCommand,
+      resumeCommand,
       broadcastCommand,
       ollamaCommand,
       keysCommand,
@@ -16462,7 +16904,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.44"
+    "2.3.6-beta.46"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -17263,7 +17705,7 @@ function useTerminalResize() {
 
 // src/App.tsx
 import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
-var App = ({ compact: compact2 = false }) => {
+var App = ({ compact: compact2 = false, continueSession: continueSession2 = false }) => {
   const [user, setUser] = useState4(null);
   const [input, setInput] = useState4("");
   const [history, setHistory] = useState4([]);
@@ -17285,18 +17727,32 @@ var App = ({ compact: compact2 = false }) => {
   const { columns: termResizeCols, rows: termResizeRows } = useTerminalResize();
   const storage = useRef(new StorageManager()).current;
   const client = useRef(new MSaplingClient()).current;
+  const agentRef = useRef(null);
   const requestApproval = useCallback2((request) => {
+    agentRef.current?.fireLifecycleHook(
+      "notification",
+      { kind: "approval-request", tool: request.tool, command: request.command, reason: request.reason },
+      request.tool
+    );
     return new Promise((resolve20) => {
       setPendingApproval({ request, resolve: resolve20 });
     });
   }, []);
   const agent = useRef(new Agent(client, process.cwd(), requestApproval)).current;
+  agentRef.current = agent;
   const trustStore = useRef(new TrustStore()).current;
   const lastActivityRef = useRef(Date.now());
   const pollingIntervalRef = useRef(null);
   useEffect4(() => {
     agent.setApprovalCallback(requestApproval);
   }, [agent, requestApproval]);
+  useEffect4(() => {
+    agent.setOnModeChange((m) => {
+      setModeState(m);
+      addMessage("system", `Mode changed to: ${m} (via plan-mode tool)`);
+    });
+    return () => agent.setOnModeChange(null);
+  }, [agent]);
   const resolveApproval = useCallback2((decision) => {
     setPendingApproval((current) => {
       current?.resolve(decision);
@@ -17358,21 +17814,53 @@ var App = ({ compact: compact2 = false }) => {
     }
   }, [client, activeChatId, activeProjectId, setProjectId, handle401]);
   useEffect4(() => {
-    initSession({
-      agent,
-      client,
-      storage,
-      trustStore,
-      setActiveModel,
-      setMode,
-      setStatus,
-      addMessage,
-      refreshOverview,
-      setShellEscapeEnabled,
-      // CLI-PORT-STATE-04: restore persisted project/chat on cold start.
-      setProjectId,
-      setActiveChatId
-    });
+    (async () => {
+      await initSession({
+        agent,
+        client,
+        storage,
+        trustStore,
+        setActiveModel,
+        setMode,
+        setStatus,
+        addMessage,
+        refreshOverview,
+        setShellEscapeEnabled,
+        // CLI-PORT-STATE-04: restore persisted project/chat on cold start.
+        setProjectId,
+        setActiveChatId
+      });
+      if (continueSession2) {
+        try {
+          const { rehydrateChat: rehydrateChat2 } = await Promise.resolve().then(() => (init_resume(), resume_exports));
+          const recent = await client.listRecentChats(1);
+          if (recent.length > 0) {
+            await rehydrateChat2(recent[0], {
+              client,
+              setActiveChatId,
+              clearHistory,
+              addMessage,
+              refreshOverview
+            });
+          } else {
+            addMessage("system", "--continue: no prior chats to resume.");
+          }
+        } catch (e) {
+          addMessage("system", `--continue: could not resume most-recent chat: ${e?.message ?? e}`);
+        }
+      }
+      agent.fireLifecycleHook("session-start", {
+        cwd: process.cwd(),
+        compact: compact2,
+        continued: continueSession2,
+        chat_id: activeChatId
+      });
+    })();
+  }, []);
+  useEffect4(() => {
+    return () => {
+      agent.fireLifecycleHook("session-end", { cwd: process.cwd() });
+    };
   }, []);
   useEffect4(() => {
     if (!user) return;
@@ -17531,6 +18019,7 @@ function handleCliArgs(args2) {
     console.log("msapling \u2014 MSapling CLI (React/Ink)");
     console.log("Usage: msapling                  start interactive REPL");
     console.log("       msapling --compact        start REPL in compact mode (no footer, thin separators)");
+    console.log("       msapling --continue       resume your most-recent chat (alias: -c); replays its history");
     console.log('       msapling --exec "<cmd>"   run one slash command non-interactively and exit');
     console.log("       msapling mcp serve        run as MCP stdio server (Claude Code / Cursor / Windsurf integration)");
     console.log("       msapling doctor           run diagnostic health checks");
@@ -17645,9 +18134,10 @@ if (!process.env.NODE_ENV?.includes("test")) {
 }
 var args = process.argv.slice(2);
 var compact = args.includes("--compact");
+var continueSession = args.includes("--continue") || args.includes("-c");
 var shouldRenderRepl = handleCliArgs(args);
 if (shouldRenderRepl && !process.env.NODE_ENV?.includes("test")) {
-  render(/* @__PURE__ */ jsx9(App, { compact }));
+  render(/* @__PURE__ */ jsx9(App, { compact, continueSession }));
 }
 export {
   App,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtreeai/msapling-cli",
-  "version": "2.3.6-beta.44",
+  "version": "2.3.6-beta.46",
   "description": "MSapling CLI — React/Ink terminal client for the MSapling backend (chat, projects, MDrive, agent tools). Proprietary; redistribution prohibited.",
   "license": "UNLICENSED",
   "author": "MSapling Team",
@@ -51,7 +51,9 @@
   },
   "dependencies": {
     "ink": "^4.4.1",
+    "proper-lockfile": "^4.1.2",
     "react": "^18.3.1",
+    "shell-quote": "^1.8.1",
     "yaml": "^2.8.3"
   },
   "optionalDependencies": {