@bike4mind/cli 0.2.30 → 0.2.31-b4m-cli-undo-command.19493

package/dist/index.js

@@ -5,8 +5,8 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-WIB75EEX.js";
-import "./chunk-RUI6HNLO.js";
+} from "./chunk-T67NGQW6.js";
+import "./chunk-GQGOWACU.js";
 import {
   ConfigStore,
   logger
@@ -15,8 +15,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-BYXFQJYT.js";
-import "./chunk-LLA44SW7.js";
-import "./chunk-U63VANTQ.js";
+import "./chunk-2LLA4MTN.js";
+import "./chunk-ZOWCX4MQ.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -28,7 +28,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-BQAPZP5Y.js";
+} from "./chunk-RI45VJW3.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -83,8 +83,10 @@ import {
   VideoModels,
   XAI_IMAGE_MODELS,
   b4mLLMTools,
-  getMcpProviderMetadata
-} from "./chunk-T4VPCTBM.js";
+  getMcpProviderMetadata,
+  getViewById,
+  resolveNavigationIntents
+} from "./chunk-GE7Q64MS.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -94,7 +96,7 @@ import React21, { useState as useState10, useEffect as useEffect7, useCallback a
 import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
 import { execSync } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
-import { v4 as uuidv411 } from "uuid";
+import { v4 as uuidv413 } from "uuid";
 
 // src/components/App.tsx
 import React15, { useState as useState6, useEffect as useEffect5 } from "react";
@@ -350,9 +352,23 @@ function CommandAutocomplete({ commands, selectedIndex }) {
   if (commands.length === 0) {
     return /* @__PURE__ */ React3.createElement(Box2, { marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, "No matching commands"));
   }
-  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, commands.length === 1 ? "1 command" : `${commands.length} commands`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), commands.map((cmd, index) => {
+  const VIEWPORT_SIZE = 6;
+  const totalCommands = commands.length;
+  let startIndex = 0;
+  let endIndex = Math.min(VIEWPORT_SIZE, totalCommands);
+  if (totalCommands > VIEWPORT_SIZE) {
+    const halfViewport = Math.floor(VIEWPORT_SIZE / 2);
+    startIndex = Math.max(0, selectedIndex - halfViewport);
+    endIndex = Math.min(totalCommands, startIndex + VIEWPORT_SIZE);
+    if (endIndex === totalCommands) {
+      startIndex = Math.max(0, totalCommands - VIEWPORT_SIZE);
+    }
+  }
+  const visibleCommands = commands.slice(startIndex, endIndex);
+  return /* @__PURE__ */ React3.createElement(Box2, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, /* @__PURE__ */ React3.createElement(Box2, { marginBottom: 1 }, /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, totalCommands === 1 ? "1 command" : `${totalCommands} commands`, totalCommands > VIEWPORT_SIZE && ` (${selectedIndex + 1}/${totalCommands})`, " \u2022 Use \u2191\u2193 to navigate, Enter to select")), visibleCommands.map((cmd, viewportIndex) => {
+    const actualIndex = startIndex + viewportIndex;
     const args = cmd.args ? ` ${cmd.args}` : "";
-    const isSelected = index === selectedIndex;
+    const isSelected = actualIndex === selectedIndex;
     const sourceIcon = cmd.source === "global" ? "\u{1F3E0} " : cmd.source === "project" ? "\u{1F4C1} " : cmd.source === "built-in" ? "\u{1F527} " : "";
     return /* @__PURE__ */ React3.createElement(Box2, { key: cmd.name, marginLeft: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: isSelected ? "cyan" : void 0, bold: isSelected }, isSelected ? "\u25B8 " : "  ", sourceIcon, "/", cmd.name, args, " - ", cmd.description));
   }));
@@ -713,8 +729,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",
@@ -1096,8 +1129,8 @@ function InputPrompt({
   useEffect3(() => {
     onBashModeChange?.(isBashMode);
   }, [isBashMode, onBashModeChange]);
-  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active && !looksLikeFilePath(value) && !pastedContent;
-  const commandQuery = shouldShowCommandAutocomplete ? value.slice(1) : "";
+  const commandQuery = value.startsWith("/") ? value.slice(1) : "";
+  const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active && !looksLikeFilePath(value) && !pastedContent && !commandQuery.includes(" ");
   const filteredCommands = useMemo(() => {
     if (!shouldShowCommandAutocomplete) return [];
     return searchCommands(commandQuery, commands);
@@ -2818,9 +2851,327 @@ 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 = path6.resolve(this.projectDir, 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.stat(absolutePath);
+          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 = path6.resolve(this.projectDir, 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 = path6.resolve(this.projectDir, filePath);
+      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;
+        }
+        const tmpCheckpoint = path6.join(this.shadowRepoDir, ".diff-a");
+        const tmpCurrent = path6.join(this.shadowRepoDir, ".diff-b");
+        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}`);
+            }
+          }
+        }
+        try {
+          unlinkSync(tmpCheckpoint);
+          unlinkSync(tmpCurrent);
+        } catch {
+        }
+      } 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 ---
+  /**
+   * 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
@@ -2983,14 +3334,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")
     ];
   }
   /**
@@ -3015,7 +3366,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;
       }
@@ -3048,9 +3399,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);
@@ -3070,14 +3421,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);
   }
@@ -3089,7 +3440,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;
   }
   /**
@@ -3151,15 +3502,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]
@@ -3174,7 +3525,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;
   }
 };
@@ -3388,7 +3739,8 @@ ${options.context}` : this.getSystemPrompt()
             maxTokens,
             temperature,
             abortSignal: options.signal,
-            tool_choice: this.context.toolChoice
+            tool_choice: this.context.toolChoice,
+            executeTools: false
           },
           async (texts, completionInfo) => {
             for (const text of texts) {
@@ -4405,7 +4757,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";
 
@@ -6096,8 +6448,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) {
@@ -7423,8 +7775,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;
@@ -9057,8 +9409,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z147 = r * sinOmega * sinI;
-  return { x, y, z: z147, r };
+  const z148 = r * sinOmega * sinI;
+  return { x, y, z: z148, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -9365,33 +9717,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;
@@ -9429,7 +9781,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);
@@ -9446,7 +9798,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,
@@ -9490,25 +9842,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
@@ -9519,7 +9871,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
@@ -9561,7 +9913,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/**",
@@ -9577,7 +9929,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`);
   }
@@ -9617,7 +9969,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}`;
@@ -9671,27 +10023,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 === "**/*") {
@@ -9707,7 +10080,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`);
   }
@@ -9769,7 +10142,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
@@ -9862,18 +10235,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);
@@ -9883,10 +10256,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`;
   }
@@ -9896,8 +10269,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
@@ -9942,13 +10315,13 @@ function formatSearchResults(files) {
     const notes = file.notes ? `
    Notes: ${file.notes}` : "";
     const fileType = file.type || "FILE";
-    return `${index + 1}. **${file.fileName}**
+    return `${index + 1}. **${file.fileName}** (ID: ${file.id})
    Type: ${fileType} | MIME: ${file.mimeType}
    Tags: ${tags}${notes}`;
   });
   return `Found ${files.length} document(s) in your knowledge base:
 
-` + formattedFiles.join("\n\n") + "\n\n*To use these documents in your conversation, you can ask me to reference specific files by name.*";
+` + formattedFiles.join("\n\n") + "\n\n*Use retrieve_knowledge_content with a file ID or tags to read the actual document content.*";
 }
 var knowledgeBaseSearchTool = {
   name: "search_knowledge_base",
@@ -9975,6 +10348,8 @@ var knowledgeBaseSearchTool = {
           by: "fileName",
           direction: "asc"
         }, {
+          textSearch: true,
+          // Search across fileName + tags + notes for better recall
           includeShared: true,
           // Include owned + explicitly shared + org-shared files
           userGroups: context.user.groups || []
@@ -9989,18 +10364,18 @@ var knowledgeBaseSearchTool = {
     },
     toolSchema: {
       name: "search_knowledge_base",
-      description: "Search the user's uploaded knowledge base (fab files). Returns relevant documents from the user's own files, organization-shared files, and files explicitly shared with them. Use this tool when the user asks about their own documents, uploaded files, or organization knowledge.",
+      description: "Search the user's uploaded knowledge base (fab files). Searches across file names, tags, and notes for broad recall. Returns relevant documents from the user's own files, organization-shared files, and files explicitly shared with them. Use this tool when the user asks about their own documents, uploaded files, or organization knowledge.",
       parameters: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "The search query to find relevant documents by filename or content"
+            description: "The search query to find relevant documents. Matches against file names, tags, and notes."
           },
           tags: {
             type: "array",
             items: { type: "string" },
-            description: "Optional: filter results to only include files with these tags"
+            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs", etc. Any matching tag qualifies the file.'
           },
           file_type: {
             type: "string",
@@ -10020,85 +10395,1707 @@ var knowledgeBaseSearchTool = {
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
-import { spawn } from "child_process";
-import path12 from "path";
-var DEFAULT_TIMEOUT_MS = 6e4;
-var MAX_OUTPUT_SIZE = 100 * 1024;
-var DANGEROUS_PATTERNS = [
-  // Destructive file operations
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
-    reason: "Recursive delete with path",
-    block: true
-  },
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
-    reason: "Force delete without preserve root",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
-    reason: "Recursive force delete on root paths",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
-    reason: "Force recursive delete on root paths",
-    block: true
-  },
-  // System-level dangerous commands
-  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
-  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
-  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
-  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
-  // Disk/partition operations
-  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
-  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
-  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
-  // Network attacks
-  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
-  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  // Fork bombs and resource exhaustion
-  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
-  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
-  // Credential/sensitive data access
-  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
-  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
-  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
-  // History/log manipulation
-  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
-  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
-  // Dangerous redirects
-  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
-  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
-  // Environment manipulation
-  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
-  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
-  // Process/system control
-  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
-  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
-  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
-  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
-  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
-];
-var SAFE_COMMAND_PREFIXES = [
-  "ls",
-  "cat",
-  "head",
-  "tail",
-  "grep",
-  "find",
-  "echo",
-  "pwd",
-  "whoami",
-  "date",
-  "cal",
-  "wc",
-  "sort",
-  "uniq",
-  "cut",
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/knowledgeBaseRetrieve/index.js
+var DEFAULT_MAX_CHARS = 8e3;
+var ABSOLUTE_MAX_CHARS = 16e3;
+var knowledgeBaseRetrieveTool = {
+  name: "retrieve_knowledge_content",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { file_id, tags, query, max_chars } = params;
+      const charBudget = Math.min(max_chars ?? DEFAULT_MAX_CHARS, ABSOLUTE_MAX_CHARS);
+      context.logger.log("\u{1F4D6} Knowledge Retrieve: params", { file_id, tags, query, max_chars: charBudget });
+      if (!file_id && !tags?.length && !query) {
+        return "Error: You must provide at least one of file_id, tags, or query.";
+      }
+      if (!context.db.fabfiles) {
+        context.logger.error("\u274C Knowledge Retrieve: fabfiles repository not available");
+        return "Knowledge base retrieval is not available at this time.";
+      }
+      if (!context.db.fabfilechunks) {
+        context.logger.error("\u274C Knowledge Retrieve: fabfilechunks repository not available");
+        return "Knowledge base retrieval is not available at this time (chunk reader unavailable).";
+      }
+      try {
+        let files = [];
+        if (file_id) {
+          const file = await context.db.fabfiles.findByIdAndUserId(file_id, context.userId);
+          if (file) {
+            files = [file];
+          } else {
+            const searchResults = await context.db.fabfiles.search(context.userId, file_id, { tags: [], shared: false }, { page: 1, limit: 1 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+            files = searchResults.data;
+          }
+          if (files.length === 0) {
+            return `No document found with ID "${file_id}". The file may not exist or you may not have access to it. Try using search_knowledge_base to find the correct file ID.`;
+          }
+        }
+        if (files.length === 0 && (tags?.length || query)) {
+          const searchResults = await context.db.fabfiles.search(context.userId, query || "", { tags: tags || [], shared: false }, { page: 1, limit: 5 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+          files = searchResults.data;
+          if (files.length === 0) {
+            const searchDesc = [query && `query "${query}"`, tags?.length && `tags [${tags.join(", ")}]`].filter(Boolean).join(" and ");
+            return `No documents found matching ${searchDesc}. Try broadening your search with search_knowledge_base.`;
+          }
+        }
+        let totalCharsUsed = 0;
+        const sections = [];
+        let filesRetrieved = 0;
+        for (const file of files) {
+          if (totalCharsUsed >= charBudget)
+            break;
+          const chunks = await context.db.fabfilechunks.findByFabFileId(file.id);
+          if (chunks.length === 0) {
+            context.logger.log(`\u{1F4D6} Knowledge Retrieve: No chunks for file ${file.fileName} (${file.id})`);
+            continue;
+          }
+          const fullText = chunks.map((c) => c.text).join("\n");
+          const remainingBudget = charBudget - totalCharsUsed;
+          const truncated = fullText.length > remainingBudget;
+          const content = truncated ? fullText.slice(0, remainingBudget) : fullText;
+          const fileTags = file.tags?.map((t) => t.name).join(", ") || "none";
+          const charLabel = truncated ? `${content.length} (truncated from ${fullText.length})` : `${content.length}`;
+          sections.push(`### ${file.fileName} (ID: ${file.id})
+Tags: ${fileTags}
+Chunks: ${chunks.length} | Characters: ${charLabel}
+---
+` + content);
+          totalCharsUsed += content.length;
+          filesRetrieved++;
+        }
+        if (filesRetrieved === 0) {
+          return "Found matching documents but they have no indexed content. The files may not have been processed yet.";
+        }
+        const header = `Retrieved content from ${filesRetrieved} of ${files.length} document(s):
+`;
+        return header + "\n" + sections.join("\n\n---\n\n");
+      } catch (error) {
+        context.logger.error("\u274C Knowledge Retrieve: Error during retrieval:", error);
+        return "An error occurred while retrieving document content. Please try again.";
+      }
+    },
+    toolSchema: {
+      name: "retrieve_knowledge_content",
+      description: "Read the actual text content of knowledge base documents. Use this after search_knowledge_base to read documents by file ID, or provide tags/query to find and read documents in one step. Returns the full text content (up to the character budget) for grounding your responses in the user's curated knowledge.",
+      parameters: {
+        type: "object",
+        properties: {
+          file_id: {
+            type: "string",
+            description: "The file ID to retrieve (from search_knowledge_base results). Most efficient for single-document retrieval."
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs", etc.'
+          },
+          query: {
+            type: "string",
+            description: "Search query to find documents. Can be combined with tags for more targeted retrieval."
+          },
+          max_chars: {
+            type: "number",
+            description: "Maximum characters of content to return (default: 8000, max: 16000). Lower values for quick lookups, higher for detailed reading.",
+            minimum: 500,
+            maximum: 16e3
+          }
+        }
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/quantum/dist/src/types.js
+import { z as z139 } from "zod";
+var OperationSchema = z139.object({
+  jobId: z139.number(),
+  machineId: z139.number(),
+  duration: z139.number().positive()
+});
+var JobSchema = z139.object({
+  id: z139.number(),
+  name: z139.string(),
+  operations: z139.array(OperationSchema)
+});
+var MachineSchema = z139.object({
+  id: z139.number(),
+  name: z139.string()
+});
+var SchedulingProblemSchema = z139.object({
+  name: z139.string(),
+  description: z139.string().optional(),
+  jobs: z139.array(JobSchema),
+  machines: z139.array(MachineSchema)
+});
+var SolverIdSchema = z139.enum([
+  "greedy",
+  "naive",
+  "random-restart",
+  "simulated-annealing",
+  "simulated-annealing-medium",
+  "simulated-annealing-large",
+  "tabu",
+  "genetic-algorithm",
+  "ant-colony",
+  "highs",
+  "simulated-qaoa",
+  "ionq-qaoa"
+]);
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/greedy-solver.js
+var greedySolver = {
+  id: "greedy",
+  name: "Greedy (Earliest Start)",
+  description: "Schedules each operation at the earliest available time on its machine, respecting job ordering.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const machineAvailableAt = /* @__PURE__ */ new Map();
+    for (const machine of problem.machines) {
+      machineAvailableAt.set(machine.id, 0);
+    }
+    const jobCompletedAt = /* @__PURE__ */ new Map();
+    for (const job of problem.jobs) {
+      jobCompletedAt.set(job.id, 0);
+    }
+    const schedule = [];
+    const totalOps = problem.jobs.reduce((sum2, job) => sum2 + job.operations.length, 0);
+    let opsScheduled = 0;
+    for (const job of problem.jobs) {
+      for (let opIndex = 0; opIndex < job.operations.length; opIndex++) {
+        const op = job.operations[opIndex];
+        const machineReady = machineAvailableAt.get(op.machineId) ?? 0;
+        const jobReady = jobCompletedAt.get(job.id) ?? 0;
+        const opStart = Math.max(machineReady, jobReady);
+        const opEnd = opStart + op.duration;
+        schedule.push({
+          jobId: job.id,
+          machineId: op.machineId,
+          operationIndex: opIndex,
+          startTime: opStart,
+          endTime: opEnd
+        });
+        machineAvailableAt.set(op.machineId, opEnd);
+        jobCompletedAt.set(job.id, opEnd);
+        opsScheduled++;
+        if (options?.onProgress) {
+          options.onProgress({
+            solverId: "greedy",
+            percentage: Math.round(opsScheduled / totalOps * 100),
+            bestMakespan: opEnd,
+            currentIteration: opsScheduled,
+            totalIterations: totalOps
+          });
+        }
+      }
+    }
+    const makespan = Math.max(...schedule.map((op) => op.endTime));
+    const elapsedMs = performance.now() - startTime;
+    return {
+      solverId: "greedy",
+      solverName: "Greedy (Earliest Start)",
+      makespan,
+      schedule,
+      elapsedMs,
+      iterations: totalOps
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/schedule-utils.js
+function buildOperationList(problem) {
+  const ops = [];
+  for (const job of problem.jobs) {
+    for (let i = 0; i < job.operations.length; i++) {
+      ops.push({ jobId: job.id, opIndex: i });
+    }
+  }
+  return ops;
+}
+function decodePermutation(permutation, problem) {
+  const schedule = [];
+  const machineAvailableAt = /* @__PURE__ */ new Map();
+  const jobCompletedAt = /* @__PURE__ */ new Map();
+  const jobNextOp = /* @__PURE__ */ new Map();
+  for (const machine of problem.machines) {
+    machineAvailableAt.set(machine.id, 0);
+  }
+  for (const job of problem.jobs) {
+    jobCompletedAt.set(job.id, 0);
+    jobNextOp.set(job.id, 0);
+  }
+  const remaining = [...permutation];
+  const maxPasses = remaining.length * remaining.length;
+  let passes = 0;
+  while (remaining.length > 0 && passes < maxPasses) {
+    let scheduled = false;
+    for (let i = 0; i < remaining.length; i++) {
+      const ref = remaining[i];
+      const nextOp = jobNextOp.get(ref.jobId) ?? 0;
+      if (ref.opIndex !== nextOp)
+        continue;
+      const job = problem.jobs.find((j) => j.id === ref.jobId);
+      const op = job.operations[ref.opIndex];
+      const machineReady = machineAvailableAt.get(op.machineId) ?? 0;
+      const jobReady = jobCompletedAt.get(ref.jobId) ?? 0;
+      const start = Math.max(machineReady, jobReady);
+      const end = start + op.duration;
+      schedule.push({
+        jobId: ref.jobId,
+        machineId: op.machineId,
+        operationIndex: ref.opIndex,
+        startTime: start,
+        endTime: end
+      });
+      machineAvailableAt.set(op.machineId, end);
+      jobCompletedAt.set(ref.jobId, end);
+      jobNextOp.set(ref.jobId, nextOp + 1);
+      remaining.splice(i, 1);
+      scheduled = true;
+      break;
+    }
+    if (!scheduled) {
+      remaining.push(remaining.shift());
+    }
+    passes++;
+  }
+  return schedule;
+}
+function computeMakespan(schedule) {
+  if (schedule.length === 0)
+    return 0;
+  return Math.max(...schedule.map((op) => op.endTime));
+}
+function randomPermutation(problem, rng = Math.random) {
+  const ops = buildOperationList(problem);
+  for (let i = ops.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [ops[i], ops[j]] = [ops[j], ops[i]];
+  }
+  return ops;
+}
+function swapNeighbor(perm, rng = Math.random) {
+  const newPerm = [...perm];
+  const i = Math.floor(rng() * newPerm.length);
+  let j = Math.floor(rng() * (newPerm.length - 1));
+  if (j >= i)
+    j++;
+  [newPerm[i], newPerm[j]] = [newPerm[j], newPerm[i]];
+  return newPerm;
+}
+function createRng(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/naive-solver.js
+var MAX_PERMUTATIONS = 40320;
+function* permutations(arr) {
+  if (arr.length <= 1) {
+    yield [...arr];
+    return;
+  }
+  for (let i = 0; i < arr.length; i++) {
+    const rest = [...arr.slice(0, i), ...arr.slice(i + 1)];
+    for (const perm of permutations(rest)) {
+      yield [arr[i], ...perm];
+    }
+  }
+}
+var naiveSolver = {
+  id: "naive",
+  name: "Naive (Brute Force)",
+  description: "Evaluates all permutations to find the optimal schedule. Only feasible for small problems.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const ops = buildOperationList(problem);
+    const totalPerms = factorial(ops.length);
+    const cappedTotal = Math.min(totalPerms, MAX_PERMUTATIONS);
+    let bestMakespan = Infinity;
+    let bestSchedule = decodePermutation(ops, problem);
+    let count = 0;
+    for (const perm of permutations(ops)) {
+      if (count >= MAX_PERMUTATIONS)
+        break;
+      const schedule = decodePermutation(perm, problem);
+      const makespan = computeMakespan(schedule);
+      if (makespan < bestMakespan) {
+        bestMakespan = makespan;
+        bestSchedule = schedule;
+      }
+      count++;
+      if (options?.onProgress && count % 100 === 0) {
+        options.onProgress({
+          solverId: "naive",
+          percentage: Math.min(99, Math.round(count / cappedTotal * 100)),
+          bestMakespan,
+          currentIteration: count,
+          totalIterations: cappedTotal
+        });
+      }
+    }
+    options?.onProgress?.({
+      solverId: "naive",
+      percentage: 100,
+      bestMakespan,
+      currentIteration: count,
+      totalIterations: cappedTotal
+    });
+    return {
+      solverId: "naive",
+      solverName: "Naive (Brute Force)",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: count
+    };
+  }
+};
+function factorial(n) {
+  if (n <= 1)
+    return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++)
+    result *= i;
+  return result;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/random-restart-solver.js
+var RESTARTS = 50;
+var HILL_CLIMB_ITERATIONS = 500;
+var randomRestartSolver = {
+  id: "random-restart",
+  name: "Random Restart Hill Climbing",
+  description: "Multiple random starts with local search improvement via operation swaps.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 1e4;
+    const rng = createRng(42);
+    let globalBestMakespan = Infinity;
+    let globalBestSchedule = decodePermutation(randomPermutation(problem, rng), problem);
+    let totalIterations = 0;
+    for (let restart = 0; restart < RESTARTS; restart++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      let currentPerm = randomPermutation(problem, rng);
+      let currentSchedule = decodePermutation(currentPerm, problem);
+      let currentMakespan = computeMakespan(currentSchedule);
+      for (let i = 0; i < HILL_CLIMB_ITERATIONS; i++) {
+        if (performance.now() - startTime > timeoutMs)
+          break;
+        const neighborPerm = swapNeighbor(currentPerm, rng);
+        const neighborSchedule = decodePermutation(neighborPerm, problem);
+        const neighborMakespan = computeMakespan(neighborSchedule);
+        if (neighborMakespan < currentMakespan) {
+          currentPerm = neighborPerm;
+          currentSchedule = neighborSchedule;
+          currentMakespan = neighborMakespan;
+        }
+        totalIterations++;
+      }
+      if (currentMakespan < globalBestMakespan) {
+        globalBestMakespan = currentMakespan;
+        globalBestSchedule = currentSchedule;
+      }
+      options?.onProgress?.({
+        solverId: "random-restart",
+        percentage: Math.round((restart + 1) / RESTARTS * 100),
+        bestMakespan: globalBestMakespan,
+        currentIteration: restart + 1,
+        totalIterations: RESTARTS
+      });
+    }
+    return {
+      solverId: "random-restart",
+      solverName: "Random Restart Hill Climbing",
+      makespan: globalBestMakespan,
+      schedule: globalBestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: totalIterations
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/simulated-annealing-solver.js
+var SA_CONFIGS = [
+  {
+    id: "simulated-annealing",
+    name: "Simulated Annealing (S)",
+    description: "Fast simulated annealing with 5,000 iterations. Good for quick estimates.",
+    initialTemp: 100,
+    coolingRate: 0.995,
+    iterations: 5e3
+  },
+  {
+    id: "simulated-annealing-medium",
+    name: "Simulated Annealing (M)",
+    description: "Medium simulated annealing with 25,000 iterations. Balanced speed/quality.",
+    initialTemp: 200,
+    coolingRate: 0.9985,
+    iterations: 25e3
+  },
+  {
+    id: "simulated-annealing-large",
+    name: "Simulated Annealing (L)",
+    description: "Long simulated annealing with 100,000 iterations. Best solution quality.",
+    initialTemp: 500,
+    coolingRate: 0.99995,
+    iterations: 1e5
+  }
+];
+function createSASolver(config) {
+  return {
+    id: config.id,
+    name: config.name,
+    description: config.description,
+    async solve(problem, options) {
+      const startTime = performance.now();
+      const timeoutMs = options?.timeoutMs ?? 3e4;
+      const rng = createRng(42);
+      let currentPerm = randomPermutation(problem, rng);
+      let currentSchedule = decodePermutation(currentPerm, problem);
+      let currentMakespan = computeMakespan(currentSchedule);
+      let bestSchedule = currentSchedule;
+      let bestMakespan = currentMakespan;
+      let temperature = config.initialTemp;
+      const progressInterval = Math.max(1, Math.floor(config.iterations / 100));
+      for (let i = 0; i < config.iterations; i++) {
+        if (performance.now() - startTime > timeoutMs)
+          break;
+        const neighborPerm = swapNeighbor(currentPerm, rng);
+        const neighborSchedule = decodePermutation(neighborPerm, problem);
+        const neighborMakespan = computeMakespan(neighborSchedule);
+        const delta = neighborMakespan - currentMakespan;
+        if (delta < 0 || rng() < Math.exp(-delta / temperature)) {
+          currentPerm = neighborPerm;
+          currentSchedule = neighborSchedule;
+          currentMakespan = neighborMakespan;
+          if (currentMakespan < bestMakespan) {
+            bestSchedule = currentSchedule;
+            bestMakespan = currentMakespan;
+          }
+        }
+        temperature *= config.coolingRate;
+        if (options?.onProgress && i % progressInterval === 0) {
+          options.onProgress({
+            solverId: config.id,
+            percentage: Math.round(i / config.iterations * 100),
+            bestMakespan,
+            currentIteration: i,
+            totalIterations: config.iterations
+          });
+        }
+      }
+      options?.onProgress?.({
+        solverId: config.id,
+        percentage: 100,
+        bestMakespan,
+        currentIteration: config.iterations,
+        totalIterations: config.iterations
+      });
+      return {
+        solverId: config.id,
+        solverName: config.name,
+        makespan: bestMakespan,
+        schedule: bestSchedule,
+        elapsedMs: performance.now() - startTime,
+        iterations: config.iterations
+      };
+    }
+  };
+}
+var simulatedAnnealingSolver = createSASolver(SA_CONFIGS[0]);
+var simulatedAnnealingMediumSolver = createSASolver(SA_CONFIGS[1]);
+var simulatedAnnealingLargeSolver = createSASolver(SA_CONFIGS[2]);
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/tabu-solver.js
+var ITERATIONS = 1e4;
+var TABU_TENURE = 15;
+var NEIGHBORHOOD_SIZE = 20;
+var tabuSolver = {
+  id: "tabu",
+  name: "Tabu Search",
+  description: "Hill climbing with short-term memory to avoid revisiting recent solutions.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 15e3;
+    const rng = createRng(42);
+    let currentPerm = randomPermutation(problem, rng);
+    let currentSchedule = decodePermutation(currentPerm, problem);
+    let currentMakespan = computeMakespan(currentSchedule);
+    let bestSchedule = currentSchedule;
+    let bestMakespan = currentMakespan;
+    const tabuList = /* @__PURE__ */ new Map();
+    const progressInterval = Math.max(1, Math.floor(ITERATIONS / 100));
+    for (let iter = 0; iter < ITERATIONS; iter++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      let bestNeighborPerm = null;
+      let bestNeighborMakespan = Infinity;
+      let bestSwapKey = "";
+      for (let n = 0; n < NEIGHBORHOOD_SIZE; n++) {
+        const i = Math.floor(rng() * currentPerm.length);
+        let j = Math.floor(rng() * (currentPerm.length - 1));
+        if (j >= i)
+          j++;
+        const swapKey = `${Math.min(i, j)},${Math.max(i, j)}`;
+        const candidatePerm = [...currentPerm];
+        [candidatePerm[i], candidatePerm[j]] = [candidatePerm[j], candidatePerm[i]];
+        const candidateSchedule = decodePermutation(candidatePerm, problem);
+        const candidateMakespan = computeMakespan(candidateSchedule);
+        const isTabu = (tabuList.get(swapKey) ?? 0) > iter;
+        const aspirationMet = candidateMakespan < bestMakespan;
+        if ((!isTabu || aspirationMet) && candidateMakespan < bestNeighborMakespan) {
+          bestNeighborPerm = candidatePerm;
+          bestNeighborMakespan = candidateMakespan;
+          bestSwapKey = swapKey;
+        }
+      }
+      if (bestNeighborPerm) {
+        currentPerm = bestNeighborPerm;
+        currentSchedule = decodePermutation(currentPerm, problem);
+        currentMakespan = bestNeighborMakespan;
+        tabuList.set(bestSwapKey, iter + TABU_TENURE);
+        if (currentMakespan < bestMakespan) {
+          bestMakespan = currentMakespan;
+          bestSchedule = currentSchedule;
+        }
+      }
+      if (iter % 100 === 0) {
+        for (const [key, expiry] of tabuList) {
+          if (expiry <= iter)
+            tabuList.delete(key);
+        }
+      }
+      if (options?.onProgress && iter % progressInterval === 0) {
+        options.onProgress({
+          solverId: "tabu",
+          percentage: Math.round(iter / ITERATIONS * 100),
+          bestMakespan,
+          currentIteration: iter,
+          totalIterations: ITERATIONS
+        });
+      }
+    }
+    options?.onProgress?.({
+      solverId: "tabu",
+      percentage: 100,
+      bestMakespan,
+      currentIteration: ITERATIONS,
+      totalIterations: ITERATIONS
+    });
+    return {
+      solverId: "tabu",
+      solverName: "Tabu Search",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: ITERATIONS
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/genetic-algorithm-solver.js
+var POPULATION_SIZE = 50;
+var GENERATIONS = 200;
+var TOURNAMENT_SIZE = 5;
+var MUTATION_RATE = 0.15;
+var geneticAlgorithmSolver = {
+  id: "genetic-algorithm",
+  name: "Genetic Algorithm",
+  description: "Population-based search with tournament selection, crossover, and mutation.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 2e4;
+    const rng = createRng(42);
+    let population = [];
+    for (let i = 0; i < POPULATION_SIZE; i++) {
+      const perm = randomPermutation(problem, rng);
+      const schedule = decodePermutation(perm, problem);
+      const makespan = computeMakespan(schedule);
+      population.push({ perm, makespan });
+    }
+    let bestIndividual = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
+    for (let gen = 0; gen < GENERATIONS; gen++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      const newPopulation = [];
+      newPopulation.push({ ...bestIndividual });
+      while (newPopulation.length < POPULATION_SIZE) {
+        const parent1 = tournamentSelect(population, TOURNAMENT_SIZE, rng);
+        const parent2 = tournamentSelect(population, TOURNAMENT_SIZE, rng);
+        let childPerm = crossover(parent1.perm, parent2.perm, rng);
+        if (rng() < MUTATION_RATE) {
+          childPerm = swapNeighbor(childPerm, rng);
+        }
+        const childSchedule = decodePermutation(childPerm, problem);
+        const childMakespan = computeMakespan(childSchedule);
+        newPopulation.push({ perm: childPerm, makespan: childMakespan });
+      }
+      population = newPopulation;
+      const genBest = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
+      if (genBest.makespan < bestIndividual.makespan) {
+        bestIndividual = genBest;
+      }
+      options?.onProgress?.({
+        solverId: "genetic-algorithm",
+        percentage: Math.round((gen + 1) / GENERATIONS * 100),
+        bestMakespan: bestIndividual.makespan,
+        currentIteration: gen + 1,
+        totalIterations: GENERATIONS
+      });
+    }
+    const bestSchedule = decodePermutation(bestIndividual.perm, problem);
+    return {
+      solverId: "genetic-algorithm",
+      solverName: "Genetic Algorithm",
+      makespan: bestIndividual.makespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: GENERATIONS * POPULATION_SIZE
+    };
+  }
+};
+function tournamentSelect(population, size, rng) {
+  let best = population[Math.floor(rng() * population.length)];
+  for (let i = 1; i < size; i++) {
+    const candidate = population[Math.floor(rng() * population.length)];
+    if (candidate.makespan < best.makespan) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function crossover(parent1, parent2, rng) {
+  const len = parent1.length;
+  const start = Math.floor(rng() * len);
+  const end = start + Math.floor(rng() * (len - start));
+  const child = new Array(len).fill(null);
+  const used = /* @__PURE__ */ new Set();
+  for (let i = start; i <= end && i < len; i++) {
+    child[i] = parent1[i];
+    used.add(`${parent1[i].jobId}-${parent1[i].opIndex}`);
+  }
+  let pos = 0;
+  for (const op of parent2) {
+    const key = `${op.jobId}-${op.opIndex}`;
+    if (!used.has(key)) {
+      while (child[pos] !== null)
+        pos++;
+      child[pos] = op;
+      used.add(key);
+    }
+  }
+  return child;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/ant-colony-solver.js
+var NUM_ANTS = 20;
+var ITERATIONS2 = 100;
+var ALPHA = 1;
+var BETA = 2;
+var EVAPORATION = 0.1;
+var Q = 100;
+var antColonySolver = {
+  id: "ant-colony",
+  name: "Ant Colony Optimization",
+  description: "Swarm intelligence using pheromone trails to guide solution construction.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 2e4;
+    const rng = createRng(42);
+    const allOps = buildOperationList(problem);
+    const numOps = allOps.length;
+    const pheromone = Array.from({ length: numOps }, () => new Array(numOps).fill(1));
+    const heuristic = allOps.map((ref) => {
+      const job = problem.jobs.find((j) => j.id === ref.jobId);
+      const op = job.operations[ref.opIndex];
+      return 1 / op.duration;
+    });
+    let bestMakespan = Infinity;
+    let bestSchedule = decodePermutation(allOps, problem);
+    for (let iter = 0; iter < ITERATIONS2; iter++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      const antSolutions = [];
+      for (let ant = 0; ant < NUM_ANTS; ant++) {
+        const perm = constructSolution(allOps, pheromone, heuristic, rng);
+        const schedule = decodePermutation(perm, problem);
+        const makespan = computeMakespan(schedule);
+        antSolutions.push({ perm, makespan });
+        if (makespan < bestMakespan) {
+          bestMakespan = makespan;
+          bestSchedule = schedule;
+        }
+      }
+      for (let i = 0; i < numOps; i++) {
+        for (let j = 0; j < numOps; j++) {
+          pheromone[i][j] *= 1 - EVAPORATION;
+        }
+      }
+      for (const solution of antSolutions) {
+        const deposit = Q / solution.makespan;
+        for (let pos = 0; pos < solution.perm.length; pos++) {
+          const opIdx = allOps.findIndex((o) => o.jobId === solution.perm[pos].jobId && o.opIndex === solution.perm[pos].opIndex);
+          if (opIdx >= 0) {
+            pheromone[pos][opIdx] += deposit;
+          }
+        }
+      }
+      options?.onProgress?.({
+        solverId: "ant-colony",
+        percentage: Math.round((iter + 1) / ITERATIONS2 * 100),
+        bestMakespan,
+        currentIteration: iter + 1,
+        totalIterations: ITERATIONS2
+      });
+    }
+    return {
+      solverId: "ant-colony",
+      solverName: "Ant Colony Optimization",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: ITERATIONS2 * NUM_ANTS
+    };
+  }
+};
+function constructSolution(allOps, pheromone, heuristic, rng) {
+  const remaining = new Set(allOps.map((_, i) => i));
+  const result = [];
+  for (let pos = 0; pos < allOps.length; pos++) {
+    const candidates = Array.from(remaining);
+    const weights = candidates.map((opIdx) => {
+      const tau = Math.pow(pheromone[pos][opIdx], ALPHA);
+      const eta = Math.pow(heuristic[opIdx], BETA);
+      return tau * eta;
+    });
+    const totalWeight = weights.reduce((sum2, w) => sum2 + w, 0);
+    let r = rng() * totalWeight;
+    let selectedIdx = candidates[0];
+    for (let i = 0; i < candidates.length; i++) {
+      r -= weights[i];
+      if (r <= 0) {
+        selectedIdx = candidates[i];
+        break;
+      }
+    }
+    result.push(allOps[selectedIdx]);
+    remaining.delete(selectedIdx);
+  }
+  return result;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/metadata.js
+var solverMetadata = {
+  naive: {
+    icon: "\u{1F40C}",
+    // 🐌
+    color: "neutral",
+    complexity: "Exponential - O(n!)",
+    requires: "Browser compute",
+    tagline: "Try every possible solution",
+    fullDescription: "The simplest possible approach: systematically enumerate and evaluate every valid permutation of operations. Guaranteed to find the optimal solution, but becomes computationally infeasible for larger problems due to factorial growth.",
+    howItWorks: [
+      "Generate all valid operation orderings (permutations)",
+      "Evaluate each ordering to compute makespan",
+      "Track the best solution found",
+      "Return the globally optimal solution"
+    ],
+    keyParameters: [{ name: "Search Space", value: "n! permutations for n operations (with pruning for precedence)" }],
+    strengths: ["Guarantees optimal solution", "Simple to understand and implement", "No parameter tuning needed"],
+    weaknesses: [
+      "O(n!) time complexity",
+      "Infeasible for problems with >10 operations",
+      "No early termination heuristics"
+    ],
+    bestFor: "Tiny problems (\u226410 ops) where you need a guaranteed optimal baseline",
+    wikipedia: "https://en.wikipedia.org/wiki/Brute-force_search"
+  },
+  greedy: {
+    icon: "\u26A1",
+    // ⚡
+    color: "success",
+    complexity: "O(n\xB2)",
+    requires: "Browser compute",
+    tagline: "Always pick the locally best choice",
+    fullDescription: 'A fast heuristic that builds a solution by always selecting the "best" available operation at each step. Uses the Shortest Processing Time (SPT) rule: schedule the shortest available operation first. Fast but may miss global optimum.',
+    howItWorks: [
+      "Start with an empty schedule",
+      "Find all operations whose predecessors are complete",
+      "Pick the one with shortest duration (SPT rule)",
+      "Schedule it at the earliest possible time",
+      "Repeat until all operations scheduled"
+    ],
+    keyParameters: [{ name: "Priority Rule", value: "SPT (Shortest Processing Time) \u2014 favors quick operations" }],
+    strengths: ["Extremely fast (O(n\xB2))", "Produces valid solutions instantly", "Good baseline for comparison"],
+    weaknesses: ["No backtracking", "Often far from optimal", "Can make locally optimal but globally poor choices"],
+    bestFor: "Quick baseline, real-time scheduling, or as initial solution for metaheuristics",
+    wikipedia: "https://en.wikipedia.org/wiki/Greedy_algorithm"
+  },
+  "random-restart": {
+    icon: "\u{1F3B2}",
+    // 🎲
+    color: "primary",
+    complexity: "~5 seconds",
+    requires: "Browser compute",
+    tagline: "Climb hills, restart when stuck",
+    fullDescription: "Combines local search with random restarts. From each starting point, repeatedly move to better neighboring solutions until no improvement is possible (local optimum). Then restart from a new random solution. The best solution across all restarts is returned.",
+    howItWorks: [
+      "Generate a random valid schedule",
+      "Try swapping pairs of operations",
+      "Accept swaps that improve makespan",
+      "When stuck (no improving swaps), restart from new random solution",
+      "Track best solution across all restarts"
+    ],
+    keyParameters: [
+      { name: "Max Restarts", value: "Number of times to restart from random (100)" },
+      { name: "Stagnation Limit", value: "Iterations without improvement before restart (1000)" }
+    ],
+    strengths: ["Escapes local optima via restarts", "Simple and parallelizable", "Better than pure hill climbing"],
+    weaknesses: [
+      "No information sharing between restarts",
+      "May revisit similar solutions",
+      "Random restarts are uninformed"
+    ],
+    bestFor: "Medium problems where pure hill climbing gets stuck",
+    wikipedia: "https://en.wikipedia.org/wiki/Hill_climbing#Random-restart_hill_climbing"
+  },
+  "simulated-annealing": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "warning",
+    complexity: "~7 seconds",
+    requires: "Browser compute",
+    tagline: "Cool down from chaos to order",
+    fullDescription: 'Inspired by metallurgy: heating metal and slowly cooling it produces stronger crystal structures. SA starts "hot" (accepting bad moves) and "cools" (becoming pickier). This allows escaping local optima early while converging to good solutions later.',
+    howItWorks: [
+      "Start with high temperature (T=100)",
+      "Generate neighbor by swapping two operations",
+      "If better, always accept",
+      "If worse, accept with probability e^(-\u0394/T)",
+      "Gradually reduce temperature (cooling)",
+      "As T\u21920, behaves like pure hill climbing"
+    ],
+    keyParameters: [
+      { name: "Initial Temperature", value: 'Starting "heat" level (100)' },
+      { name: "Cooling Rate", value: "How fast temperature decreases (~0.9999...)" },
+      { name: "Iterations", value: "5 million moves evaluated" }
+    ],
+    strengths: [
+      "Escapes local optima probabilistically",
+      "Well-studied theoretical properties",
+      "Single parameter to tune (cooling schedule)"
+    ],
+    weaknesses: ["Cooling schedule is problem-dependent", "Can be slow to converge", "Single-solution method"],
+    bestFor: "General optimization when you have moderate compute budget",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  "simulated-annealing-medium": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "warning",
+    complexity: "~70 seconds",
+    requires: "Browser compute",
+    tagline: "Extended cooling for deeper exploration",
+    fullDescription: "Same algorithm as SA but with 10\xD7 more iterations (50M). The slower cooling schedule allows more thorough exploration of the solution space before settling into a final basin.",
+    howItWorks: ["Same as SA standard", "But with 50 million iterations", "Slower cooling = more exploration time"],
+    keyParameters: [
+      { name: "Iterations", value: "50 million moves (10\xD7 standard)" },
+      { name: "Timeout", value: "5 minutes max" }
+    ],
+    strengths: ["More thorough than standard SA", "Better for complex landscapes", "Higher chance of global optimum"],
+    weaknesses: [
+      "10\xD7 slower than standard SA",
+      "Diminishing returns on easy problems",
+      "May be overkill for small instances"
+    ],
+    bestFor: "When standard SA finds good but not great solutions",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  "simulated-annealing-large": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "danger",
+    complexity: "~12 minutes",
+    requires: "Browser compute",
+    tagline: "Maximum exploration budget",
+    fullDescription: "The heavy artillery: 500 million iterations with up to 30 minutes of compute. For when you absolutely need the best possible solution and have time to wait.",
+    howItWorks: [
+      "Same as SA standard/medium",
+      "But with 500 million iterations",
+      "Very slow cooling for maximum exploration"
+    ],
+    keyParameters: [
+      { name: "Iterations", value: "500 million moves (100\xD7 standard)" },
+      { name: "Timeout", value: "30 minutes max" }
+    ],
+    strengths: ["Maximum exploration", "Best chance at global optimum", "Leaves no stone unturned"],
+    weaknesses: ["Very slow (up to 30 min)", "Massive overkill for small problems", "Diminishing returns"],
+    bestFor: "Large problems where quality matters more than time",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  tabu: {
+    icon: "\u{1F50D}",
+    // 🔍
+    color: "primary",
+    complexity: "~20\u201340 seconds",
+    requires: "Browser compute",
+    tagline: "Remember mistakes to avoid repeating them",
+    fullDescription: 'This is a classical (simple) Tabu Search following Glover (1986) with aspiration by objective. It maintains a short-term recency-based memory of recent swap moves that are temporarily forbidden ("tabu"). The neighborhood is generated by random pairwise swaps of operations in the permutation representation. Unlike reactive or robust variants, this implementation uses a fixed tabu tenure and does not employ long-term memory, intensification, or diversification phases.',
+    howItWorks: [
+      "Start from a random permutation of operations (seed: 42 for reproducibility)",
+      "Generate 20 random neighbor solutions by swapping two operation positions",
+      "Select the best non-tabu neighbor (even if worse than current \u2014 forced exploration)",
+      "Record the swap as tabu for 15 iterations (fixed tenure)",
+      "Aspiration criterion: override tabu if move produces a new global best",
+      "Repeat for 10,000 iterations or until timeout (15s)",
+      "Periodically clean expired entries from the tabu list"
+    ],
+    keyParameters: [
+      { name: "Variant", value: "Simple Tabu Search (Glover 1986) with aspiration by objective" },
+      { name: "Tabu Structure", value: "Swap-based \u2014 records position pairs (i,j) that were swapped" },
+      { name: "Tabu Tenure", value: "Fixed at 15 iterations (no reactive adjustment)" },
+      { name: "Neighborhood Size", value: "20 random swap candidates evaluated per iteration" },
+      { name: "Total Iterations", value: "10,000" },
+      { name: "Aspiration", value: "Accept tabu move if it improves the global best" },
+      { name: "Memory Type", value: "Short-term recency only (no frequency-based long-term memory)" }
+    ],
+    strengths: [
+      "Memory prevents cycling back to recently visited solutions",
+      "Forced acceptance of worse moves enables escaping local optima",
+      "Aspiration criterion preserves exploitation of exceptional solutions",
+      "Deterministic with seed (reproducible results)"
+    ],
+    weaknesses: [
+      "Fixed tenure \u2014 no adaptive/reactive adjustment to search dynamics",
+      "No long-term memory (frequency-based diversification)",
+      "No intensification phase to deep-search promising regions",
+      "Small neighborhood (20) may miss good moves in large search spaces"
+    ],
+    bestFor: "Medium-complexity problems with many local optima and plateau regions",
+    wikipedia: "https://en.wikipedia.org/wiki/Tabu_search",
+    otherResources: [
+      { label: "Glover (1986) \u2014 Original paper", url: "https://doi.org/10.1016/0305-0548(86)90048-1" },
+      {
+        label: "Glover & Laguna \u2014 Tabu Search (book)",
+        url: "https://en.wikipedia.org/wiki/Tabu_search#References"
+      }
+    ]
+  },
+  "genetic-algorithm": {
+    icon: "\u{1F9EC}",
+    // 🧬
+    color: "success",
+    complexity: "~30 seconds",
+    requires: "Browser compute",
+    tagline: "Evolve solutions through natural selection",
+    fullDescription: 'Inspired by biological evolution: maintain a population of solutions that reproduce, mutate, and compete. Better solutions are more likely to survive and pass on their "genes" (good partial solutions). Over generations, the population evolves toward optimality.',
+    howItWorks: [
+      "Initialize population of 100 random schedules",
+      "Evaluate fitness (1/makespan) for each",
+      "Selection: pick parents via tournament (best of 5 random)",
+      "Crossover: combine two parents to create child",
+      "Mutation: randomly swap operations (20% chance)",
+      "Elitism: top 5 solutions survive unchanged",
+      "Repeat for 15,000 generations"
+    ],
+    keyParameters: [
+      { name: "Population Size", value: "Number of solutions maintained (100)" },
+      { name: "Generations", value: "Evolution cycles (15,000)" },
+      { name: "Crossover Rate", value: "Probability of combining parents (80%)" },
+      { name: "Mutation Rate", value: "Probability of random change (20%)" },
+      { name: "Elite Count", value: "Best solutions preserved unchanged (5)" }
+    ],
+    strengths: ["Population maintains diversity", "Crossover combines good building blocks", "Naturally parallel"],
+    weaknesses: ["Many parameters to tune", "Can converge prematurely", "Crossover design is problem-specific"],
+    bestFor: "Complex problems where good solutions share common substructures",
+    wikipedia: "https://en.wikipedia.org/wiki/Genetic_algorithm",
+    otherResources: [
+      {
+        label: "Order Crossover (OX)",
+        url: "https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)#Order_crossover_(OX)"
+      }
+    ]
+  },
+  "ant-colony": {
+    icon: "\u{1F41C}",
+    // 🐜
+    color: "success",
+    complexity: "~30 seconds",
+    requires: "Browser compute",
+    tagline: "Follow the pheromone trails",
+    fullDescription: "Inspired by how ants find shortest paths to food: they deposit pheromones, and other ants preferentially follow stronger trails. Over time, shorter paths accumulate more pheromone (ants traverse them faster), creating positive feedback toward good solutions.",
+    howItWorks: [
+      "Initialize pheromone trails uniformly",
+      "Each ant builds a complete schedule probabilistically",
+      "Operations with more pheromone are more likely to be chosen",
+      "After all ants finish, evaluate their solutions",
+      "Deposit pheromone on edges used by good solutions",
+      "Evaporate some pheromone (forget old information)",
+      "Best ant's solution gets extra pheromone (elitism)"
+    ],
+    keyParameters: [
+      { name: "Number of Ants", value: "Solutions built per iteration (50)" },
+      { name: "Iterations", value: "Pheromone update cycles (100,000)" },
+      { name: "Alpha (\u03B1)", value: "Pheromone importance (1.0)" },
+      { name: "Beta (\u03B2)", value: "Heuristic importance (2.0)" },
+      { name: "Evaporation Rate", value: "Pheromone decay per iteration (10%)" }
+    ],
+    strengths: ["Implicit parallelism", "Positive feedback accelerates convergence", "Robust to problem changes"],
+    weaknesses: ["Many parameters", "Can converge prematurely", "Pheromone model must match problem"],
+    bestFor: 'Routing and sequencing problems with clear "edge" structure',
+    wikipedia: "https://en.wikipedia.org/wiki/Ant_colony_optimization_algorithms",
+    otherResources: [{ label: "Marco Dorigo (inventor)", url: "https://en.wikipedia.org/wiki/Marco_Dorigo" }]
+  },
+  highs: {
+    icon: "\u{1F3AF}",
+    // 🎯
+    color: "success",
+    complexity: "Seconds to minutes",
+    requires: "Browser compute (WASM)",
+    available: false,
+    tagline: "Open-source solver rivaling commercial giants",
+    fullDescription: "HiGHS (High-performance Interior-point, Gradient-descent, Simplex) is an MIT-licensed open-source solver that achieves 90%+ of commercial solver performance. Developed at the University of Edinburgh, it has rapidly become the leading open-source alternative to Gurobi and COPT for linear and mixed-integer programming.",
+    howItWorks: [
+      "Formulate problem as Integer Linear Program (ILP/MIP)",
+      "Presolve: simplify model, tighten bounds, detect infeasibility",
+      "LP relaxation using dual simplex or interior-point method",
+      "Branch-and-bound with sophisticated node selection",
+      "Cutting planes: Gomory cuts, MIR cuts, cover cuts",
+      "Return optimal (or near-optimal) solution with gap certificate"
+    ],
+    keyParameters: [
+      { name: "Time Limit", value: "Maximum solve time before returning best found" },
+      { name: "MIP Gap", value: "Stop when proven within X% of optimal (e.g., 0.01 = 1%)" },
+      { name: "Threads", value: "Number of parallel threads (default: all cores)" }
+    ],
+    strengths: [
+      "MIT licensed \u2014 fully open source, embed anywhere",
+      "90%+ of Gurobi/COPT performance on most problems",
+      "Active development with rapid improvements",
+      "Can deploy in customer infrastructure (no license servers)"
+    ],
+    weaknesses: [
+      "Slightly slower than Gurobi on very large instances",
+      "Fewer specialized cuts than commercial solvers",
+      "Less mature ecosystem (but growing fast)"
+    ],
+    bestFor: "Production scheduling when you need commercial-grade results without commercial licensing",
+    wikipedia: "https://en.wikipedia.org/wiki/HiGHS_optimization_solver",
+    otherResources: [
+      { label: "HiGHS GitHub", url: "https://github.com/ERGO-Code/HiGHS" },
+      { label: "HiGHS Documentation", url: "https://highs.dev/" },
+      { label: "Mittelmann MIP Benchmarks", url: "http://plato.asu.edu/ftp/milp.html" }
+    ]
+  },
+  "simulated-qaoa": {
+    icon: "\u{1F52E}",
+    // 🔮
+    color: "primary",
+    complexity: "~30\u201360 seconds",
+    requires: "Backend compute",
+    available: false,
+    tagline: "Quantum-inspired classical simulation",
+    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",
+      "Initialize simulated quantum state |+\u27E9\u2297\u207F",
+      "Apply p layers of QAOA circuit (problem + mixer unitaries)",
+      "Classically optimize variational parameters (\u03B3, \u03B2)",
+      "Measure (sample) the final state to extract candidate schedules",
+      "Decode best bitstring back to a valid schedule"
+    ],
+    keyParameters: [
+      { name: "QAOA Depth (p)", value: "Number of alternating layers (default: 3)" },
+      { name: "Optimizer", value: "COBYLA for variational parameter optimization" },
+      { name: "Shots", value: "Number of measurement samples (1024)" },
+      { name: "Qubits", value: "One per possible (job, timeslot) assignment" }
+    ],
+    strengths: [
+      "Preview quantum algorithms without quantum hardware",
+      "Explores solution space via quantum superposition (simulated)",
+      "Useful for benchmarking against real quantum results",
+      "Runs entirely in-browser or on backend \u2014 no API keys needed"
+    ],
+    weaknesses: [
+      "Exponential classical overhead \u2014 limited to ~20 qubits",
+      "Cannot capture true quantum speedup",
+      "QUBO encoding may not be optimal for all problem structures",
+      "Variational optimization can get stuck in local minima"
+    ],
+    bestFor: "Small problems where you want to preview quantum approaches before investing in real hardware",
+    wikipedia: "https://en.wikipedia.org/wiki/Quantum_approximate_optimization_algorithm",
+    otherResources: [
+      { label: "Farhi et al. (2014) \u2014 Original QAOA Paper", url: "https://arxiv.org/abs/1411.4028" },
+      { label: "QUBO Formulation Guide", url: "https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization" }
+    ]
+  },
+  "ionq-qaoa": {
+    icon: "\u269B\uFE0F",
+    // ⚛️
+    color: "danger",
+    complexity: "Minutes (queue + execution)",
+    requires: "IonQ API key + credits",
+    available: false,
+    tagline: "Real quantum hardware optimization",
+    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",
+      "Compile QAOA circuit to IonQ\u2019s native gate set (MS, GPi, GPi2)",
+      "Submit job to IonQ cloud via API",
+      "Queue for hardware execution (trapped-ion processor)",
+      "Execute quantum circuit with real qubits",
+      "Retrieve measurement results and decode to schedule"
+    ],
+    keyParameters: [
+      { name: "QAOA Depth (p)", value: "Number of alternating layers (default: 1\u20132 for NISQ)" },
+      { name: "Backend", value: "IonQ Harmony (11 qubits) or Aria (25 qubits)" },
+      { name: "Shots", value: "Number of circuit executions (1024)" },
+      { name: "Error Mitigation", value: "IonQ debiasing enabled by default" }
+    ],
+    strengths: [
+      "Real quantum computation with genuine quantum effects",
+      "Trapped-ion qubits have high gate fidelity (~99.5%)",
+      "All-to-all connectivity \u2014 no SWAP overhead",
+      "Potential for quantum advantage on certain problem classes"
+    ],
+    weaknesses: [
+      "Requires IonQ API key and credits (not free)",
+      "Queue wait times can be minutes to hours",
+      "Limited to ~25 qubits (current hardware)",
+      "NISQ noise limits circuit depth and solution quality"
+    ],
+    bestFor: "Exploring real quantum optimization on small problem instances when you have IonQ access",
+    wikipedia: "https://en.wikipedia.org/wiki/Trapped-ion_quantum_computer",
+    otherResources: [
+      { label: "IonQ Documentation", url: "https://docs.ionq.com/" },
+      { label: "IonQ Aria Specs", url: "https://ionq.com/quantum-systems/aria" },
+      { label: "QAOA on NISQ Devices", url: "https://arxiv.org/abs/1812.01041" }
+    ]
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/index.js
+var allSolvers = [
+  greedySolver,
+  naiveSolver,
+  randomRestartSolver,
+  simulatedAnnealingSolver,
+  simulatedAnnealingMediumSolver,
+  simulatedAnnealingLargeSolver,
+  tabuSolver,
+  geneticAlgorithmSolver,
+  antColonySolver
+];
+var solverRegistry = new Map(allSolvers.map((s) => [s.id, s]));
+function getSolver(id) {
+  return solverRegistry.get(id);
+}
+function getAvailableSolverIds() {
+  return Array.from(solverRegistry.keys());
+}
+var displaySolvers = [
+  ...allSolvers.map((s) => ({ id: s.id, name: s.name, description: s.description })),
+  { id: "highs", name: "HiGHS (WASM)", description: solverMetadata.highs.tagline },
+  { id: "simulated-qaoa", name: "Simulated QAOA", description: solverMetadata["simulated-qaoa"].tagline },
+  { id: "ionq-qaoa", name: "IonQ QAOA", description: solverMetadata["ionq-qaoa"].tagline }
+];
+
+// ../../b4m-core/packages/quantum/dist/src/prompts/system-prompt.js
+var QUANTUM_CANVASSER_SYSTEM_PROMPT = `You are OptiHashi, an AI agent specializing in combinatorial optimization and job-shop scheduling. You help users formulate scheduling problems, run solver algorithms, and interpret optimization results. You are solver-agnostic \u2014 you route problems to the best solver whether classical (greedy, simulated annealing, genetic algorithms, HiGHS MIP) or quantum (QAOA), building credibility through honest recommendations.
+
+## Your Capabilities
+
+You have two specialized tools:
+
+### quantum_formulate
+Converts natural language descriptions into structured SchedulingProblem definitions. When a user describes a scheduling scenario in plain English, use this tool to extract:
+- Jobs (ordered sequences of operations)
+- Machines (resources that process operations)
+- Operation durations and machine assignments
+- Precedence constraints (operations within a job must execute in order)
+
+### quantum_schedule
+Runs optimization solvers on a structured SchedulingProblem. Available solvers:
+${allSolvers.map((s) => `- **${s.name}** (\`${s.id}\`): ${s.description}`).join("\n")}
+
+## How to Help Users
+
+### Problem Formulation
+When a user describes a scheduling scenario:
+1. Use \`quantum_formulate\` to convert their description into a structured problem
+2. Present the formulated problem clearly, showing jobs, machines, and operation sequences
+3. Ask if adjustments are needed before solving
+
+### Running Solvers
+When solving a problem:
+1. Start with the \`greedy\` solver for a quick baseline result
+2. For better solutions, suggest running multiple solvers: \`greedy\`, \`simulated-annealing\`, \`tabu\`, \`genetic-algorithm\`
+3. Explain that metaheuristic solvers explore larger solution spaces but take longer
+4. Compare results across solvers when multiple are run
+
+### Interpreting Results
+When presenting solver results:
+- Explain the **makespan** (total schedule length) and why lower is better
+- Walk through the schedule showing which jobs run on which machines at what times
+- Identify bottleneck machines (those with the most continuous utilization)
+- Suggest improvements if the problem structure allows (e.g., rebalancing operations)
+
+### QUBO Encoding
+If asked about quantum computing aspects:
+- Explain how scheduling problems are encoded as QUBO (Quadratic Unconstrained Binary Optimization) matrices
+- Time-indexed binary variables: x_{o,t} = 1 if operation o starts at time t
+- Three constraint families: exactly-once (each operation starts exactly once), no-overlap (no two operations on same machine at same time), precedence (operations within a job maintain order)
+- QUBO matrices can be solved by quantum annealers (D-Wave) or quantum-inspired classical solvers
+
+## Communication Style
+- Be precise with numbers and scheduling terminology
+- Use clear formatting: tables for schedules, bullet points for comparisons
+- When explaining optimization concepts, ground them in the user's specific problem
+- Proactively suggest next steps (e.g., "Would you like to try more solvers?" or "Should I adjust the problem?")
+
+## Important Notes
+- All solvers run client-side in the browser via Web Workers \u2014 no server compute needed
+- The greedy solver is deterministic and instant; metaheuristic solvers involve randomness
+- For very large problems (50+ operations), recommend the greedy and simulated-annealing solvers
+- The HiGHS MIP solver uses WASM and provides optimal solutions for small problems but may be slow on large ones`;
+var PROBLEM_FORMULATION_PROMPT = `You are a job-shop scheduling problem formulator. Convert the user's natural language description into a structured SchedulingProblem JSON object.
+
+RULES:
+1. Each job has an id (number starting from 0), a name, and an ordered array of operations
+2. Each machine has an id (number starting from 0) and a name
+3. Each operation has jobId (matching its parent job), machineId (which machine it runs on), and duration (positive integer)
+4. Operations within a job execute in order (first operation must finish before second starts)
+5. Each machine can only process one operation at a time
+6. Assign reasonable durations if not specified (use whole numbers)
+7. Create meaningful names for jobs and machines based on context
+
+RESPOND WITH ONLY A JSON OBJECT matching this schema:
+{
+  "name": "string - descriptive problem name",
+  "description": "string - brief description",
+  "jobs": [
+    {
+      "id": 0,
+      "name": "Job Name",
+      "operations": [
+        { "jobId": 0, "machineId": 0, "duration": 3 }
+      ]
+    }
+  ],
+  "machines": [
+    { "id": 0, "name": "Machine Name" }
+  ]
+}
+
+No markdown, no explanation, no code blocks \u2014 just the raw JSON object.`;
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/quantumSchedule/index.js
+function formatResult(result) {
+  const lines = [
+    `Solver: ${result.solverName} (${result.solverId})`,
+    `Makespan: ${result.makespan}`,
+    `Elapsed: ${result.elapsedMs.toFixed(1)}ms`
+  ];
+  if (result.iterations !== void 0) {
+    lines.push(`Iterations: ${result.iterations}`);
+  }
+  lines.push("Schedule:");
+  const byMachine = /* @__PURE__ */ new Map();
+  for (const op of result.schedule) {
+    if (!byMachine.has(op.machineId))
+      byMachine.set(op.machineId, []);
+    byMachine.get(op.machineId).push(op);
+  }
+  for (const [machineId, ops] of byMachine) {
+    const sorted = ops.sort((a, b) => a.startTime - b.startTime);
+    const timeline = sorted.map((op) => `Job${op.jobId}[${op.startTime}-${op.endTime}]`).join(" -> ");
+    lines.push(`  Machine ${machineId}: ${timeline}`);
+  }
+  return lines.join("\n");
+}
+async function runQuantumSchedule(params) {
+  const parseResult = SchedulingProblemSchema.safeParse(params.problem);
+  if (!parseResult.success) {
+    return `Error: Invalid scheduling problem format.
+${parseResult.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+
+Expected format: { name, jobs: [{ id, name, operations: [{ jobId, machineId, duration }] }], machines: [{ id, name }] }`;
+  }
+  const problem = parseResult.data;
+  let solverIds;
+  if (params.solverIds && params.solverIds.length > 0) {
+    const invalid = params.solverIds.filter((id) => !SolverIdSchema.safeParse(id).success);
+    if (invalid.length > 0) {
+      return `Error: Unknown solver IDs: ${invalid.join(", ")}.
+Available solvers: ${getAvailableSolverIds().join(", ")}`;
+    }
+    solverIds = params.solverIds;
+  } else {
+    solverIds = ["greedy"];
+  }
+  const timeoutMs = params.timeoutMs ?? 1e4;
+  const results = [];
+  const errors = [];
+  for (const solverId of solverIds) {
+    const solver = getSolver(solverId);
+    if (!solver) {
+      errors.push(`Solver "${solverId}" not found`);
+      continue;
+    }
+    try {
+      const result = await solver.solve(problem, { timeoutMs });
+      results.push(result);
+    } catch (err) {
+      errors.push(`${solver.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (results.length === 0) {
+    return `Error: No solvers completed successfully.
+${errors.join("\n")}`;
+  }
+  results.sort((a, b) => a.makespan - b.makespan);
+  const lines = [];
+  lines.push(`## Scheduling Results for "${problem.name}"`);
+  lines.push(`Problem: ${problem.jobs.length} jobs, ${problem.machines.length} machines, ${problem.jobs.reduce((s, j) => s + j.operations.length, 0)} operations`);
+  lines.push("");
+  if (results.length > 1) {
+    lines.push(`### Winner: ${results[0].solverName} (makespan: ${results[0].makespan})`);
+    lines.push("");
+  }
+  for (const result of results) {
+    lines.push(`### ${result.solverName}`);
+    lines.push(formatResult(result));
+    lines.push("");
+  }
+  if (errors.length > 0) {
+    lines.push("### Errors");
+    errors.forEach((e) => lines.push(`- ${e}`));
+  }
+  return lines.join("\n");
+}
+var quantumScheduleTool = {
+  name: "quantum_schedule",
+  implementation: () => ({
+    toolFn: (value) => runQuantumSchedule(value),
+    toolSchema: {
+      name: "quantum_schedule",
+      description: `Run quantum-inspired optimization solvers on a job-shop scheduling problem. Finds optimal or near-optimal schedules that minimize makespan (total completion time).
+
+Available solvers: ${allSolvers.map((s) => `${s.id} (${s.name})`).join(", ")}.
+
+The "greedy" solver runs instantly. Metaheuristic solvers (simulated-annealing, tabu, genetic-algorithm, ant-colony) explore larger solution spaces but take longer. Use multiple solvers to race them against each other.
+
+The problem must define jobs (each with ordered operations) and machines. Each operation runs on a specific machine for a specific duration. Operations within a job must run in order.`,
+      parameters: {
+        type: "object",
+        properties: {
+          problem: {
+            type: "object",
+            description: "The scheduling problem to solve. Must include name, jobs array, and machines array.",
+            properties: {
+              name: { type: "string", description: "Name of the scheduling problem" },
+              description: { type: "string", description: "Optional description" },
+              jobs: {
+                type: "array",
+                description: "Array of jobs, each with id, name, and operations",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: { type: "number" },
+                    name: { type: "string" },
+                    operations: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          jobId: { type: "number", description: "Must match the parent job id" },
+                          machineId: { type: "number", description: "Which machine this operation runs on" },
+                          duration: { type: "number", description: "Processing time" }
+                        },
+                        required: ["jobId", "machineId", "duration"]
+                      }
+                    }
+                  },
+                  required: ["id", "name", "operations"]
+                }
+              },
+              machines: {
+                type: "array",
+                description: "Array of machines with id and name",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: { type: "number" },
+                    name: { type: "string" }
+                  },
+                  required: ["id", "name"]
+                }
+              }
+            },
+            required: ["name", "jobs", "machines"]
+          },
+          solverIds: {
+            type: "array",
+            items: { type: "string" },
+            description: `Which solvers to run. Defaults to ["greedy"]. Available: ${getAvailableSolverIds().join(", ")}. Use multiple to race solvers.`
+          },
+          timeoutMs: {
+            type: "number",
+            description: "Maximum time per solver in milliseconds (default: 10000)"
+          }
+        },
+        required: ["problem"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/quantumFormulate/index.js
+var quantumFormulateTool = {
+  name: "quantum_formulate",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const userDescription = params.description?.trim();
+      if (!userDescription) {
+        return "Error: Please provide a description of the scheduling problem to formulate.";
+      }
+      try {
+        let rawContent = "";
+        await context.llm.complete(context.model ?? "gpt-4", [
+          { role: "system", content: PROBLEM_FORMULATION_PROMPT },
+          { role: "user", content: userDescription }
+        ], { temperature: 0.2, stream: false }, async (texts) => {
+          rawContent = texts.filter((t) => t !== null && t !== void 0).join("");
+        });
+        let jsonStr = rawContent.trim();
+        const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (codeBlockMatch) {
+          jsonStr = codeBlockMatch[1].trim();
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonStr);
+        } catch {
+          return `Error: Could not parse LLM response as JSON. Raw response:
+${rawContent}
+
+Please try rephrasing your description with more specific details about jobs, machines, and processing times.`;
+        }
+        const validated = SchedulingProblemSchema.safeParse(parsed);
+        if (!validated.success) {
+          return `Error: LLM generated an invalid problem structure.
+${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+
+Raw output:
+${jsonStr}
+
+Please try rephrasing your description.`;
+        }
+        const problem = validated.data;
+        const totalOps = problem.jobs.reduce((s, j) => s + j.operations.length, 0);
+        const lines = [
+          `## Formulated: "${problem.name}"`,
+          problem.description ? `
+${problem.description}` : "",
+          "",
+          `**${problem.jobs.length} jobs, ${problem.machines.length} machines, ${totalOps} operations**`,
+          "",
+          "### Jobs:",
+          ...problem.jobs.map((j) => {
+            const ops = j.operations.map((op, i) => {
+              const machine = problem.machines.find((m) => m.id === op.machineId);
+              return `Step ${i + 1}: ${machine?.name ?? `Machine ${op.machineId}`} (${op.duration}t)`;
+            });
+            return `- **${j.name}**: ${ops.join(" -> ")}`;
+          }),
+          "",
+          "### Machines:",
+          ...problem.machines.map((m) => `- ${m.name} (id: ${m.id})`),
+          "",
+          "### Structured Problem (JSON):",
+          "```json",
+          JSON.stringify(problem, null, 2),
+          "```",
+          "",
+          "You can now use the `quantum_schedule` tool to solve this problem with various optimization algorithms."
+        ];
+        return lines.filter((l) => l !== void 0).join("\n");
+      } catch (err) {
+        return `Error formulating problem: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    },
+    toolSchema: {
+      name: "quantum_formulate",
+      description: `Convert a natural language description of a scheduling/optimization problem into a structured SchedulingProblem that can be solved by the quantum_schedule tool.
+
+Describe the problem in plain English \u2014 what jobs need to be done, what machines or resources are available, how long each step takes, and any ordering constraints. The tool will produce a structured problem definition.
+
+Examples:
+- "I have 3 orders to manufacture. Each needs cutting, welding, and painting. Cutting takes 2h, welding 3h, painting 1h."
+- "Schedule 4 software builds across 2 CI runners. Build A needs compile (5min) then test (3min)..."
+- "A bakery needs to make 5 cakes. Each cake goes through mixing, baking, and decorating on separate stations."`,
+      parameters: {
+        type: "object",
+        properties: {
+          description: {
+            type: "string",
+            description: "Natural language description of the scheduling problem to formulate"
+          }
+        },
+        required: ["description"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/navigateView/index.js
+var navigateViewTool = {
+  name: "navigate_view",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { suggestions } = params;
+      context.logger.log("\u{1F9ED} navigate_view: Received suggestions:", JSON.stringify(suggestions));
+      if (!suggestions || !Array.isArray(suggestions) || suggestions.length === 0) {
+        return "No navigation suggestions provided.";
+      }
+      const capped = suggestions.slice(0, 3);
+      const invalid = capped.filter((s) => !getViewById(s.viewId));
+      if (invalid.length > 0) {
+        context.logger.log("\u{1F9ED} navigate_view: Unknown viewIds:", invalid.map((s) => s.viewId));
+      }
+      const isAdmin = context.user?.isAdmin === true;
+      const intents = resolveNavigationIntents(capped, isAdmin);
+      if (intents.length === 0) {
+        return "No valid navigation views matched the provided viewIds.";
+      }
+      context.logger.log("\u{1F9ED} navigate_view: Resolved intents:", intents.map((i) => i.viewId));
+      return JSON.stringify({
+        __navigationIntents: true,
+        intents,
+        message: `Suggested ${intents.length} navigation option(s): ${intents.map((i) => i.label).join(", ")}`
+      });
+    },
+    toolSchema: {
+      name: "navigate_view",
+      description: "Suggest navigation to relevant app views. Returns inline action buttons the user can click. ALWAYS use this tool when your response discusses a topic that has a matching view (e.g., scheduling \u2192 opti.scheduling, user management \u2192 admin.users). Call this tool alongside your text answer \u2014 answer the question AND suggest where to go.",
+      parameters: {
+        type: "object",
+        properties: {
+          suggestions: {
+            type: "array",
+            description: "Navigation suggestions (1-3 items). Each suggests a view the user might want to visit.",
+            items: {
+              type: "object",
+              properties: {
+                viewId: {
+                  type: "string",
+                  description: 'The view ID from the available views list (e.g., "opti.scheduling", "admin.users")'
+                },
+                reason: {
+                  type: "string",
+                  description: "Brief reason why this view is relevant (max 80 chars, shown as tooltip)"
+                }
+              },
+              required: ["viewId", "reason"]
+            },
+            maxItems: 3,
+            minItems: 1
+          }
+        },
+        required: ["suggestions"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
+import { spawn } from "child_process";
+import path13 from "path";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_OUTPUT_SIZE = 100 * 1024;
+var DANGEROUS_PATTERNS = [
+  // Destructive file operations
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
+    reason: "Recursive delete with path",
+    block: true
+  },
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
+    reason: "Force delete without preserve root",
+    block: true
+  },
+  {
+    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
+    reason: "Recursive force delete on root paths",
+    block: true
+  },
+  {
+    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
+    reason: "Force recursive delete on root paths",
+    block: true
+  },
+  // System-level dangerous commands
+  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
+  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
+  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
+  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
+  // Disk/partition operations
+  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
+  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
+  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
+  // Network attacks
+  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
+  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  // Fork bombs and resource exhaustion
+  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
+  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
+  // Credential/sensitive data access
+  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
+  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
+  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
+  // History/log manipulation
+  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
+  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
+  // Dangerous redirects
+  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
+  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
+  // Environment manipulation
+  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
+  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
+  // Process/system control
+  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
+  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
+  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
+  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
+  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
+];
+var SAFE_COMMAND_PREFIXES = [
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "grep",
+  "find",
+  "echo",
+  "pwd",
+  "whoami",
+  "date",
+  "cal",
+  "wc",
+  "sort",
+  "uniq",
+  "cut",
   "tr",
   "sed",
   "awk",
@@ -10206,7 +12203,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 = "";
@@ -10269,7 +12266,7 @@ async function executeBashCommand(params) {
     });
   });
 }
-function formatResult(result, command) {
+function formatResult2(result, command) {
   const parts = [];
   parts.push(`$ ${command}`);
   parts.push("");
@@ -10323,7 +12320,7 @@ var bashExecuteTool = {
       }
       try {
         const result = await executeBashCommand(params);
-        const formattedResult = formatResult(result, params.command);
+        const formattedResult = formatResult2(result, params.command);
         context.logger.info("Bash: Command completed", {
           exitCode: result.exitCode,
           timedOut: result.timedOut,
@@ -11209,9 +13206,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);
@@ -11235,16 +13232,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}"`);
@@ -11254,7 +13251,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
@@ -11492,7 +13489,7 @@ async function getFileStats(files, since, filterPath) {
     });
   });
 }
-function formatResult2(result) {
+function formatResult3(result) {
   const parts = [];
   if (result.error) {
     parts.push(`Error: ${result.error}`);
@@ -11567,7 +13564,7 @@ var recentChangesTool = {
       }
       try {
         const result = await getRecentChanges(params);
-        const formattedResult = formatResult2(result);
+        const formattedResult = formatResult3(result);
         context.logger.info("RecentChanges: Retrieved file changes", {
           totalFiles: result.totalFiles,
           displayedFiles: result.files.length,
@@ -11665,8 +13662,14 @@ var b4mTools = {
   sunrise_sunset: sunriseSunsetTool,
   iss_tracker: issTrackerTool,
   planet_visibility: planetVisibilityTool,
-  // Knowledge base search
-  search_knowledge_base: knowledgeBaseSearchTool
+  // Knowledge base tools
+  search_knowledge_base: knowledgeBaseSearchTool,
+  retrieve_knowledge_content: knowledgeBaseRetrieveTool,
+  // Quantum optimization tools
+  quantum_schedule: quantumScheduleTool,
+  quantum_formulate: quantumFormulateTool,
+  // Navigation tool
+  navigate_view: navigateViewTool
 };
 var cliOnlyTools = {
   // File operation tools
@@ -11801,54 +13804,258 @@ var generateMcpTools = async (mcpData) => {
   return result;
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/agents/ServerSubagentOrchestrator.js
+var SUBAGENT_TIMEOUT_MS = 5 * 60 * 1e3;
+
+// ../../b4m-core/packages/services/dist/src/llm/agents/CodeReviewAgent.js
+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",
+  defaultThoroughness: config?.defaultThoroughness ?? "medium",
+  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
+  deniedTools: ["image_generation", "edit_image", "delegate_to_agent", ...config?.extraDeniedTools ?? []],
+  allowedTools: config?.extraAllowedTools,
+  systemPrompt: `You are a code review specialist. Your job is to analyze code for quality, correctness, security, and maintainability.
+
+## Focus Areas
+- Bugs, logic errors, and edge cases
+- Security vulnerabilities (injection, auth issues, data exposure)
+- Code quality and readability
+- Performance concerns
+- Adherence to project patterns and conventions
+
+## Review Process
+1. Understand the context and intent of the code changes
+2. Check for bugs, logic errors, and unhandled edge cases
+3. Identify security vulnerabilities and data handling issues
+4. Evaluate code clarity, naming, and structure
+5. Look for performance problems or unnecessary complexity
+
+## Output Format
+Provide actionable feedback:
+
+### Critical Issues
+- Bugs, security vulnerabilities, or correctness problems that must be fixed
+
+### Suggestions
+- Code quality improvements with rationale
+
+### Positive Observations
+- Well-implemented patterns worth noting (optional)
+
+Focus on actionable, specific feedback referencing exact code locations. Your review will be used by the main agent.`
+});
+
+// ../../b4m-core/packages/services/dist/src/llm/agents/ProjectManagerAgent.js
+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",
+  defaultThoroughness: config?.defaultThoroughness ?? "medium",
+  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
+  allowedTools: [...config?.extraAllowedTools ?? []],
+  deniedTools: [...config?.extraDeniedTools ?? []],
+  exclusiveMcpServers: ["atlassian"],
+  systemPrompt: `You are a project management specialist with access to Jira and Confluence. Your job is to help manage projects, issues, documentation, and team workflows.
+
+## Capabilities
+
+### Jira
+- Search for issues using JQL
+- Create, update, and transition issues
+- Add comments and manage watchers
+- List projects and issue types
+
+### Confluence
+- Search for documentation
+- Create and update pages
+- Browse spaces and page hierarchies
+
+## Best Practices
+1. When searching Jira, use precise JQL queries (e.g., \`project = PROJ AND status = "In Progress"\`)
+2. When creating issues, always check available issue types first with \`atlassian__jira_list_issue_types\`
+3. When updating issue status, use \`atlassian__jira_update_issue_transition\` with the target status name
+4. When creating Confluence pages, use the user's personal space if no space is specified
+5. Always confirm destructive operations (delete) with the user before proceeding
+
+## Output Format
+Provide a clear summary of actions taken:
+1. What was done (created, updated, searched, etc.)
+2. Links or keys to relevant items (e.g., PROJ-123)
+3. Any issues or warnings encountered
+
+Be precise with issue keys and project names. Your results will be used by the main agent.`
+});
+
+// ../../b4m-core/packages/services/dist/src/llm/agents/GithubManagerAgent.js
+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",
+  defaultThoroughness: config?.defaultThoroughness ?? "medium",
+  maxIterations: { quick: 3, medium: 8, very_thorough: 15 },
+  allowedTools: [...config?.extraAllowedTools ?? []],
+  deniedTools: [...config?.extraDeniedTools ?? []],
+  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: 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.)
+
+### 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
+
+### Issues
+- Create, update, and search issues
+- Add comments and manage labels
+- List and filter issues by state, assignee, labels
+
+### Pull Requests
+- Create, update, and list pull requests
+- Get PR diffs, files changed, and review status
+- Merge pull requests and manage reviews
+- Request reviews from team members
+
+### Code & Repository
+- Search code across repositories
+- Get file contents and commit history
+- Create and list branches and tags
+- Fork repositories
+
+### CI/CD & Workflows
+- List and monitor workflow runs
+- Get job logs for debugging failures
+- Re-run failed jobs or entire workflows
+- Download workflow artifacts
+
+### Notifications
+- List and manage GitHub notifications
+- Mark notifications as read/done
+
+## Best Practices
+1. When searching issues or PRs, use GitHub search syntax (e.g., \`is:open label:bug assignee:username\`)
+2. When creating PRs, always include a clear title and description
+3. When reviewing PR changes, use \`get_pull_request_diff\` or \`get_pull_request_files\` for context
+4. For CI/CD debugging, use \`get_job_logs\` with \`failed_only=true\` to focus on failures
+5. Always include links to issues/PRs in your responses (e.g., owner/repo#123)
+
+## Output Format
+Provide a clear summary of actions taken:
+1. What was done (created, searched, merged, etc.)
+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.`
+});
+
+// ../../b4m-core/packages/services/dist/src/llm/agents/ServerAgentStore.js
+var ServerAgentStore = class {
+  constructor() {
+    const builtInAgents = [
+      // For now disable explore and plan agents as it is much faster if the parent llm handles this.
+      // ExploreAgent(),
+      // PlanAgent(),
+      CodeReviewAgent(),
+      ProjectManagerAgent(),
+      GithubManagerAgent()
+    ];
+    this.agents = new Map(builtInAgents.map((a) => [a.name, a]));
+  }
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  getAllAgents() {
+    return Array.from(this.agents.values());
+  }
+  getAgentNames() {
+    return Array.from(this.agents.keys());
+  }
+  hasAgent(name) {
+    return this.agents.has(name);
+  }
+  /**
+   * Get the deduplicated list of MCP server names that are exclusive to agents.
+   * Derived from each agent's `exclusiveMcpServers` field.
+   */
+  getExclusiveMcpServers() {
+    const servers = /* @__PURE__ */ new Set();
+    for (const agent of this.agents.values()) {
+      if (agent.exclusiveMcpServers) {
+        for (const s of agent.exclusiveMcpServers) {
+          servers.add(s);
+        }
+      }
+    }
+    return Array.from(servers);
+  }
+};
+var serverAgentStore = new ServerAgentStore();
+
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
 import throttle2 from "lodash/throttle.js";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionFeatures.js
-import { z as z139 } from "zod";
+import { z as z140 } from "zod";
 import uniq4 from "lodash/uniq.js";
-var QuestStartBodySchema = z139.object({
-  userId: z139.string(),
-  sessionId: z139.string(),
-  questId: z139.string(),
-  message: z139.string(),
-  messageFileIds: z139.array(z139.string()),
-  historyCount: z139.number(),
-  fabFileIds: z139.array(z139.string()),
+var QuestStartBodySchema = z140.object({
+  userId: z140.string(),
+  sessionId: z140.string(),
+  questId: z140.string(),
+  message: z140.string().min(1, "Message cannot be empty"),
+  messageFileIds: z140.array(z140.string()),
+  historyCount: z140.number(),
+  fabFileIds: z140.array(z140.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z139.boolean().optional(),
-  enableMementos: z139.boolean().optional(),
-  enableArtifacts: z139.boolean().optional(),
-  enableAgents: z139.boolean().optional(),
-  enableLattice: z139.boolean().optional(),
+  enableQuestMaster: z140.boolean().optional(),
+  enableMementos: z140.boolean().optional(),
+  enableArtifacts: z140.boolean().optional(),
+  enableAgents: z140.boolean().optional(),
+  enableLattice: z140.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
-  mcpServers: z139.array(z139.string()).optional(),
-  projectId: z139.string().optional(),
-  organizationId: z139.string().nullable().optional(),
+  tools: z140.array(z140.union([b4mLLMTools, z140.string()])).optional(),
+  mcpServers: z140.array(z140.string()).optional(),
+  projectId: z140.string().optional(),
+  organizationId: z140.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z139.string().optional(),
+  toolPromptId: z140.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z139.string().optional(),
-  embeddingModel: z139.string().optional(),
-  queryComplexity: z139.string(),
+  fallbackModel: z140.string().optional(),
+  embeddingModel: z140.string().optional(),
+  queryComplexity: z140.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z139.object({
-    maxDepth: z139.number().optional(),
-    duration: z139.number().optional(),
+  deepResearchConfig: z140.object({
+    maxDepth: z140.number().optional(),
+    duration: z140.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z139.array(z139.any()).optional()
+    searchers: z140.array(z140.any()).optional()
   }).optional(),
-  extraContextMessages: z139.array(z139.object({
-    role: z139.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z139.union([z139.string(), z139.array(z139.any())]),
-    fabFileIds: z139.array(z139.string()).optional()
+  extraContextMessages: z140.array(z140.object({
+    role: z140.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z140.union([z140.string(), z140.array(z140.any())]),
+    fabFileIds: z140.array(z140.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z139.string().optional(),
-  /** Pre-fetched API key table from invoke phase — avoids redundant DB call in process (#6616 P1-a) */
-  apiKeyTable: z139.record(z139.string(), z139.string().nullable()).optional()
+  timezone: z140.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -12348,89 +14555,89 @@ var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z140 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  organizationId: z140.string().nullable().optional(),
-  safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z140.boolean().optional().default(false),
-  seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
-  width: z140.number().optional(),
-  height: z140.number().optional(),
-  aspect_ratio: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional()
+  sessionId: z141.string(),
+  questId: z141.string(),
+  userId: z141.string(),
+  prompt: z141.string(),
+  organizationId: z141.string().nullable().optional(),
+  safety_tolerance: z141.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z141.boolean().optional().default(false),
+  seed: z141.number().nullable().optional(),
+  output_format: z141.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  width: z141.number().optional(),
+  height: z141.number().optional(),
+  aspect_ratio: z141.string().optional(),
+  fabFileIds: z141.array(z141.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z141 } from "zod";
+import { z as z142 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-var VideoGenerationBodySchema = z141.object({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  model: z141.nativeEnum(VideoModels).default(VideoModels.SORA_2),
-  seconds: z141.union([z141.literal(4), z141.literal(8), z141.literal(12)]).default(4),
-  size: z141.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
-  organizationId: z141.string().nullable().optional()
+var VideoGenerationBodySchema = z142.object({
+  sessionId: z142.string(),
+  questId: z142.string(),
+  userId: z142.string(),
+  prompt: z142.string(),
+  model: z142.nativeEnum(VideoModels).default(VideoModels.SORA_2),
+  seconds: z142.union([z142.literal(4), z142.literal(8), z142.literal(12)]).default(4),
+  size: z142.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
+  organizationId: z142.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
 import axios10 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
 import { v4 as uuidv49 } from "uuid";
-import { z as z142 } from "zod";
+import { z as z143 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
-var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z142.string(),
-  questId: z142.string(),
-  userId: z142.string(),
-  prompt: z142.string(),
-  organizationId: z142.string().nullable().optional(),
-  safety_tolerance: z142.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z142.boolean().optional().default(false),
-  seed: z142.number().nullable().optional(),
-  output_format: z142.enum(["jpeg", "png"]).optional().default("png"),
-  width: z142.number().optional(),
-  height: z142.number().optional(),
-  aspect_ratio: z142.string().optional(),
-  size: z142.string().optional(),
-  fabFileIds: z142.array(z142.string()).optional(),
-  image: z142.string()
+var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
+  sessionId: z143.string(),
+  questId: z143.string(),
+  userId: z143.string(),
+  prompt: z143.string(),
+  organizationId: z143.string().nullable().optional(),
+  safety_tolerance: z143.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z143.boolean().optional().default(false),
+  seed: z143.number().nullable().optional(),
+  output_format: z143.enum(["jpeg", "png"]).optional().default("png"),
+  width: z143.number().optional(),
+  height: z143.number().optional(),
+  aspect_ratio: z143.string().optional(),
+  size: z143.string().optional(),
+  fabFileIds: z143.array(z143.string()).optional(),
+  image: z143.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z143 } from "zod";
-var refineTextLLMSchema = z143.object({
-  text: z143.string(),
-  context: z143.string().optional()
+import { z as z144 } from "zod";
+var refineTextLLMSchema = z144.object({
+  text: z144.string(),
+  context: z144.string().optional()
   // tone: z.enum(['formal', 'informal', 'neutral']).optional(),
   // style: z.enum(['technical', 'creative', 'academic', 'business', 'narrative']).optional(),
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/MementoEvaluationService.js
-import { z as z144 } from "zod";
-var SingleMementoEvalSchema = z144.object({
-  importance: z144.number().min(1).max(10),
+import { z as z145 } from "zod";
+var SingleMementoEvalSchema = z145.object({
+  importance: z145.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z144.string(),
-  tags: z144.array(z144.string()).optional()
+  summary: z145.string(),
+  tags: z145.array(z145.string()).optional()
 });
-var MementoEvalResponseSchema = z144.object({
-  isPersonal: z144.boolean(),
-  mementos: z144.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z145.object({
+  isPersonal: z145.boolean(),
+  mementos: z145.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z145 } from "zod";
+import { z as z146 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -12449,10 +14656,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;
@@ -12490,10 +14697,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}
@@ -12546,6 +14753,10 @@ var ServerToolExecutor = class {
 };
 
 // src/llm/ToolRouter.ts
+var wsToolExecutor = null;
+function setWebSocketToolExecutor(executor) {
+  wsToolExecutor = executor;
+}
 var SERVER_TOOLS = ["weather_info", "web_search", "web_fetch"];
 var LOCAL_TOOLS = [
   "file_read",
@@ -12568,7 +14779,15 @@ function isLocalTool(toolName) {
 }
 async function executeTool(toolName, input, apiClient, localToolFn) {
   if (isServerTool(toolName)) {
-    logger.debug(`[ToolRouter] Routing ${toolName} to server`);
+    if (wsToolExecutor) {
+      logger.debug(`[ToolRouter] Routing ${toolName} to server via WebSocket`);
+      const result = await wsToolExecutor.execute(toolName, input);
+      if (!result.success) {
+        return `Error executing ${toolName}: ${result.error || "Tool execution failed"}`;
+      }
+      return typeof result.content === "string" ? result.content : JSON.stringify(result.content ?? "");
+    }
+    logger.debug(`[ToolRouter] Routing ${toolName} to server via HTTP`);
     const executor = new ServerToolExecutor(apiClient);
     return await executor.executeTool(toolName, input);
   } else if (isLocalTool(toolName)) {
@@ -12666,7 +14885,7 @@ async function executeCommandHook(hook, context) {
   }
 }
 var MAX_PATTERN_LENGTH = 200;
-function matchesToolPattern(toolName, pattern) {
+function matchesToolPattern2(toolName, pattern) {
   if (pattern.length > MAX_PATTERN_LENGTH) {
     console.warn(`Hook pattern exceeds max length (${MAX_PATTERN_LENGTH}), skipping: ${pattern.slice(0, 50)}...`);
     return false;
@@ -12684,7 +14903,7 @@ async function executeHooks(hooks, context) {
   }
   const matchingHooks = [];
   for (const matcher of hooks) {
-    const shouldMatch = !matcher.matcher || !context.tool_name || matchesToolPattern(context.tool_name, matcher.matcher);
+    const shouldMatch = !matcher.matcher || !context.tool_name || matchesToolPattern2(context.tool_name, matcher.matcher);
     if (shouldMatch) {
       matchingHooks.push(...matcher.hooks);
     }
@@ -12723,7 +14942,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z146 } from "zod";
+import { z as z147 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -12735,40 +14954,40 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z146.object({
-  type: z146.literal("command"),
-  command: z146.string().min(1, "Command is required for command hooks"),
-  timeout: z146.number().optional()
+var CommandHookSchema = z147.object({
+  type: z147.literal("command"),
+  command: z147.string().min(1, "Command is required for command hooks"),
+  timeout: z147.number().optional()
 });
-var PromptHookSchema = z146.object({
-  type: z146.literal("prompt"),
-  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
-  timeout: z146.number().optional()
+var PromptHookSchema = z147.object({
+  type: z147.literal("prompt"),
+  prompt: z147.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z147.number().optional()
 });
-var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z146.object({
-  matcher: z146.string().optional(),
-  hooks: z146.array(HookDefinitionSchema)
+var HookDefinitionSchema = z147.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z147.object({
+  matcher: z147.string().optional(),
+  hooks: z147.array(HookDefinitionSchema)
 });
-var AgentHooksSchema = z146.object({
-  PreToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
-  Stop: z146.array(HookMatcherSchema).optional()
+var AgentHooksSchema = z147.object({
+  PreToolUse: z147.array(HookMatcherSchema).optional(),
+  PostToolUse: z147.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z147.array(HookMatcherSchema).optional(),
+  Stop: z147.array(HookMatcherSchema).optional()
 }).optional();
-var AgentFrontmatterSchema = z146.object({
-  description: z146.string().min(1, "Agent description is required"),
-  model: z146.string().optional(),
-  "allowed-tools": z146.array(z146.string()).optional(),
-  "denied-tools": z146.array(z146.string()).optional(),
-  skills: z146.array(z146.string()).optional(),
-  "max-iterations": z146.object({
-    quick: z146.number().int().positive().optional(),
-    medium: z146.number().int().positive().optional(),
-    very_thorough: z146.number().int().positive().optional()
+var AgentFrontmatterSchema = z147.object({
+  description: z147.string().min(1, "Agent description is required"),
+  model: z147.string().optional(),
+  "allowed-tools": z147.array(z147.string()).optional(),
+  "denied-tools": z147.array(z147.string()).optional(),
+  skills: z147.array(z147.string()).optional(),
+  "max-iterations": z147.object({
+    quick: z147.number().int().positive().optional(),
+    medium: z147.number().int().positive().optional(),
+    very_thorough: z147.number().int().positive().optional()
   }).optional(),
-  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z146.record(z146.string()).optional(),
+  "default-thoroughness": z147.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z147.record(z147.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -12780,25 +14999,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" };
   }
 };
@@ -12971,6 +15191,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",
@@ -12995,7 +15236,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 = {
@@ -13054,9 +15295,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);
@@ -13234,8 +15483,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 = [
@@ -13256,9 +15505,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;
     }
@@ -13272,7 +15521,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,
@@ -13324,7 +15573,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")),
@@ -13595,8 +15844,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;
@@ -13637,18 +15886,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);
@@ -14530,6 +16779,173 @@ var ServerLlmBackend = class {
   }
 };
 
+// src/llm/WebSocketLlmBackend.ts
+import { v4 as uuidv411 } from "uuid";
+function stripThinkingBlocks2(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+}
+var WebSocketLlmBackend = class {
+  constructor(options) {
+    this.wsManager = options.wsManager;
+    this.apiClient = options.apiClient;
+    this.currentModel = options.model;
+    this.tokenGetter = options.tokenGetter;
+    this.wsCompletionUrl = options.wsCompletionUrl;
+  }
+  /**
+   * Send completion request via HTTP POST, receive streaming response via WebSocket.
+   * Collects all streamed chunks, then calls callback once at completion
+   * with the full accumulated content.
+   */
+  async complete(model, messages, options, callback) {
+    logger.debug(`[WebSocketLlmBackend] Starting complete() with model: ${model}`);
+    if (options.abortSignal?.aborted) {
+      logger.debug("[WebSocketLlmBackend] Request aborted before start");
+      return;
+    }
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const requestId = uuidv411();
+    return new Promise((resolve3, reject) => {
+      const isVerbose = process.env.B4M_VERBOSE === "1";
+      const isUltraVerbose = process.env.B4M_DEBUG_STREAM === "1";
+      const streamLogger = new StreamLogger(logger, "WebSocketLlmBackend", isVerbose, isUltraVerbose);
+      streamLogger.streamStart();
+      let eventCount = 0;
+      let accumulatedText = "";
+      let lastUsageInfo = {};
+      let toolsUsed = [];
+      let thinkingBlocks = [];
+      let settled = false;
+      const settle = (action) => {
+        if (settled) return;
+        settled = true;
+        this.wsManager.offRequest(requestId);
+        this.wsManager.offDisconnect(onDisconnect);
+        action();
+      };
+      const settleResolve = () => settle(() => resolve3());
+      const settleReject = (err) => settle(() => reject(err));
+      const onDisconnect = () => {
+        logger.debug("[WebSocketLlmBackend] Connection dropped during completion");
+        settleReject(new Error("WebSocket connection lost during completion"));
+      };
+      this.wsManager.onDisconnect(onDisconnect);
+      if (options.abortSignal) {
+        if (options.abortSignal.aborted) {
+          settleResolve();
+          return;
+        }
+        options.abortSignal.addEventListener(
+          "abort",
+          () => {
+            logger.debug("[WebSocketLlmBackend] Abort signal received");
+            settleResolve();
+          },
+          { once: true }
+        );
+      }
+      const updateUsage = (usage) => {
+        if (usage) {
+          lastUsageInfo = { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens };
+        }
+      };
+      this.wsManager.onRequest(requestId, (message) => {
+        if (options.abortSignal?.aborted) return;
+        const action = message.action;
+        if (action === "cli_completion_chunk") {
+          eventCount++;
+          const chunk = message.chunk;
+          streamLogger.onEvent(eventCount, JSON.stringify(chunk));
+          const textChunk = chunk.text || "";
+          if (textChunk) accumulatedText += textChunk;
+          updateUsage(chunk.usage);
+          if (chunk.type === "content") {
+            streamLogger.onContent(eventCount, textChunk, accumulatedText);
+          } else if (chunk.type === "tool_use") {
+            streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${chunk.tools?.length}`);
+            if (chunk.tools && chunk.tools.length > 0) toolsUsed = chunk.tools;
+            if (chunk.thinking && chunk.thinking.length > 0) thinkingBlocks = chunk.thinking;
+          }
+        } else if (action === "cli_completion_done") {
+          streamLogger.streamComplete(accumulatedText);
+          const cleanedText = stripThinkingBlocks2(accumulatedText);
+          if (!cleanedText && toolsUsed.length === 0) {
+            settleResolve();
+            return;
+          }
+          const info = {
+            ...lastUsageInfo,
+            ...toolsUsed.length > 0 && { toolsUsed },
+            ...thinkingBlocks.length > 0 && { thinking: thinkingBlocks }
+          };
+          callback([cleanedText], info).then(() => settleResolve()).catch((err) => settleReject(err));
+        } else if (action === "cli_completion_error") {
+          const errorMsg = message.error || "Server error";
+          streamLogger.onCriticalEvent(eventCount, "ERROR", errorMsg);
+          settleReject(new Error(errorMsg));
+        }
+      });
+      const axiosInstance = this.apiClient.getAxiosInstance();
+      axiosInstance.post(
+        this.wsCompletionUrl,
+        {
+          requestId,
+          model,
+          messages,
+          options: {
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            stream: true,
+            tools: options.tools || []
+          }
+        },
+        { signal: options.abortSignal }
+      ).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        settleReject(new Error(`HTTP request failed: ${msg}`));
+      });
+    });
+  }
+  /**
+   * Get available models from server (REST call, not streaming).
+   * Delegates to ApiClient -- same as ServerLlmBackend.
+   */
+  async getModelInfo() {
+    try {
+      logger.debug("[WebSocketLlmBackend] Fetching models from /api/models");
+      const response = await this.apiClient.get("/api/models");
+      if (!response || typeof response !== "object" || !Array.isArray(response.models)) {
+        logger.warn("[WebSocketLlmBackend] Invalid API response format, using fallback models");
+        return this.getFallbackModels();
+      }
+      const filteredModels = response.models.filter(
+        (model) => model.type === "text" && model.supportsTools === true
+      );
+      if (filteredModels.length === 0) {
+        logger.warn("[WebSocketLlmBackend] No CLI-compatible models found, using fallback");
+        return this.getFallbackModels();
+      }
+      logger.debug(`[WebSocketLlmBackend] Loaded ${filteredModels.length} models`);
+      return filteredModels;
+    } catch (error) {
+      logger.warn(
+        `[WebSocketLlmBackend] Failed to fetch models: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.getFallbackModels();
+    }
+  }
+  getFallbackModels() {
+    return [
+      { id: "claude-sonnet-4-5-20250929", name: "Claude 4.5 Sonnet" },
+      { id: "claude-3-5-haiku-20241022", name: "Claude 3.5 Haiku" },
+      { id: "gpt-4o", name: "GPT-4o" },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini" }
+    ];
+  }
+};
+
 // src/llm/NotifyingLlmBackend.ts
 var NotifyingLlmBackend = class {
   constructor(inner, backgroundManager) {
@@ -14564,6 +16980,253 @@ Please acknowledge these background agent results and incorporate them into your
   }
 };
 
+// src/ws/WebSocketConnectionManager.ts
+var WebSocketConnectionManager = class {
+  constructor(wsUrl, getToken) {
+    this.ws = null;
+    this.heartbeatInterval = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectDelay = 3e4;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.disconnectHandlers = /* @__PURE__ */ new Set();
+    this.reconnectTimer = null;
+    this.connected = false;
+    this.connecting = false;
+    this.closed = false;
+    this.wsUrl = wsUrl;
+    this.getToken = getToken;
+  }
+  /**
+   * Connect to the WebSocket server.
+   * Resolves when connection is established, rejects on failure.
+   */
+  async connect() {
+    if (this.connected || this.connecting) return;
+    this.connecting = true;
+    const token = await this.getToken();
+    if (!token) {
+      this.connecting = false;
+      throw new Error("No access token available for WebSocket connection");
+    }
+    return new Promise((resolve3, reject) => {
+      logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
+      this.ws = new WebSocket(this.wsUrl, [`access_token.${token}`]);
+      this.ws.onopen = () => {
+        logger.debug("[WS] Connected");
+        this.connected = true;
+        this.connecting = false;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        resolve3();
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = typeof event.data === "string" ? event.data : event.data.toString();
+          const message = JSON.parse(data);
+          const requestId = message.requestId;
+          if (requestId && this.handlers.has(requestId)) {
+            this.handlers.get(requestId)(message);
+          } else {
+            logger.debug(`[WS] Unhandled message: ${message.action || "unknown"}`);
+          }
+        } catch (err) {
+          logger.debug(`[WS] Failed to parse message: ${err}`);
+        }
+      };
+      this.ws.onclose = () => {
+        logger.debug("[WS] Connection closed");
+        this.cleanup();
+        this.notifyDisconnect();
+        if (!this.closed) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = (err) => {
+        logger.debug(`[WS] Error: ${err}`);
+        if (this.connecting) {
+          this.connecting = false;
+          this.connected = false;
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+    });
+  }
+  /** Whether the connection is currently established */
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Send a JSON message over the WebSocket connection.
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const payload = JSON.stringify(data);
+    const sizeKB = (payload.length / 1024).toFixed(1);
+    logger.debug(`[WS] Sending ${sizeKB} KB (action: ${data.action})`);
+    if (payload.length > 32e3) {
+      logger.warn(`[WS] Payload ${sizeKB} KB exceeds API Gateway 32 KB frame limit \u2014 connection will be closed`);
+    }
+    this.ws.send(payload);
+  }
+  /**
+   * Register a handler for messages matching a specific requestId.
+   */
+  onRequest(requestId, handler) {
+    this.handlers.set(requestId, handler);
+  }
+  /**
+   * Remove a handler for a specific requestId.
+   */
+  offRequest(requestId) {
+    this.handlers.delete(requestId);
+  }
+  /**
+   * Register a handler that fires when the connection drops.
+   */
+  onDisconnect(handler) {
+    this.disconnectHandlers.add(handler);
+  }
+  /**
+   * Remove a disconnect handler.
+   */
+  offDisconnect(handler) {
+    this.disconnectHandlers.delete(handler);
+  }
+  /**
+   * Close the connection and stop all heartbeat/reconnect logic.
+   */
+  disconnect() {
+    this.closed = true;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.handlers.clear();
+    this.disconnectHandlers.clear();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(
+      () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify({ action: "heartbeat" }));
+          logger.debug("[WS] Heartbeat sent");
+        }
+      },
+      5 * 60 * 1e3
+    );
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.connecting = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  notifyDisconnect() {
+    for (const handler of this.disconnectHandlers) {
+      try {
+        handler();
+      } catch {
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+    logger.debug(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.closed) return;
+      try {
+        await this.connect();
+      } catch {
+        logger.debug("[WS] Reconnection failed");
+      }
+    }, delay);
+  }
+};
+
+// src/ws/WebSocketToolExecutor.ts
+import { v4 as uuidv412 } from "uuid";
+var WebSocketToolExecutor = class {
+  constructor(wsManager, tokenGetter) {
+    this.wsManager = wsManager;
+    this.tokenGetter = tokenGetter;
+  }
+  /**
+   * Execute a server-side tool via WebSocket.
+   * Returns the tool result or throws on error.
+   */
+  async execute(toolName, input, abortSignal) {
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const token = await this.tokenGetter();
+    if (!token) {
+      throw new Error("No access token available");
+    }
+    const requestId = uuidv412();
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      const settle = (action) => {
+        if (settled) return;
+        settled = true;
+        this.wsManager.offRequest(requestId);
+        this.wsManager.offDisconnect(onDisconnect);
+        action();
+      };
+      const settleResolve = (result) => settle(() => resolve3(result));
+      const settleReject = (err) => settle(() => reject(err));
+      const onDisconnect = () => {
+        settleReject(new Error("WebSocket connection lost during tool execution"));
+      };
+      this.wsManager.onDisconnect(onDisconnect);
+      if (abortSignal) {
+        if (abortSignal.aborted) {
+          settleReject(new Error("Tool execution aborted"));
+          return;
+        }
+        abortSignal.addEventListener("abort", () => settleReject(new Error("Tool execution aborted")), {
+          once: true
+        });
+      }
+      this.wsManager.onRequest(requestId, (message) => {
+        if (message.action === "cli_tool_response") {
+          settleResolve({
+            success: message.success,
+            content: message.content,
+            error: message.error
+          });
+        }
+      });
+      try {
+        this.wsManager.send({
+          action: "cli_tool_request",
+          accessToken: token,
+          requestId,
+          toolName,
+          input
+        });
+      } catch (err) {
+        settleReject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+};
+
 // src/auth/ApiClient.ts
 import axios11 from "axios";
 var ApiClient = class {
@@ -14701,7 +17364,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.30",
+  version: "0.2.31-b4m-cli-undo-command.19493+44c80c9bc",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -14812,10 +17475,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.52.0",
-    "@bike4mind/mcp": "1.31.0",
-    "@bike4mind/services": "2.50.0",
-    "@bike4mind/utils": "2.7.0",
+    "@bike4mind/common": "2.52.1-b4m-cli-undo-command.19493+44c80c9bc",
+    "@bike4mind/mcp": "1.31.1-b4m-cli-undo-command.19493+44c80c9bc",
+    "@bike4mind/services": "2.50.1-b4m-cli-undo-command.19493+44c80c9bc",
+    "@bike4mind/utils": "2.7.1-b4m-cli-undo-command.19493+44c80c9bc",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -14836,29 +17499,29 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "e18c60eb7133cb85a538c4d87ccfafc6c95fc211"
+  gitHead: "44c80c9bcf8bf132a8b75c3635426a901adce99e"
 };
 
 // src/agents/toolFilter.ts
-function matchesToolPattern2(toolName, pattern) {
+function matchesToolPattern3(toolName, pattern) {
   const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
   return new RegExp(`^${regexPattern}$`).test(toolName);
 }
-function matchesAnyPattern(toolName, patterns) {
-  return patterns.some((pattern) => matchesToolPattern2(toolName, pattern));
+function matchesAnyPattern2(toolName, patterns) {
+  return patterns.some((pattern) => matchesToolPattern3(toolName, pattern));
 }
-function filterToolsByPatterns(allTools, allowedPatterns, deniedPatterns) {
+function filterToolsByPatterns2(allTools, allowedPatterns, deniedPatterns) {
   return allTools.filter((tool) => {
     const toolName = tool.toolSchema.name;
     if (deniedPatterns && deniedPatterns.length > 0) {
-      if (matchesAnyPattern(toolName, deniedPatterns)) {
+      if (matchesAnyPattern2(toolName, deniedPatterns)) {
         return false;
       }
     }
     if (!allowedPatterns || allowedPatterns.length === 0) {
       return true;
     }
-    return matchesAnyPattern(toolName, allowedPatterns);
+    return matchesAnyPattern2(toolName, allowedPatterns);
   });
 }
 
@@ -15127,9 +17790,12 @@ 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 = filterToolsByPatterns(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
+    const filteredTools = filterToolsByPatterns2(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
     if (this.deps.customCommandStore) {
       const skillTool = createSkillTool({
         customCommandStore: this.deps.customCommandStore,
@@ -15280,8 +17946,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 = [
@@ -15430,10 +18096,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
@@ -15457,7 +18123,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;
       }
@@ -15485,9 +18151,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);
@@ -15504,10 +18170,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) {
@@ -15587,16 +18253,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
@@ -15631,7 +18297,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;
   }
   /**
@@ -16284,7 +18950,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";
@@ -16305,8 +18971,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"
@@ -16314,10 +18980,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, "\\$&");
@@ -16350,7 +19016,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`);
   }
@@ -16405,7 +19071,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
           });
@@ -16483,8 +19149,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 = [
@@ -16521,35 +19187,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);
@@ -16610,7 +19276,9 @@ function CliApp() {
     agentStore: null,
     abortController: null,
     contextContent: "",
-    backgroundManager: null
+    backgroundManager: null,
+    wsManager: null,
+    checkpointStore: null
   });
   const [isInitialized, setIsInitialized] = useState10(false);
   const [initError, setInitError] = useState10(null);
@@ -16638,6 +19306,10 @@ function CliApp() {
         })
       );
     }
+    if (state.wsManager) {
+      state.wsManager.disconnect();
+      setWebSocketToolExecutor(null);
+    }
     if (state.agent) {
       state.agent.removeAllListeners();
     }
@@ -16656,7 +19328,7 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore, state.wsManager]);
   useInput9((input, key) => {
     if (key.escape) {
       const store = useCliStore.getState();
@@ -16731,7 +19403,7 @@ function CliApp() {
       if (!isAuthenticated) {
         console.log("\u2139\uFE0F  AI features disabled. Available commands: /login, /help, /config\n");
         const minimalSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16759,10 +19431,45 @@ function CliApp() {
         console.log(`\u{1F30D} API Environment: ${envName} (${apiBaseURL})`);
       }
       const apiClient = new ApiClient(apiBaseURL, state.configStore);
-      const llm = new ServerLlmBackend({
-        apiClient,
-        model: config.defaultModel
-      });
+      const tokenGetter = async () => {
+        const tokens = await state.configStore.getAuthTokens();
+        return tokens?.accessToken ?? null;
+      };
+      let wsManager = null;
+      let llm;
+      try {
+        const serverConfig = await apiClient.get(
+          "/api/settings/serverConfig"
+        );
+        const wsUrl = serverConfig?.websocketUrl;
+        const wsCompletionUrl = serverConfig?.wsCompletionUrl;
+        if (wsUrl && wsCompletionUrl) {
+          wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
+          await wsManager.connect();
+          const wsToolExecutor2 = new WebSocketToolExecutor(wsManager, tokenGetter);
+          setWebSocketToolExecutor(wsToolExecutor2);
+          llm = new WebSocketLlmBackend({
+            wsManager,
+            apiClient,
+            model: config.defaultModel,
+            tokenGetter,
+            wsCompletionUrl
+          });
+          logger.debug("\u{1F50C} Using WebSocket transport (bypasses CloudFront timeout)");
+        } else {
+          throw new Error("No websocketUrl or wsCompletionUrl in server config");
+        }
+      } catch (wsError) {
+        logger.debug(
+          `[WS] WebSocket unavailable, using SSE fallback: ${wsError instanceof Error ? wsError.message : String(wsError)}`
+        );
+        wsManager = null;
+        setWebSocketToolExecutor(null);
+        llm = new ServerLlmBackend({
+          apiClient,
+          model: config.defaultModel
+        });
+      }
       const models = await llm.getModelInfo();
       if (models.length === 0) {
         throw new Error("No models available from server.");
@@ -16775,7 +19482,7 @@ function CliApp() {
       }
       llm.currentModel = modelInfo.id;
       const newSession = {
-        id: uuidv411(),
+        id: uuidv413(),
         name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16825,6 +19532,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: []
@@ -16837,7 +19550,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);
@@ -16868,7 +19584,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) => {
@@ -16989,8 +19706,12 @@ function CliApp() {
         // Store agent store for agent management commands
         contextContent: contextResult.mergedContent,
         // Store raw context for compact instructions
-        backgroundManager
+        backgroundManager,
         // Store for grouped notification turn tracking
+        wsManager,
+        // WebSocket connection manager (null if using SSE fallback)
+        checkpointStore
+        // File change checkpointing for undo/restore
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -17085,13 +19806,13 @@ function CliApp() {
         messageContent = multimodalMessage.content;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17304,13 +20025,13 @@ function CliApp() {
         userMessageContent = message;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17390,7 +20111,7 @@ function CliApp() {
         const currentSession = useCliStore.getState().session;
         if (currentSession) {
           const cancelMessage = {
-            id: uuidv411(),
+            id: uuidv413(),
             role: "assistant",
             content: "\u26A0\uFE0F Operation cancelled by user",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17435,7 +20156,7 @@ function CliApp() {
     setState((prev) => ({ ...prev, abortController }));
     try {
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17463,7 +20184,7 @@ function CliApp() {
       const currentSession = useCliStore.getState().session;
       if (!currentSession) return;
       const continuationMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "---\n\n**Background Agent Results:**\n\n" + result.finalAnswer,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17524,13 +20245,13 @@ function CliApp() {
         isError = true;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: `$ ${command}`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const assistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: isError ? `\u274C Error:
 ${output}` : output.trim() || "(no output)",
@@ -17683,6 +20404,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
@@ -17775,6 +20500,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();
@@ -17999,7 +20727,7 @@ Keyboard Shortcuts:
         console.clear();
         const model = state.session?.model || state.config?.defaultModel || "claude-sonnet";
         const newSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18013,6 +20741,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();
@@ -18023,8 +20754,7 @@ Keyboard Shortcuts:
 `);
         break;
       }
-      case "rewind":
-      case "undo": {
+      case "rewind": {
         if (!state.session) {
           console.log("No active session to rewind");
           return;
@@ -18083,6 +20813,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()) {
@@ -18504,9 +21331,9 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       return { ...prev, config: updatedConfig };
     });
     if (modelChanged && state.agent) {
-      const llm = state.agent.context.llm;
-      if (llm) {
-        llm.currentModel = updatedConfig.defaultModel;
+      const backend = state.agent.context.llm;
+      if (backend) {
+        backend.currentModel = updatedConfig.defaultModel;
       }
     }
   };