@bike4mind/cli 0.2.31-update-default-agent-models.19589 → 0.2.31

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import "./chunk-GQGOWACU.js";
-import "./chunk-4P27WV34.js";
-import "./chunk-S6AUIWWB.js";
+import "./chunk-C7LKV7P2.js";
+import "./chunk-4R42FAEH.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-DQHCE3TN.js";
+} from "./chunk-BD56DFFM.js";
 import {
   ConfigStore,
   logger
@@ -16,7 +16,7 @@ import {
 import {
   checkForUpdate,
   package_default
-} from "./chunk-SB53O27R.js";
+} from "./chunk-PAE3OMY2.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -32,7 +32,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-PV6PZFPC.js";
+} from "./chunk-UAJBCJZ2.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -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",
@@ -2838,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
@@ -3004,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")
     ];
   }
   /**
@@ -3036,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;
       }
@@ -3069,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);
@@ -3091,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);
   }
@@ -3110,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;
   }
   /**
@@ -3172,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]
@@ -3195,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;
   }
 };
@@ -4427,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";
 
@@ -6118,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) {
@@ -7445,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;
@@ -8064,7 +8418,7 @@ var blogDraftTool = {
           outputFormat,
           additionalInstructions: params.additionalInstructions
         });
-        const modelToUse = context.model || "claude-sonnet-4-5-20250929";
+        const modelToUse = context.model || ChatModels.CLAUDE_4_6_SONNET;
         logger2.info("Using model for blog draft:", { model: modelToUse });
         let llmResponse = "";
         await llm.complete(modelToUse, [
@@ -9387,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;
@@ -9451,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);
@@ -9468,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,
@@ -9512,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
@@ -9541,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
@@ -9583,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/**",
@@ -9599,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`);
   }
@@ -9639,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}`;
@@ -9693,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 === "**/*") {
@@ -9729,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`);
   }
@@ -9791,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
@@ -9884,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);
@@ -9905,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`;
   }
@@ -9918,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
@@ -11496,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",
@@ -11541,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",
@@ -12598,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 = [
@@ -12782,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 = "";
@@ -13785,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);
@@ -13811,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}"`);
@@ -13830,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
@@ -14390,7 +14767,8 @@ var SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
 var CodeReviewAgent = (config) => ({
   name: "code_review",
   description: "Code review specialist for analyzing code quality, bugs, and improvements",
-  model: config?.model ?? "claude-sonnet-4-5-20250929",
+  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET,
+  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
   defaultThoroughness: config?.defaultThoroughness ?? "medium",
   maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
   deniedTools: ["image_generation", "edit_image", "delegate_to_agent", ...config?.extraDeniedTools ?? []],
@@ -14430,7 +14808,8 @@ Focus on actionable, specific feedback referencing exact code locations. Your re
 var ProjectManagerAgent = (config) => ({
   name: "project_manager",
   description: "Project management via Jira and Confluence (create issues, search, update status, write docs). ALWAYS delegate Jira/Confluence requests to this agent \u2014 you do not have direct access to these tools",
-  model: config?.model ?? "claude-sonnet-4-5-20250929",
+  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET,
+  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
   defaultThoroughness: config?.defaultThoroughness ?? "medium",
   maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
   allowedTools: [...config?.extraAllowedTools ?? []],
@@ -14471,7 +14850,8 @@ Be precise with issue keys and project names. Your results will be used by the m
 var GithubManagerAgent = (config) => ({
   name: "github_manager",
   description: "GitHub operations (issues, pull requests, code search, branches, workflows, reviews). ALWAYS delegate GitHub requests to this agent \u2014 you do not have direct access to these tools",
-  model: config?.model ?? "claude-sonnet-4-5-20250929",
+  model: config?.model ?? ChatModels.CLAUDE_4_6_SONNET,
+  fallbackModels: [ChatModels.GPT4_1, ChatModels.GPT4_1_MINI],
   defaultThoroughness: config?.defaultThoroughness ?? "medium",
   maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
   allowedTools: [...config?.extraAllowedTools ?? []],
@@ -14479,12 +14859,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
 
@@ -14525,7 +14920,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.`
@@ -15220,10 +15615,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;
@@ -15261,10 +15656,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}
@@ -15555,33 +15950,34 @@ var AgentFrontmatterSchema = z147.object({
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
-  quick: 4,
-  medium: 10,
-  very_thorough: 20
+  quick: 2,
+  medium: 5,
+  very_thorough: 10
 };
-var DEFAULT_AGENT_MODEL = "claude-haiku-4-5-20251001";
+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" };
   }
 };
@@ -15754,6 +16150,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",
@@ -15778,7 +16195,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 = {
@@ -15837,9 +16254,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);
@@ -16017,8 +16442,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 = [
@@ -16039,9 +16464,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;
     }
@@ -16055,7 +16480,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,
@@ -16107,7 +16532,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")),
@@ -16378,8 +16803,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;
@@ -16420,18 +16845,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);
@@ -17361,6 +17786,7 @@ var WebSocketLlmBackend = class {
         settled = true;
         this.wsManager.offRequest(requestId);
         this.wsManager.offDisconnect(onDisconnect);
+        options.abortSignal?.removeEventListener("abort", abortHandler);
         action();
       };
       const settleResolve = () => settle(() => resolve3());
@@ -17370,19 +17796,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) {
@@ -17720,27 +18143,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") {
@@ -18163,26 +18594,14 @@ var SubagentOrchestrator = class {
       const available = this.deps.agentStore.getAgentNames().join(", ");
       throw new Error(`Unknown agent: "${agentName}". Available agents: ${available}`);
     }
-    let effectiveModel = model || agentDef.model;
-    if (!model && !agentDef.modelResolved) {
-      const config = await this.deps.configStore.get();
-      if (config?.defaultModel) {
-        this.deps.logger.debug(
-          `Agent "${agentName}" model unresolved, inheriting main session model: ${config.defaultModel}`
-        );
-        effectiveModel = config.defaultModel;
-      }
-    }
+    const effectiveModel = model || agentDef.model;
     const effectiveThoroughness = thoroughness || agentDef.defaultThoroughness;
     const maxIterations = agentDef.maxIterations[effectiveThoroughness];
     const effectiveVariables = {
       ...agentDef.defaultVariables,
       ...variables
     };
-    let systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables, {
-      maxIterations,
-      thoroughness: effectiveThoroughness
-    });
+    let systemPrompt = this.substituteVariables(agentDef.systemPrompt, task, effectiveVariables);
     const effectiveAllowedTools = allowedTools || agentDef.allowedTools;
     const toolFilter = {
       allowedTools: effectiveAllowedTools,
@@ -18200,7 +18619,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) {
@@ -18299,15 +18721,11 @@ var SubagentOrchestrator = class {
   }
   /**
    * Substitute variables in system prompt
-   * Reserved: $TASK, $MAX_ITERATIONS, $THOROUGHNESS
+   * Reserved: $TASK, $ARGUMENTS, $1, $2, etc.
    */
-  substituteVariables(systemPrompt, task, variables, reserved) {
+  substituteVariables(systemPrompt, task, variables) {
     let result = systemPrompt;
     result = result.split("$TASK").join(task);
-    if (reserved) {
-      result = result.split("$MAX_ITERATIONS").join(String(reserved.maxIterations));
-      result = result.split("$THOROUGHNESS").join(reserved.thoroughness);
-    }
     if (variables) {
       for (const [key, value] of Object.entries(variables)) {
         result = result.split(`$${key}`).join(value);
@@ -18357,8 +18775,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 = [
@@ -18487,7 +18905,7 @@ function resolveModelAlias(modelInput, agentName, filePath) {
   }
   const availableAliases = getAvailableModelAliases();
   const suggestions = availableAliases.filter((alias) => alias.includes(normalizedInput) || normalizedInput.includes(alias)).slice(0, 5);
-  let warning = `Unknown model "${modelInput}" in agent "${agentName}" (${filePath}). Will inherit the main session model at runtime.
+  let warning = `Unknown model "${modelInput}" in agent "${agentName}" (${filePath}). Using inherited model instead.
 `;
   if (suggestions.length > 0) {
     warning += `Did you mean: ${suggestions.join(", ")}?
@@ -18508,10 +18926,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
@@ -18535,7 +18953,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;
       }
@@ -18563,9 +18981,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);
@@ -18582,10 +19000,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) {
@@ -18610,8 +19028,7 @@ var AgentStore = class {
       defaultVariables: parsed.variables,
       hooks: parsed.hooks,
       source,
-      filePath,
-      modelResolved: resolution.resolved
+      filePath
     };
   }
   /**
@@ -18666,16 +19083,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
@@ -18710,7 +19127,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;
   }
   /**
@@ -19363,7 +19780,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";
@@ -19384,8 +19801,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"
@@ -19393,10 +19810,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, "\\$&");
@@ -19429,7 +19846,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`);
   }
@@ -19484,7 +19901,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
           });
@@ -19562,8 +19979,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 = [
@@ -19600,35 +20017,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);
@@ -19690,7 +20107,8 @@ function CliApp() {
     abortController: null,
     contextContent: "",
     backgroundManager: null,
-    wsManager: null
+    wsManager: null,
+    checkpointStore: null
   });
   const [isInitialized, setIsInitialized] = useState10(false);
   const [initError, setInitError] = useState10(null);
@@ -19944,6 +20362,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: []
@@ -19956,7 +20380,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);
@@ -19987,7 +20414,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) => {
@@ -20110,8 +20538,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 = [
@@ -20804,6 +21234,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
@@ -20896,6 +21330,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();
@@ -21134,6 +21571,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();
@@ -21144,8 +21584,7 @@ Keyboard Shortcuts:
 `);
         break;
       }
-      case "rewind":
-      case "undo": {
+      case "rewind": {
         if (!state.session) {
           console.log("No active session to rewind");
           return;
@@ -21204,6 +21643,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()) {