@bike4mind/cli 0.2.31-feat-dynamic-agent-creation.19590 → 0.2.31-feat-python-playground.19625

package/dist/index.js

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 import "./chunk-GQGOWACU.js";
-import "./chunk-4P27WV34.js";
-import "./chunk-S6AUIWWB.js";
+import "./chunk-ZHXVJFCI.js";
+import "./chunk-RTD3GUAP.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-DQHCE3TN.js";
+} from "./chunk-LAZAO77H.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-ZS65NK25.js";
+} from "./chunk-32PKF3N7.js";
 import {
   checkForUpdate,
   package_default
-} from "./chunk-HNT6CPNA.js";
+} from "./chunk-S3S2FV2N.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -32,7 +32,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-PV6PZFPC.js";
+} from "./chunk-2PXPXXDN.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -90,7 +90,7 @@ import {
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-PLA2VBQW.js";
+} from "./chunk-EEGKRFVP.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
@@ -733,8 +733,25 @@ var COMMANDS = [
   },
   {
     name: "rewind",
-    description: "Rewind conversation to a previous point",
-    aliases: ["undo"]
+    description: "Rewind conversation to a previous point"
+  },
+  {
+    name: "undo",
+    description: "Undo the last file change"
+  },
+  {
+    name: "checkpoints",
+    description: "List available file restore points"
+  },
+  {
+    name: "restore",
+    description: "Restore files to a specific checkpoint",
+    args: "<number>"
+  },
+  {
+    name: "diff",
+    description: "Show diff between current state and a checkpoint",
+    args: "[number]"
   },
   {
     name: "project-config",
@@ -1647,19 +1664,6 @@ function buildConfigItems(availableModels) {
           exportFormat: value
         }
       })
-    },
-    {
-      key: "enableDynamicAgentCreation",
-      label: "Dynamic Agents",
-      type: "boolean",
-      getValue: (config) => config.preferences.enableDynamicAgentCreation ?? false,
-      setValue: (config, value) => ({
-        ...config,
-        preferences: {
-          ...config.preferences,
-          enableDynamicAgentCreation: value
-        }
-      })
     }
   );
   return items;
@@ -2851,9 +2855,346 @@ var CommandHistoryStore = class {
   }
 };
 
-// src/storage/CustomCommandStore.ts
-import fs5 from "fs/promises";
+// src/storage/CheckpointStore.ts
+import { promises as fs5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, unlinkSync } from "fs";
+import { execFileSync } from "child_process";
 import path6 from "path";
+var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+var DEFAULT_KEEP_COUNT = 50;
+var ABSENT_MARKER = ".b4m-absent";
+var CheckpointStore = class {
+  constructor(projectDir) {
+    this.metadata = null;
+    this.sessionId = null;
+    this.initialized = false;
+    this.projectDir = projectDir;
+    this.shadowRepoDir = path6.join(projectDir, ".b4m", "shadow-repo");
+    this.metadataPath = path6.join(projectDir, ".b4m", "checkpoints.json");
+  }
+  /**
+   * Initialize the shadow git repository and load metadata
+   */
+  async init(sessionId) {
+    this.sessionId = sessionId;
+    await fs5.mkdir(path6.join(this.projectDir, ".b4m"), { recursive: true });
+    if (!existsSync4(path6.join(this.shadowRepoDir, ".git"))) {
+      await fs5.mkdir(this.shadowRepoDir, { recursive: true });
+      this.git("init");
+      this.git("config", "user.email", "checkpoint@b4m.local");
+      this.git("config", "user.name", "B4M Checkpoint");
+      this.git("commit", "--allow-empty", "-m", "checkpoint-init");
+    }
+    await this.loadMetadata();
+    await this.ensureGitignore();
+    await this.pruneCheckpoints(DEFAULT_KEEP_COUNT);
+    this.initialized = true;
+  }
+  /**
+   * Update session ID (e.g., on /clear or /resume)
+   */
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  /**
+   * Create a checkpoint by snapshotting the current state of target files
+   * before they are modified by a tool.
+   *
+   * @param toolName - The tool about to modify files
+   * @param filePaths - Relative paths of files about to be modified
+   * @param name - Optional human-readable checkpoint name
+   */
+  async createCheckpoint(toolName, filePaths, name) {
+    if (!this.initialized || !this.sessionId) {
+      return null;
+    }
+    const checkpointName = name || `before-${toolName}-${path6.basename(filePaths[0] || "unknown")}`;
+    try {
+      let hasChanges = false;
+      for (const filePath of filePaths) {
+        const absolutePath = this.validatePathWithinProject(filePath);
+        const shadowPath = path6.join(this.shadowRepoDir, filePath);
+        const shadowDir = path6.dirname(shadowPath);
+        const absentMarkerPath = path6.join(shadowDir, `${path6.basename(filePath)}${ABSENT_MARKER}`);
+        await fs5.mkdir(shadowDir, { recursive: true });
+        if (existsSync4(absolutePath)) {
+          const stats = await fs5.lstat(absolutePath);
+          if (stats.isSymbolicLink()) {
+            continue;
+          }
+          if (stats.size > MAX_FILE_SIZE2) {
+            continue;
+          }
+          if (existsSync4(absentMarkerPath)) {
+            await fs5.unlink(absentMarkerPath);
+          }
+          await fs5.copyFile(absolutePath, shadowPath);
+          hasChanges = true;
+        } else {
+          if (existsSync4(shadowPath)) {
+            await fs5.unlink(shadowPath);
+          }
+          await fs5.writeFile(absentMarkerPath, "", "utf-8");
+          hasChanges = true;
+        }
+      }
+      if (!hasChanges) {
+        return null;
+      }
+      this.git("add", "-A");
+      try {
+        this.git("diff", "--cached", "--quiet");
+        return null;
+      } catch {
+      }
+      this.git("commit", "-m", checkpointName);
+      const sha = this.git("rev-parse", "--short", "HEAD").trim();
+      const checkpoint = {
+        id: sha,
+        name: checkpointName,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        toolName,
+        filePaths: [...filePaths],
+        sessionId: this.sessionId
+      };
+      if (!this.metadata) {
+        this.metadata = { checkpoints: [], createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      this.metadata.checkpoints.push(checkpoint);
+      await this.saveMetadata();
+      return checkpoint;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * List checkpoints for the current session (most recent first)
+   */
+  listCheckpoints() {
+    if (!this.metadata || !this.sessionId) {
+      return [];
+    }
+    return this.metadata.checkpoints.filter((cp) => cp.sessionId === this.sessionId).reverse();
+  }
+  /**
+   * Get a specific checkpoint by 1-based index (1 = most recent)
+   */
+  getCheckpoint(index) {
+    const checkpoints = this.listCheckpoints();
+    if (index < 1 || index > checkpoints.length) {
+      return null;
+    }
+    return checkpoints[index - 1];
+  }
+  /**
+   * Restore files to the state captured in a specific checkpoint
+   *
+   * @param index - 1-based index (1 = most recent)
+   * @returns The checkpoint that was restored to
+   */
+  async restoreCheckpoint(index) {
+    const checkpoint = this.getCheckpoint(index);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint #${index} not found. Use /checkpoints to see available restore points.`);
+    }
+    for (const filePath of checkpoint.filePaths) {
+      const absolutePath = this.validatePathWithinProject(filePath);
+      try {
+        const content = this.git("show", `${checkpoint.id}:${filePath}`);
+        await fs5.mkdir(path6.dirname(absolutePath), { recursive: true });
+        await fs5.writeFile(absolutePath, content, "utf-8");
+      } catch {
+        try {
+          this.git("show", `${checkpoint.id}:${path6.dirname(filePath)}/${path6.basename(filePath)}${ABSENT_MARKER}`);
+          if (existsSync4(absolutePath)) {
+            await fs5.unlink(absolutePath);
+          }
+        } catch {
+        }
+      }
+    }
+    return checkpoint;
+  }
+  /**
+   * Undo the last file change (restore to most recent checkpoint)
+   */
+  async undoLast() {
+    return this.restoreCheckpoint(1);
+  }
+  /**
+   * Get diff between current file state and a checkpoint
+   *
+   * @param index - 1-based index (1 = most recent, default)
+   * @returns Unified diff string
+   */
+  getCheckpointDiff(index = 1) {
+    const checkpoint = this.getCheckpoint(index);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint #${index} not found. Use /checkpoints to see available restore points.`);
+    }
+    const diffParts = [];
+    for (const filePath of checkpoint.filePaths) {
+      const absolutePath = this.validatePathWithinProject(filePath);
+      const tmpCheckpoint = path6.join(this.shadowRepoDir, ".diff-a");
+      const tmpCurrent = path6.join(this.shadowRepoDir, ".diff-b");
+      try {
+        let checkpointContent;
+        try {
+          checkpointContent = this.git("show", `${checkpoint.id}:${filePath}`);
+        } catch {
+          checkpointContent = "";
+        }
+        let currentContent = "";
+        if (existsSync4(absolutePath)) {
+          currentContent = readFileSync4(absolutePath, "utf-8");
+        }
+        if (checkpointContent === currentContent) {
+          continue;
+        }
+        writeFileSync(tmpCheckpoint, checkpointContent, "utf-8");
+        writeFileSync(tmpCurrent, currentContent, "utf-8");
+        try {
+          this.git(
+            "diff",
+            "--no-index",
+            "--color",
+            `--src-prefix=checkpoint:`,
+            `--dst-prefix=current:`,
+            tmpCheckpoint,
+            tmpCurrent
+          );
+        } catch (diffError) {
+          if (diffError && typeof diffError === "object" && "stdout" in diffError) {
+            const output = diffError.stdout?.toString() || "";
+            if (output) {
+              diffParts.push(`--- ${filePath} (checkpoint #${index})
++++ ${filePath} (current)
+${output}`);
+            }
+          }
+        }
+      } catch {
+      } finally {
+        try {
+          unlinkSync(tmpCheckpoint);
+        } catch {
+        }
+        try {
+          unlinkSync(tmpCurrent);
+        } catch {
+        }
+      }
+    }
+    return diffParts.join("\n");
+  }
+  /**
+   * Prune old checkpoints beyond the keep count
+   */
+  async pruneCheckpoints(keepCount = DEFAULT_KEEP_COUNT) {
+    if (!this.metadata) return;
+    const total = this.metadata.checkpoints.length;
+    if (total <= keepCount) return;
+    this.metadata.checkpoints = this.metadata.checkpoints.slice(-keepCount);
+    await this.saveMetadata();
+    try {
+      this.git("gc", "--auto", "--quiet");
+    } catch {
+    }
+  }
+  /**
+   * Clean up the shadow repository entirely
+   */
+  async cleanup() {
+    try {
+      await fs5.rm(this.shadowRepoDir, { recursive: true, force: true });
+      if (existsSync4(this.metadataPath)) {
+        await fs5.unlink(this.metadataPath);
+      }
+      this.metadata = null;
+      this.initialized = false;
+    } catch {
+    }
+  }
+  // --- Private helpers ---
+  /**
+   * Validate that a file path resolves within the project directory.
+   * Prevents path traversal attacks (e.g., ../../etc/passwd).
+   */
+  validatePathWithinProject(filePath) {
+    const absolutePath = path6.resolve(this.projectDir, filePath);
+    const normalizedProject = path6.resolve(this.projectDir) + path6.sep;
+    if (!absolutePath.startsWith(normalizedProject) && absolutePath !== path6.resolve(this.projectDir)) {
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    return absolutePath;
+  }
+  /**
+   * Execute a git command in the shadow repo
+   */
+  git(...args) {
+    return execFileSync("git", args, {
+      cwd: this.shadowRepoDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+  }
+  /**
+   * Load checkpoint metadata from disk
+   */
+  async loadMetadata() {
+    try {
+      if (existsSync4(this.metadataPath)) {
+        const data = await fs5.readFile(this.metadataPath, "utf-8");
+        this.metadata = JSON.parse(data);
+      } else {
+        this.metadata = {
+          checkpoints: [],
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    } catch {
+      this.metadata = {
+        checkpoints: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  /**
+   * Save checkpoint metadata to disk
+   */
+  async saveMetadata() {
+    if (!this.metadata) return;
+    await fs5.writeFile(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
+  }
+  /**
+   * Ensure .b4m/ is in .gitignore
+   */
+  async ensureGitignore() {
+    const gitignorePath = path6.join(this.projectDir, ".gitignore");
+    const entryToAdd = ".b4m/";
+    try {
+      let content = "";
+      try {
+        content = await fs5.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (content.includes(entryToAdd) || content.includes(".b4m")) {
+        return;
+      }
+      const newContent = content.trim() + (content ? "\n" : "") + `
+# B4M checkpoint data
+${entryToAdd}
+`;
+      await fs5.writeFile(gitignorePath, newContent, "utf-8");
+    } catch {
+    }
+  }
+};
+
+// src/storage/CustomCommandStore.ts
+import fs6 from "fs/promises";
+import path7 from "path";
 import os from "os";
 
 // src/utils/commandParser.ts
@@ -3017,14 +3358,14 @@ var CustomCommandStore = class {
     const home = os.homedir();
     const root = projectRoot || process.cwd();
     this.globalCommandsDirs = [
-      path6.join(home, ".bike4mind", "commands"),
-      path6.join(home, ".claude", "commands"),
-      path6.join(home, ".claude", "skills")
+      path7.join(home, ".bike4mind", "commands"),
+      path7.join(home, ".claude", "commands"),
+      path7.join(home, ".claude", "skills")
     ];
     this.projectCommandsDirs = [
-      path6.join(root, ".bike4mind", "commands"),
-      path6.join(root, ".claude", "commands"),
-      path6.join(root, ".claude", "skills")
+      path7.join(root, ".bike4mind", "commands"),
+      path7.join(root, ".claude", "commands"),
+      path7.join(root, ".claude", "skills")
     ];
   }
   /**
@@ -3049,7 +3390,7 @@ var CustomCommandStore = class {
    */
   async loadCommandsFromDirectory(directory, source) {
     try {
-      const stats = await fs5.stat(directory);
+      const stats = await fs6.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -3082,9 +3423,9 @@ var CustomCommandStore = class {
   async findCommandFiles(directory) {
     const files = [];
     try {
-      const entries = await fs5.readdir(directory, { withFileTypes: true });
+      const entries = await fs6.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path6.join(directory, entry.name);
+        const fullPath = path7.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findCommandFiles(fullPath);
           files.push(...subFiles);
@@ -3104,14 +3445,14 @@ var CustomCommandStore = class {
    * @param source - Source identifier ('global' or 'project')
    */
   async loadCommandFile(filePath, source) {
-    const filename = path6.basename(filePath);
+    const filename = path7.basename(filePath);
     const isSkillFile = filename.toLowerCase() === "skill.md";
     const commandName = isSkillFile ? this.extractSkillName(filePath) : extractCommandName(filename);
     if (!commandName) {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
-    const fileContent = await fs5.readFile(filePath, "utf-8");
+    const fileContent = await fs6.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
     this.commands.set(commandName, command);
   }
@@ -3123,7 +3464,7 @@ var CustomCommandStore = class {
    * @returns Skill name or null if invalid
    */
   extractSkillName(filePath) {
-    const parentDir = path6.basename(path6.dirname(filePath));
+    const parentDir = path7.basename(path7.dirname(filePath));
     return parentDir && parentDir !== "skills" ? parentDir : null;
   }
   /**
@@ -3185,15 +3526,15 @@ var CustomCommandStore = class {
    */
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
-    const filePath = path6.join(targetDir, `${name}.md`);
-    const fileExists = await fs5.access(filePath).then(
+    const filePath = path7.join(targetDir, `${name}.md`);
+    const fileExists = await fs6.access(filePath).then(
       () => true,
       () => false
     );
     if (fileExists) {
       throw new Error(`Command file already exists: ${filePath}`);
     }
-    await fs5.mkdir(targetDir, { recursive: true });
+    await fs6.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} command
 argument-hint: [args]
@@ -3208,7 +3549,7 @@ You can use:
 - $1, $2, etc. for positional arguments
 - @filename for file references
 `;
-    await fs5.writeFile(filePath, template, "utf-8");
+    await fs6.writeFile(filePath, template, "utf-8");
     return filePath;
   }
 };
@@ -3868,13 +4209,11 @@ var TOOL_CREATE_FILE = "create_file";
 var TOOL_BASH_EXECUTE = "bash_execute";
 var TOOL_SUBAGENT_DELEGATE = "subagent_delegate";
 var TOOL_WRITE_TODOS = "write_todos";
-var TOOL_CREATE_DYNAMIC_AGENT = "create_dynamic_agent";
 var EXPLORE_SUBAGENT_TYPE = "explore";
 function buildCoreSystemPrompt(contextSection, config) {
   let projectContextSection = "";
   let agentDirectoryContext = "";
   let skillsSection = "";
-  let dynamicAgentSection = "";
   if (typeof contextSection === "string") {
     projectContextSection = contextSection;
     if (config) {
@@ -3884,9 +4223,6 @@ function buildCoreSystemPrompt(contextSection, config) {
       if (config.agentStore) {
         agentDirectoryContext = config.agentStore.getDirectoryContext();
       }
-      if (config.enableDynamicAgentCreation) {
-        dynamicAgentSection = buildDynamicAgentPromptSection();
-      }
     }
   } else if (contextSection && typeof contextSection === "object") {
     config = contextSection;
@@ -3905,9 +4241,6 @@ ${config.contextContent}`;
     if (config.agentStore) {
       agentDirectoryContext = config.agentStore.getDirectoryContext();
     }
-    if (config.enableDynamicAgentCreation) {
-      dynamicAgentSection = buildDynamicAgentPromptSection();
-    }
   }
   return `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
 
@@ -3940,7 +4273,6 @@ SUBAGENT DELEGATION:
 - You have access to specialized subagents via the ${TOOL_SUBAGENT_DELEGATE} tool
 - ${agentDirectoryContext ? `${agentDirectoryContext}` : ""}
 - Subagents keep the main conversation clean and run faster with optimized models
-${dynamicAgentSection}
 
 CODE SEARCH BEST PRACTICES:
 When searching code, follow this hierarchy for speed and efficiency:
@@ -3999,52 +4331,6 @@ EXAMPLES:
 
 Remember: Use context from previous messages to understand follow-up questions.${projectContextSection}${skillsSection}`;
 }
-function buildDynamicAgentPromptSection() {
-  return `
-DYNAMIC AGENT CREATION:
-You have access to the '${TOOL_CREATE_DYNAMIC_AGENT}' tool, which lets you create and spawn one-off agents at runtime with custom system prompts.
-
-**When to use '${TOOL_CREATE_DYNAMIC_AGENT}' instead of '${TOOL_SUBAGENT_DELEGATE}':**
-- When no pre-defined agent fits the task \u2014 you need custom instructions or a specialized role
-- When you want to give a sub-task a tailored system prompt (e.g., "You are a security auditor...")
-- When you need fine-grained control over which tools the spawned agent can access
-
-**How to use it:**
-1. Provide a descriptive 'name' (e.g., "security-auditor", "migration-checker")
-2. Write a focused 'systemPrompt' that defines the agent's role and constraints
-3. Specify the 'task' \u2014 what the agent should accomplish
-4. Optionally restrict tools with 'allowedTools' or 'deniedTools'
-5. Use 'run_in_background: true' for long-running or parallel work
-
-**Constraints:** Dynamic agents cannot spawn other agents (no recursion). They are ephemeral and not saved.
-
-**Examples (simple \u2192 complex):**
-
-1. **Security Auditor** \u2014 Review a file for vulnerabilities:
-   name: "security-auditor"
-   systemPrompt: "You are a security auditor. Review code for common vulnerabilities: injection attacks, hardcoded secrets, unsafe user input handling, and OWASP Top 10 issues. Report findings with severity (critical/high/medium/low), the affected line or pattern, and a recommended fix."
-   task: "Audit src/auth/login.ts for security vulnerabilities"
-   allowedTools: ["file_read", "grep_search"]
-
-2. **Test Gap Analyzer** \u2014 Find untested modules:
-   name: "test-gap-analyzer"
-   systemPrompt: "You are a test coverage analyst. Compare source files against test files to identify modules that lack tests. For each gap, note the source file, its key exports/functions, and why it should be tested. Prioritize files with complex logic or external integrations."
-   task: "Analyze apps/cli/src/agents/ and identify source files without corresponding test coverage"
-   thoroughness: "very_thorough"
-
-3. **Refactoring Planner** \u2014 Analyze and propose refactoring:
-   name: "refactor-planner"
-   systemPrompt: "You are a senior software architect specializing in code quality. Analyze the target module for code smells: long functions (>50 lines), deep nesting (>3 levels), god objects, duplicated logic, unclear naming, and tight coupling. Propose a concrete refactoring strategy with specific steps, expected benefits, and risk assessment for each change."
-   task: "Analyze src/core/prompts.ts and propose a refactoring plan"
-   thoroughness: "very_thorough"
-
-4. **PR Description Writer** \u2014 Generate PR descriptions from diffs:
-   name: "pr-writer"
-   systemPrompt: "You are a technical writer who creates clear, structured pull request descriptions. Given a git diff or list of changes, produce: a concise summary (1-3 sentences), a bulleted list of specific changes grouped by category, and a testing checklist. Use imperative mood. Focus on the 'why' not just the 'what'."
-   task: "Generate a PR description for the current branch changes"
-   allowedTools: ["bash_execute", "file_read"]
-   thoroughness: "quick"`;
-}
 
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
@@ -4495,7 +4781,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs6, { unlinkSync } from "fs";
+import fs7, { unlinkSync as unlinkSync2 } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -6186,8 +6472,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path19;
+    const path21 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path21;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -7513,8 +7799,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path19;
+  const path21 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path21;
 }
 async function generateFullMask(imageBuffer) {
   const sharp = (await import("sharp")).default;
@@ -9455,33 +9741,33 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs7 } from "fs";
-import { existsSync as existsSync4, statSync as statSync4 } from "fs";
-import path7 from "path";
-var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+import { promises as fs8 } from "fs";
+import { existsSync as existsSync5, statSync as statSync4 } from "fs";
+import path8 from "path";
+var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", offset = 0, limit } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path8.normalize(filePath);
+  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
+  const cwd = path8.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync4(resolvedPath)) {
+  if (!existsSync5(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   const stats = statSync4(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
-  if (stats.size > MAX_FILE_SIZE2) {
-    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE2 / 1024 / 1024}MB)`);
+  if (stats.size > MAX_FILE_SIZE3) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE3 / 1024 / 1024}MB)`);
   }
   const isBinary = await checkIfBinary(resolvedPath);
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs7.readFile(resolvedPath, encoding);
+  const content = await fs8.readFile(resolvedPath, encoding);
   if (typeof content === "string") {
     const lines = content.split("\n");
     const totalLines = lines.length;
@@ -9519,7 +9805,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs7.open(filePath, "r");
+  const fd = await fs8.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -9536,7 +9822,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
+        const stats = statSync4(path8.resolve(process.cwd(), path8.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -9580,25 +9866,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs8 } from "fs";
-import { existsSync as existsSync5 } from "fs";
-import path8 from "path";
+import { promises as fs9 } from "fs";
+import { existsSync as existsSync6 } from "fs";
+import path9 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path8.normalize(filePath);
-  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
-  const cwd = path8.resolve(process.cwd());
+  const normalizedPath = path9.normalize(filePath);
+  const resolvedPath = path9.resolve(process.cwd(), normalizedPath);
+  const cwd = path9.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync5(resolvedPath);
+  const fileExists = existsSync6(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path8.dirname(resolvedPath);
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path9.dirname(resolvedPath);
+    await fs9.mkdir(dir, { recursive: true });
   }
-  await fs8.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs8.stat(resolvedPath);
+  await fs9.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs9.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -9609,7 +9895,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync5(path8.resolve(process.cwd(), path8.normalize(params.path)));
+      const fileExists = existsSync6(path9.resolve(process.cwd(), path9.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -9651,7 +9937,7 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { glob } from "glob";
 import { stat } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 var DEFAULT_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
@@ -9667,7 +9953,7 @@ var DEFAULT_IGNORE_PATTERNS = [
 async function findFiles(params) {
   const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
+  const targetDir = dir_path ? path10.resolve(baseCwd, path10.normalize(dir_path)) : baseCwd;
   if (!targetDir.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search outside of current working directory`);
   }
@@ -9707,7 +9993,7 @@ async function findFiles(params) {
   const summary = `Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`;
   const dirInfo = dir_path ? `
 Directory: ${dir_path}` : "";
-  const filesList = results.map((file) => path9.relative(baseCwd, file.path)).join("\n");
+  const filesList = results.map((file) => path10.relative(baseCwd, file.path)).join("\n");
   return `${summary}${dirInfo}
 
 ${filesList}`;
@@ -9761,27 +10047,48 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { stat as stat2 } from "fs/promises";
-import path10 from "path";
-import { execFile } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import path11 from "path";
+import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { promisify } from "util";
 import { createRequire } from "module";
 var execFileAsync = promisify(execFile);
 var require2 = createRequire(import.meta.url);
+var cachedRgPath = null;
 function getRipgrepPath() {
+  if (cachedRgPath)
+    return cachedRgPath;
   try {
     const ripgrepPath = require2.resolve("@vscode/ripgrep");
-    const ripgrepDir = path10.dirname(ripgrepPath);
-    const rgBinary = path10.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path11.dirname(ripgrepPath);
+    const rgBinary = path11.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    if (!existsSync7(rgBinary)) {
+      const postinstallScript = path11.join(ripgrepDir, "..", "lib", "postinstall.js");
+      if (existsSync7(postinstallScript)) {
+        execFileSync2(process.execPath, [postinstallScript], {
+          cwd: path11.join(ripgrepDir, ".."),
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      if (!existsSync7(rgBinary)) {
+        throw new Error(`ripgrep binary not found at ${rgBinary}. The postinstall download may have failed. Try running: cd ${path11.join(ripgrepDir, "..")} && node lib/postinstall.js`);
+      }
+    }
+    cachedRgPath = rgBinary;
     return rgBinary;
   } catch (error) {
+    if (error instanceof Error && error.message.includes("ripgrep binary not found")) {
+      throw error;
+    }
     throw new Error("ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services");
   }
 }
 function isPathWithinWorkspace(targetPath, baseCwd) {
-  const resolvedTarget = path10.resolve(targetPath);
-  const resolvedBase = path10.resolve(baseCwd);
-  const relativePath = path10.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+  const resolvedTarget = path11.resolve(targetPath);
+  const resolvedBase = path11.resolve(baseCwd);
+  const relativePath = path11.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
 }
 function convertGlobToRipgrepGlobs(globPattern) {
   if (!globPattern || globPattern === "**/*") {
@@ -9797,7 +10104,7 @@ function convertGlobToRipgrepGlobs(globPattern) {
 async function searchFiles2(params) {
   const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
+  const targetDir = dir_path ? path11.resolve(baseCwd, dir_path) : baseCwd;
   if (!isPathWithinWorkspace(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
   }
@@ -9859,7 +10166,7 @@ async function searchFiles2(params) {
       if (item.type === "match") {
         const match = item;
         allMatches.push({
-          filePath: path10.relative(targetDir, match.data.path.text) || path10.basename(match.data.path.text),
+          filePath: path11.relative(targetDir, match.data.path.text) || path11.basename(match.data.path.text),
           lineNumber: match.data.line_number,
           line: match.data.lines.text.trimEnd()
           // Remove trailing newline
@@ -9952,18 +10259,18 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs9 } from "fs";
-import { existsSync as existsSync6, statSync as statSync5 } from "fs";
-import path11 from "path";
+import { promises as fs10 } from "fs";
+import { existsSync as existsSync8, statSync as statSync5 } from "fs";
+import path12 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path11.normalize(filePath);
-  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
-  const cwd = path11.resolve(process.cwd());
+  const normalizedPath = path12.normalize(filePath);
+  const resolvedPath = path12.resolve(process.cwd(), normalizedPath);
+  const cwd = path12.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync6(resolvedPath)) {
+  if (!existsSync8(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
   const stats = statSync5(resolvedPath);
@@ -9973,10 +10280,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs9.rm(resolvedPath, { recursive: true, force: true });
+    await fs10.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs9.unlink(resolvedPath);
+    await fs10.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -9986,8 +10293,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
-      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
+      const resolvedPath = path12.resolve(process.cwd(), path12.normalize(params.path));
+      const isDirectory = existsSync8(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -11564,6 +11871,7 @@ var solverMetadata = {
     requires: "Backend compute",
     available: false,
     tagline: "Quantum-inspired classical simulation",
+    externalUrl: "https://q.bike4mind.com/jobs/e499f34a-d40e-4cfb-98e5-47e0a2091f3d",
     fullDescription: "A classical simulator of the Quantum Approximate Optimization Algorithm (QAOA). Encodes the job-shop scheduling problem as a QUBO (Quadratic Unconstrained Binary Optimization), then simulates the quantum variational circuit classically. Provides a preview of quantum advantage without requiring real quantum hardware.",
     howItWorks: [
       "Encode scheduling problem as QUBO matrix",
@@ -11609,6 +11917,7 @@ var solverMetadata = {
     requires: "IonQ API key + credits",
     available: false,
     tagline: "Real quantum hardware optimization",
+    externalUrl: "https://cloud.ionq.com/jobs/019c07ff-205a-76d0-9f83-24098ea09589",
     fullDescription: "Runs the Quantum Approximate Optimization Algorithm on IonQ\u2019s trapped-ion quantum computers. This is real quantum computation \u2014 the problem is encoded as a QUBO, compiled to native quantum gates, and executed on physical qubits. Results include genuine quantum effects like superposition and entanglement.",
     howItWorks: [
       "Encode scheduling problem as QUBO matrix",
@@ -12666,7 +12975,7 @@ var navigateViewTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path12 from "path";
+import path13 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -12850,7 +13159,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path13.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -13853,9 +14162,9 @@ function parseQuery(query) {
 }
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs10 } from "fs";
-import { existsSync as existsSync7 } from "fs";
-import path13 from "path";
+import { promises as fs11 } from "fs";
+import { existsSync as existsSync9 } from "fs";
+import path14 from "path";
 import { diffLines as diffLines3 } from "diff";
 function generateDiff(original, modified) {
   const differences = diffLines3(original, modified);
@@ -13879,16 +14188,16 @@ function generateDiff(original, modified) {
 }
 async function editLocalFile(params) {
   const { path: filePath, old_string, new_string } = params;
-  const normalizedPath = path13.normalize(filePath);
-  const resolvedPath = path13.resolve(process.cwd(), normalizedPath);
-  const cwd = path13.resolve(process.cwd());
+  const normalizedPath = path14.normalize(filePath);
+  const resolvedPath = path14.resolve(process.cwd(), normalizedPath);
+  const cwd = path14.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot edit files outside of current working directory`);
   }
-  if (!existsSync7(resolvedPath)) {
+  if (!existsSync9(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
+  const currentContent = await fs11.readFile(resolvedPath, "utf-8");
   if (!currentContent.includes(old_string)) {
     const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
     throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
@@ -13898,7 +14207,7 @@ async function editLocalFile(params) {
     throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
   }
   const newContent = currentContent.replace(old_string, new_string);
-  await fs10.writeFile(resolvedPath, newContent, "utf-8");
+  await fs11.writeFile(resolvedPath, newContent, "utf-8");
   const diffResult = generateDiff(old_string, new_string);
   return `File edited successfully: ${filePath}
 Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
@@ -14547,12 +14856,27 @@ var GithubManagerAgent = (config) => ({
   exclusiveMcpServers: ["github"],
   systemPrompt: `You are a GitHub specialist with access to GitHub's API. Your job is to help manage repositories, issues, pull requests, code search, branches, and CI/CD workflows.
 
-## First Step: Resolve Repository Context
-ALWAYS start by calling the \`github__current_user\` tool. The response includes:
+## First Step: ALWAYS Resolve Repository Context Automatically
+Before doing ANYTHING else, call the \`github__current_user\` tool. The response includes:
 - **selected_repositories**: The list of repositories the user has enabled for AI access (in \`owner/repo\` format)
 - **user**: The authenticated user's profile (login, name, etc.)
 
-Use this to resolve the owner and repo name when the user does not specify them. If only one repository is selected, default to that repository. If multiple are selected and the user's request is ambiguous, mention the available repositories and ask for clarification via your response.
+### Repository Resolution Rules (CRITICAL)
+You MUST use the selected_repositories list to automatically resolve the owner and repo. NEVER ask the user for the org, owner, or full repository path. Instead:
+
+1. **Exact match**: If the user says a repo name that exactly matches a repo name in selected_repositories, use it immediately.
+2. **Partial/fuzzy match**: If the user provides a partial name, match it against any repo in selected_repositories whose name contains that term (e.g., if the user says "lumina" and selected_repositories contains \`SomeOrg/lumina5\`, use that).
+3. **Single repo shortcut**: If only one repository is selected, ALWAYS default to it \u2014 no questions asked.
+4. **Multiple matches**: Only if multiple selected repos match the user's term AND you truly cannot disambiguate, list the matching repos and ask which one. Do NOT list repos that don't match.
+5. **No match**: If nothing in selected_repositories matches, tell the user which repos are available and ask them to clarify.
+
+**NEVER ask the user to "paste the GitHub URL" or provide the org/owner name.** You already have this information from \`github__current_user\`. The owner and repo are embedded in the \`owner/repo\` format of each selected repository entry.
+
+### Defaults for Ambiguous Requests
+- **Timezone**: Default to UTC unless the user specifies otherwise.
+- **PR/Issue state**: Default to \`open\` unless the user specifies otherwise.
+- **Scope**: All matching repos unless the user narrows it down.
+- **When in doubt, act**: Prefer making reasonable assumptions and proceeding over asking clarifying questions. You can always note your assumptions in the response.
 
 ## Capabilities
 
@@ -14593,7 +14917,7 @@ Use this to resolve the owner and repo name when the user does not specify them.
 ## Output Format
 Provide a clear summary of actions taken:
 1. What was done (created, searched, merged, etc.)
-2. Links to relevant items (e.g., owner/repo#123, PR URLs)
+2. Always provide links to relevant items (e.g., owner/repo#123, PR URLs)
 3. Any issues or warnings encountered
 
 Be precise with repository names, issue numbers, and PR numbers. Your results will be used by the main agent.`
@@ -15288,10 +15612,10 @@ var ToolErrorType;
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync10(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -15329,10 +15653,10 @@ ${diffLines4.join("\n")}`;
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync10(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
+    const stats = await import("fs/promises").then((fs15) => fs15.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -15631,25 +15955,26 @@ var DEFAULT_AGENT_MODEL = "claude-3-5-haiku-20241022";
 var DEFAULT_THOROUGHNESS = "medium";
 
 // src/utils/toolsAdapter.ts
+import path15 from "path";
 var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path19) {
+  async download(path21) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path19) {
+  async delete(path21) {
   }
-  async getSignedUrl(path19) {
-    return `/tmp/${path19}`;
+  async getSignedUrl(path21) {
+    return `/tmp/${path21}`;
   }
-  getPublicUrl(path19) {
-    return `/tmp/${path19}`;
+  getPublicUrl(path21) {
+    return `/tmp/${path21}`;
   }
-  async getPreview(path19) {
-    return `/tmp/${path19}`;
+  async getPreview(path21) {
+    return `/tmp/${path21}`;
   }
-  async getMetadata(path19) {
+  async getMetadata(path21) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -15822,6 +16147,27 @@ function wrapToolWithHooks(tool, hooks, hookContext) {
     }
   };
 }
+var CHECKPOINT_TOOLS = /* @__PURE__ */ new Set(["create_file", "edit_local_file", "delete_file"]);
+function wrapToolWithCheckpointing(tool, checkpointStore) {
+  if (!checkpointStore || !CHECKPOINT_TOOLS.has(tool.toolSchema.name)) {
+    return tool;
+  }
+  const originalFn = tool.toolFn;
+  const toolName = tool.toolSchema.name;
+  return {
+    ...tool,
+    toolFn: async (args) => {
+      const filePath = args?.path;
+      if (filePath) {
+        try {
+          await checkpointStore.createCheckpoint(toolName, [filePath], `before-${toolName}-${path15.basename(filePath)}`);
+        } catch {
+        }
+      }
+      return originalFn(args);
+    }
+  };
+}
 var TOOL_NAME_MAPPING = {
   // Claude Code -> B4M
   read: "file_read",
@@ -15846,7 +16192,7 @@ function normalizeToolName(toolName) {
   }
   return TOOL_NAME_MAPPING[toolName] || toolName;
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter) {
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter, checkpointStore) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -15905,9 +16251,17 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     // imageProcessorLambdaName (not needed for CLI)
     tools_to_generate
   );
-  let tools = Object.entries(toolsMap).map(
-    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
-  );
+  let tools = Object.entries(toolsMap).map(([_, tool]) => {
+    const permissionWrapped = wrapToolWithPermission(
+      tool,
+      permissionManager,
+      showPermissionPrompt,
+      agentContext,
+      configStore,
+      apiClient
+    );
+    return wrapToolWithCheckpointing(permissionWrapped, checkpointStore ?? null);
+  });
   if (toolFilter) {
     const { allowedTools, deniedTools } = toolFilter;
     const normalizedAllowed = allowedTools?.map(normalizeToolName);
@@ -16085,8 +16439,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs11 from "fs";
-import * as path14 from "path";
+import * as fs12 from "fs";
+import * as path16 from "path";
 import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -16107,9 +16461,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path14.join(dir, filename);
+  const filePath = path16.join(dir, filename);
   try {
-    const stats = fs11.lstatSync(filePath);
+    const stats = fs12.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -16123,7 +16477,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs11.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -16175,7 +16529,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path14.join(homedir3(), ".bike4mind");
+  const globalDir = path16.join(homedir3(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -16446,8 +16800,8 @@ function substituteArguments(template, args) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path15 from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import path17 from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -16488,18 +16842,18 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path17.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync9(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync11(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -17429,6 +17783,7 @@ var WebSocketLlmBackend = class {
         settled = true;
         this.wsManager.offRequest(requestId);
         this.wsManager.offDisconnect(onDisconnect);
+        options.abortSignal?.removeEventListener("abort", abortHandler);
         action();
       };
       const settleResolve = () => settle(() => resolve3());
@@ -17438,19 +17793,16 @@ var WebSocketLlmBackend = class {
         settleReject(new Error("WebSocket connection lost during completion"));
       };
       this.wsManager.onDisconnect(onDisconnect);
+      const abortHandler = () => {
+        logger.debug("[WebSocketLlmBackend] Abort signal received");
+        settleResolve();
+      };
       if (options.abortSignal) {
         if (options.abortSignal.aborted) {
           settleResolve();
           return;
         }
-        options.abortSignal.addEventListener(
-          "abort",
-          () => {
-            logger.debug("[WebSocketLlmBackend] Abort signal received");
-            settleResolve();
-          },
-          { once: true }
-        );
+        options.abortSignal.addEventListener("abort", abortHandler, { once: true });
       }
       const updateUsage = (usage) => {
         if (usage) {
@@ -17788,27 +18140,35 @@ var WebSocketToolExecutor = class {
     const requestId = uuidv412();
     return new Promise((resolve3, reject) => {
       let settled = false;
+      let timeoutTimer;
       const settle = (action) => {
         if (settled) return;
         settled = true;
+        clearTimeout(timeoutTimer);
         this.wsManager.offRequest(requestId);
         this.wsManager.offDisconnect(onDisconnect);
+        abortSignal?.removeEventListener("abort", abortHandler);
         action();
       };
       const settleResolve = (result) => settle(() => resolve3(result));
       const settleReject = (err) => settle(() => reject(err));
+      const TOOL_TIMEOUT_MS = 5 * 60 * 1e3;
+      timeoutTimer = setTimeout(() => {
+        settleReject(new Error(`Tool execution timed out after ${TOOL_TIMEOUT_MS / 1e3}s`));
+      }, TOOL_TIMEOUT_MS);
       const onDisconnect = () => {
         settleReject(new Error("WebSocket connection lost during tool execution"));
       };
       this.wsManager.onDisconnect(onDisconnect);
+      const abortHandler = () => {
+        settleReject(new Error("Tool execution aborted"));
+      };
       if (abortSignal) {
         if (abortSignal.aborted) {
           settleReject(new Error("Tool execution aborted"));
           return;
         }
-        abortSignal.addEventListener("abort", () => settleReject(new Error("Tool execution aborted")), {
-          once: true
-        });
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
       }
       this.wsManager.onRequest(requestId, (message) => {
         if (message.action === "cli_tool_response") {
@@ -18226,16 +18586,10 @@ var SubagentOrchestrator = class {
    */
   async delegateToAgent(options) {
     const { task, agentName, thoroughness, variables, parentSessionId, model, allowedTools } = options;
-    let agentDef;
-    if (options.agentDefinition) {
-      agentDef = { ...options.agentDefinition, name: agentName, source: "dynamic", filePath: "<dynamic>" };
-    } else {
-      const storedDef = this.deps.agentStore.getAgent(agentName);
-      if (!storedDef) {
-        const available = this.deps.agentStore.getAgentNames().join(", ");
-        throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
-      }
-      agentDef = storedDef;
+    const agentDef = this.deps.agentStore.getAgent(agentName);
+    if (!agentDef) {
+      const available = this.deps.agentStore.getAgentNames().join(", ");
+      throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
     }
     const effectiveModel = model || agentDef.model;
     const effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
@@ -18262,7 +18616,10 @@ var SubagentOrchestrator = class {
       this.deps.showPermissionPrompt,
       agentContext,
       this.deps.configStore,
-      this.deps.apiClient
+      this.deps.apiClient,
+      void 0,
+      // toolFilter (applied separately below)
+      this.deps.checkpointStore
     );
     const filteredTools = filterToolsByPatterns2(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
     if (this.deps.customCommandStore) {
@@ -18415,8 +18772,8 @@ var SubagentOrchestrator = class {
 };
 
 // src/agents/AgentStore.ts
-import fs12 from "fs/promises";
-import path16 from "path";
+import fs13 from "fs/promises";
+import path18 from "path";
 import os2 from "os";
 import matter2 from "gray-matter";
 var FULL_MODEL_ID_PREFIXES = [
@@ -18566,10 +18923,10 @@ var AgentStore = class {
     const root = projectRoot || process.cwd();
     const home = os2.homedir();
     this.builtinAgentsDir = builtinDir;
-    this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
-    this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
-    this.projectB4MAgentsDir = path16.join(root, ".bike4mind", "agents");
-    this.projectClaudeAgentsDir = path16.join(root, ".claude", "agents");
+    this.globalB4MAgentsDir = path18.join(home, ".bike4mind", "agents");
+    this.globalClaudeAgentsDir = path18.join(home, ".claude", "agents");
+    this.projectB4MAgentsDir = path18.join(root, ".bike4mind", "agents");
+    this.projectClaudeAgentsDir = path18.join(root, ".claude", "agents");
   }
   /**
    * Load all agents from all directories
@@ -18593,7 +18950,7 @@ var AgentStore = class {
    */
   async loadAgentsFromDirectory(directory, source) {
     try {
-      const stats = await fs12.stat(directory);
+      const stats = await fs13.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -18621,9 +18978,9 @@ var AgentStore = class {
   async findAgentFiles(directory) {
     const files = [];
     try {
-      const entries = await fs12.readdir(directory, { withFileTypes: true });
+      const entries = await fs13.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path16.join(directory, entry.name);
+        const fullPath = path18.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findAgentFiles(fullPath);
           files.push(...subFiles);
@@ -18640,10 +18997,10 @@ var AgentStore = class {
    * Parse a single agent markdown file
    */
   async parseAgentFile(filePath, source) {
-    const content = await fs12.readFile(filePath, "utf-8");
+    const content = await fs13.readFile(filePath, "utf-8");
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
-    const name = path16.basename(filePath, ".md");
+    const name = path18.basename(filePath, ".md");
     const modelInput = parsed.model || DEFAULT_AGENT_MODEL;
     const resolution = resolveModelAlias(modelInput, name, filePath);
     if (!resolution.resolved && resolution.warning) {
@@ -18723,16 +19080,16 @@ var AgentStore = class {
    */
   async createAgentFile(name, isGlobal = false, useClaude = true) {
     const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
-    const filePath = path16.join(targetDir, `${name}.md`);
+    const filePath = path18.join(targetDir, `${name}.md`);
     try {
-      await fs12.access(filePath);
+      await fs13.access(filePath);
       throw new Error(`Agent file already exists: ${filePath}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
     }
-    await fs12.mkdir(targetDir, { recursive: true });
+    await fs13.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} agent description
 model: claude-3-5-haiku-20241022
@@ -18767,7 +19124,7 @@ You are a ${name} specialist. Your job is to [describe primary task].
 ## Output Format
 Describe the expected output format here.
 `;
-    await fs12.writeFile(filePath, template, "utf-8");
+    await fs13.writeFile(filePath, template, "utf-8");
     return filePath;
   }
   /**
@@ -18900,136 +19257,6 @@ ${agentDescriptions}
   };
 }
 
-// src/agents/dynamicAgentTool.ts
-function createDynamicAgentTool(orchestrator, parentSessionId, backgroundManager) {
-  return {
-    toolFn: async (args) => {
-      const params = args;
-      if (!params.task) {
-        throw new Error("create_dynamic_agent: task parameter is required");
-      }
-      if (!params.name) {
-        throw new Error("create_dynamic_agent: name parameter is required");
-      }
-      if (!/^[a-zA-Z0-9_-]+$/.test(params.name)) {
-        throw new Error(
-          "create_dynamic_agent: name must contain only alphanumeric characters, hyphens, and underscores"
-        );
-      }
-      if (!params.systemPrompt) {
-        throw new Error("create_dynamic_agent: systemPrompt parameter is required");
-      }
-      const deniedTools = [...params.deniedTools || [], ...ALWAYS_DENIED_FOR_AGENTS, "create_dynamic_agent"];
-      const agentDefinition = {
-        description: params.description || `Dynamic agent: ${params.name}`,
-        model: params.model || DEFAULT_AGENT_MODEL,
-        systemPrompt: params.systemPrompt,
-        allowedTools: params.allowedTools,
-        deniedTools,
-        maxIterations: { ...DEFAULT_MAX_ITERATIONS },
-        defaultThoroughness: DEFAULT_THOROUGHNESS,
-        defaultVariables: params.variables
-      };
-      const spawnOptions = {
-        task: params.task,
-        agentName: params.name,
-        thoroughness: params.thoroughness,
-        variables: params.variables,
-        parentSessionId,
-        model: params.model,
-        allowedTools: params.allowedTools,
-        agentDefinition
-      };
-      if (params.run_in_background && backgroundManager) {
-        const jobId = backgroundManager.spawn({
-          ...spawnOptions,
-          groupDescription: params.group_description
-        });
-        return `Dynamic background agent "${params.name}" started. Job ID: ${jobId}. Use check_agent_status tool with this job ID to retrieve results when ready.`;
-      }
-      const result = await orchestrator.delegateToAgent(spawnOptions);
-      return result.summary;
-    },
-    toolSchema: {
-      name: "create_dynamic_agent",
-      description: `Create and spawn a one-off agent at runtime with a custom system prompt.
-
-Unlike agent_delegate (which uses pre-defined agents), this tool lets you compose a new agent on the fly with custom instructions, model, and tool restrictions.
-
-**When to use this tool:**
-- When no existing agent fits the task at hand
-- When you need a specialized agent with custom instructions for a one-off task
-- When you need fine-grained control over what tools the agent can access
-
-**Constraints:**
-- Dynamic agents CANNOT call agent_delegate or create_dynamic_agent (no recursive spawning)
-- Dynamic agents are ephemeral \u2014 they are not saved or reusable across sessions
-
-**Example uses:**
-- Create a security auditor agent with specific review criteria
-- Create a migration agent that follows a custom checklist
-- Create a specialized code generator with domain-specific instructions`,
-      parameters: {
-        type: "object",
-        properties: {
-          task: {
-            type: "string",
-            description: "Clear description of what you want the dynamic agent to accomplish."
-          },
-          name: {
-            type: "string",
-            description: 'Unique name for this dynamic agent (e.g., "security-auditor", "migration-helper"). Used for logging and identification.'
-          },
-          systemPrompt: {
-            type: "string",
-            description: "Custom system prompt for the agent. This defines the agent's role, capabilities, and constraints. Use $TASK to reference the task parameter."
-          },
-          description: {
-            type: "string",
-            description: "Short description of the agent's purpose (for logging)."
-          },
-          model: {
-            type: "string",
-            description: 'Model to use for this agent (e.g., "claude-sonnet-4-5-20250929"). Defaults to the agent system default.'
-          },
-          allowedTools: {
-            type: "array",
-            items: { type: "string" },
-            description: 'Whitelist of tool name patterns the agent can use. Supports wildcards (e.g., "file_*", "mcp__github__*"). If omitted, all non-denied tools are available.'
-          },
-          deniedTools: {
-            type: "array",
-            items: { type: "string" },
-            description: "Blacklist of tool name patterns the agent cannot use. agent_delegate and create_dynamic_agent are always denied."
-          },
-          thoroughness: {
-            type: "string",
-            enum: ["quick", "medium", "very_thorough"],
-            description: `How thoroughly to execute:
-- quick: Fast, 1-2 iterations
-- medium: Balanced, 3-5 iterations (default)
-- very_thorough: Comprehensive, 8-10+ iterations`
-          },
-          variables: {
-            type: "object",
-            additionalProperties: { type: "string" },
-            description: 'Variables to substitute in the system prompt. For example: { "DOMAIN": "auth" } replaces $DOMAIN in the prompt.'
-          },
-          run_in_background: {
-            type: "boolean",
-            description: "Run the agent in the background (non-blocking). Returns a job ID immediately. Use check_agent_status to poll for results."
-          },
-          group_description: {
-            type: "string",
-            description: "Short description of what this group of background agents is working on. Only needed for the first background agent in a group."
-          }
-        },
-        required: ["task", "name", "systemPrompt"]
-      }
-    }
-  };
-}
-
 // src/agents/BackgroundAgentManager.ts
 import { randomBytes as randomBytes4 } from "crypto";
 var DEFAULT_MAX_CONCURRENT = 4;
@@ -19550,7 +19777,7 @@ function createTodoStore(onUpdate) {
 
 // src/tools/findDefinitionTool.ts
 import { stat as stat3 } from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { createRequire as createRequire2 } from "module";
@@ -19571,8 +19798,8 @@ var ALL_KEYWORDS = Object.values(KIND_KEYWORDS).flat();
 function getRipgrepPath2() {
   try {
     const ripgrepPath = require3.resolve("@vscode/ripgrep");
-    const ripgrepDir = path17.dirname(ripgrepPath);
-    return path17.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path19.dirname(ripgrepPath);
+    return path19.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
   } catch {
     throw new Error(
       "ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services"
@@ -19580,10 +19807,10 @@ function getRipgrepPath2() {
   }
 }
 function isPathWithinWorkspace2(targetPath, baseCwd) {
-  const resolvedTarget = path17.resolve(targetPath);
-  const resolvedBase = path17.resolve(baseCwd);
-  const relativePath = path17.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path17.isAbsolute(relativePath);
+  const resolvedTarget = path19.resolve(targetPath);
+  const resolvedBase = path19.resolve(baseCwd);
+  const relativePath = path19.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path19.isAbsolute(relativePath);
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -19616,7 +19843,7 @@ async function findDefinitions(params) {
     throw new Error("symbol_name is required");
   }
   const baseCwd = process.cwd();
-  const targetDir = search_path ? path17.resolve(baseCwd, search_path) : baseCwd;
+  const targetDir = search_path ? path19.resolve(baseCwd, search_path) : baseCwd;
   if (!isPathWithinWorkspace2(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${search_path}" resolves outside the allowed workspace directory`);
   }
@@ -19671,7 +19898,7 @@ async function findDefinitions(params) {
         const lineText = match.data.lines.text.trimEnd();
         if (isLikelyDefinition(lineText)) {
           allMatches.push({
-            filePath: path17.relative(targetDir, match.data.path.text) || path17.basename(match.data.path.text),
+            filePath: path19.relative(targetDir, match.data.path.text) || path19.basename(match.data.path.text),
             lineNumber: match.data.line_number,
             line: lineText
           });
@@ -19749,8 +19976,8 @@ function createFindDefinitionTool() {
 }
 
 // src/tools/getFileStructure/index.ts
-import { existsSync as existsSync10, promises as fs13, statSync as statSync6 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync12, promises as fs14, statSync as statSync6 } from "fs";
+import path20 from "path";
 
 // src/tools/getFileStructure/formatter.ts
 var SECTIONS = [
@@ -19787,35 +20014,35 @@ function formatSection(lines, title, items, format) {
 }
 
 // src/tools/getFileStructure/index.ts
-var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
+var MAX_FILE_SIZE4 = 10 * 1024 * 1024;
 function createGetFileStructureTool() {
   return {
     toolFn: async (value) => {
       const params = value;
       try {
         const cwd = process.cwd();
-        const resolvedPath = path18.resolve(cwd, params.path);
+        const resolvedPath = path20.resolve(cwd, params.path);
         if (!resolvedPath.startsWith(cwd)) {
           return "Error: Access denied - cannot read files outside of current working directory";
         }
-        if (!existsSync10(resolvedPath)) {
+        if (!existsSync12(resolvedPath)) {
           return `Error: File not found: ${params.path}`;
         }
         const stats = statSync6(resolvedPath);
         if (stats.isDirectory()) {
           return `Error: Path is a directory, not a file: ${params.path}`;
         }
-        if (stats.size > MAX_FILE_SIZE3) {
-          return `Error: File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max: ${MAX_FILE_SIZE3 / 1024 / 1024}MB`;
+        if (stats.size > MAX_FILE_SIZE4) {
+          return `Error: File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max: ${MAX_FILE_SIZE4 / 1024 / 1024}MB`;
         }
-        const ext = path18.extname(resolvedPath).toLowerCase();
+        const ext = path20.extname(resolvedPath).toLowerCase();
         const { getLanguageForExtension, parseFileStructure, getSupportedLanguages } = await import("./treeSitterEngine-4SGFQDY3.js");
         const languageId = getLanguageForExtension(ext);
         if (!languageId) {
           const supported = getSupportedLanguages();
           return `Error: Unsupported file type "${ext}". Supported languages: ${supported.join(", ")}`;
         }
-        const sourceCode = await fs13.readFile(resolvedPath, "utf-8");
+        const sourceCode = await fs14.readFile(resolvedPath, "utf-8");
         const lineCount = sourceCode.split("\n").length;
         const items = await parseFileStructure(sourceCode, languageId);
         return formatStructureOutput(params.path, items, stats.size, lineCount);
@@ -19877,7 +20104,8 @@ function CliApp() {
     abortController: null,
     contextContent: "",
     backgroundManager: null,
-    wsManager: null
+    wsManager: null,
+    checkpointStore: null
   });
   const [isInitialized, setIsInitialized] = useState10(false);
   const [initError, setInitError] = useState10(null);
@@ -20131,6 +20359,12 @@ function CliApp() {
           enqueuePermissionPrompt(prompt);
         });
       };
+      const checkpointProjectDir = state.configStore.getProjectConfigDir() || process.cwd();
+      const checkpointStore = new CheckpointStore(checkpointProjectDir);
+      try {
+        await checkpointStore.init(newSession.id);
+      } catch {
+      }
       const agentContext = {
         currentAgent: null,
         observationQueue: []
@@ -20143,7 +20377,10 @@ function CliApp() {
         promptFn,
         agentContext,
         state.configStore,
-        apiClient
+        apiClient,
+        void 0,
+        // toolFilter
+        checkpointStore
       );
       startupLog.push(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
@@ -20174,7 +20411,8 @@ function CliApp() {
         apiClient,
         agentStore,
         customCommandStore: state.customCommandStore,
-        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
+        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
+        checkpointStore
       });
       const backgroundManager = new BackgroundAgentManager(orchestrator);
       backgroundManager.setOnStatusChange((job) => {
@@ -20185,7 +20423,6 @@ function CliApp() {
         useCliStore.getState().setPendingBackgroundTrigger(true);
       });
       const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id, backgroundManager);
-      const dynamicAgentTool = config.preferences.enableDynamicAgentCreation === true ? createDynamicAgentTool(orchestrator, newSession.id, backgroundManager) : null;
       const backgroundTools = createBackgroundAgentTools(backgroundManager);
       const notifyingLlm = new NotifyingLlmBackend(llm, backgroundManager);
       const todoStore = createTodoStore();
@@ -20208,9 +20445,6 @@ function CliApp() {
       if (skillTool) {
         cliTools.push(skillTool);
       }
-      if (dynamicAgentTool) {
-        cliTools.push(dynamicAgentTool);
-      }
       const allTools = [...b4mTools2, ...mcpTools, ...cliTools];
       startupLog.push(`\u{1F4C2} Working directory: ${process.cwd()}`);
       const agentNamesList = agentStore.getAgentNames().join(", ");
@@ -20221,9 +20455,6 @@ function CliApp() {
           startupLog.push(`\u{1F6E0}\uFE0F  Skill tool enabled (${skillCount} skills available)`);
         }
       }
-      if (dynamicAgentTool) {
-        startupLog.push(`\u{1F9EA} Dynamic agent creation enabled (experimental)`);
-      }
       logger.debug(
         `Total tools available to agent: ${allTools.length} (${b4mTools2.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI)`
       );
@@ -20242,8 +20473,7 @@ function CliApp() {
         contextContent: contextResult.mergedContent,
         agentStore,
         customCommands: state.customCommandStore.getAllCommands(),
-        enableSkillTool,
-        enableDynamicAgentCreation: config.preferences.enableDynamicAgentCreation === true
+        enableSkillTool
       });
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
@@ -20305,8 +20535,10 @@ function CliApp() {
         // Store raw context for compact instructions
         backgroundManager,
         // Store for grouped notification turn tracking
-        wsManager
+        wsManager,
         // WebSocket connection manager (null if using SSE fallback)
+        checkpointStore
+        // File change checkpointing for undo/restore
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -20999,6 +21231,10 @@ Available commands:
   /exit - Exit the CLI
   /clear - Start a new session
   /rewind - Rewind conversation to a previous point
+  /undo - Undo the last file change
+  /checkpoints - List available file restore points
+  /restore <n> - Restore files to a specific checkpoint
+  /diff [n] - Show diff between current state and a checkpoint
   /login - Authenticate with your B4M account
   /logout - Clear authentication and sign out
   /whoami - Show current authenticated user
@@ -21091,6 +21327,9 @@ Keyboard Shortcuts:
           }
           await logger.initialize(loadedSession.id);
           logger.debug("=== Session Resumed ===");
+          if (state.checkpointStore) {
+            state.checkpointStore.setSessionId(loadedSession.id);
+          }
           setState((prev) => ({ ...prev, session: loadedSession }));
           setStoreSession(loadedSession);
           useCliStore.getState().clearPendingMessages();
@@ -21329,6 +21568,9 @@ Keyboard Shortcuts:
         };
         await logger.initialize(newSession.id);
         logger.debug("=== New Session Started via /clear ===");
+        if (state.checkpointStore) {
+          state.checkpointStore.setSessionId(newSession.id);
+        }
         setState((prev) => ({ ...prev, session: newSession }));
         setStoreSession(newSession);
         useCliStore.getState().clearPendingMessages();
@@ -21339,8 +21581,7 @@ Keyboard Shortcuts:
 `);
         break;
       }
-      case "rewind":
-      case "undo": {
+      case "rewind": {
         if (!state.session) {
           console.log("No active session to rewind");
           return;
@@ -21399,6 +21640,103 @@ Keyboard Shortcuts:
         }));
         break;
       }
+      case "undo": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const undoCheckpoints = state.checkpointStore.listCheckpoints();
+        if (undoCheckpoints.length === 0) {
+          console.log("No checkpoints available. No file changes have been made yet.");
+          return;
+        }
+        try {
+          const restored = await state.checkpointStore.undoLast();
+          console.log(`
+\u2705 Restored ${restored.filePaths.length} file(s) to state before: ${restored.name}`);
+          for (const f of restored.filePaths) {
+            console.log(`  - ${f}`);
+          }
+          console.log("");
+        } catch (err) {
+          console.log(`Failed to undo: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
+      case "checkpoints": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const cpList = state.checkpointStore.listCheckpoints();
+        if (cpList.length === 0) {
+          console.log("No checkpoints yet. Checkpoints are created automatically before file changes.");
+          return;
+        }
+        console.log("\nCheckpoints (most recent first):\n");
+        cpList.forEach((cp, idx) => {
+          const ageMs = Date.now() - new Date(cp.timestamp).getTime();
+          const ageSec = Math.floor(ageMs / 1e3);
+          let age;
+          if (ageSec < 60) age = `${ageSec}s ago`;
+          else if (ageSec < 3600) age = `${Math.floor(ageSec / 60)}m ago`;
+          else age = `${Math.floor(ageSec / 3600)}h ago`;
+          console.log(`  ${idx + 1}. ${cp.name} (${age}) - ${cp.filePaths.length} file(s)`);
+        });
+        console.log("\nUse /restore <number> to restore, /diff <number> to see changes.\n");
+        break;
+      }
+      case "restore": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const restoreTarget = args[0];
+        if (!restoreTarget) {
+          console.log("Usage: /restore <checkpoint-number>");
+          console.log("Use /checkpoints to list available restore points.");
+          return;
+        }
+        const restoreNum = parseInt(restoreTarget, 10);
+        if (isNaN(restoreNum) || restoreNum < 1) {
+          console.log("Please provide a valid checkpoint number. Use /checkpoints to list.");
+          return;
+        }
+        try {
+          const restoredCp = await state.checkpointStore.restoreCheckpoint(restoreNum);
+          console.log(`
+\u2705 Restored to checkpoint: ${restoredCp.name}`);
+          for (const f of restoredCp.filePaths) {
+            console.log(`  - ${f}`);
+          }
+          console.log("");
+        } catch (err) {
+          console.log(`Failed to restore: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
+      case "diff": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const diffTarget = args[0] ? parseInt(args[0], 10) : 1;
+        if (isNaN(diffTarget) || diffTarget < 1) {
+          console.log("Usage: /diff [checkpoint-number] (defaults to 1, most recent)");
+          return;
+        }
+        try {
+          const diffOutput = state.checkpointStore.getCheckpointDiff(diffTarget);
+          if (!diffOutput.trim()) {
+            console.log("No differences found between checkpoint and current state.");
+          } else {
+            console.log(diffOutput);
+          }
+        } catch (err) {
+          console.log(`Failed to generate diff: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
       case "usage": {
         const usageAuthTokens = await state.configStore.getAuthTokens();
         if (!usageAuthTokens || new Date(usageAuthTokens.expiresAt) <= /* @__PURE__ */ new Date()) {