@bike4mind/cli 0.2.31-feat-wolfram-alpha-tool.19541 → 0.2.31-feat-python-playground.19625

package/dist/index.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 import "./chunk-GQGOWACU.js";
-import "./chunk-MHXRROUI.js";
-import "./chunk-WO3ITPAK.js";
+import "./chunk-ZHXVJFCI.js";
+import "./chunk-RTD3GUAP.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
-  getSerperKey,
-  getWolframAlphaKey
-} from "./chunk-RCVCDNU6.js";
+  getSerperKey
+} from "./chunk-LAZAO77H.js";
 import {
   ConfigStore,
   logger
@@ -17,7 +16,7 @@ import {
 import {
   checkForUpdate,
   package_default
-} from "./chunk-DRPTZ5JQ.js";
+} from "./chunk-S3S2FV2N.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -33,7 +32,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-WZURXWHI.js";
+} from "./chunk-2PXPXXDN.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -91,7 +90,7 @@ import {
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-KTHRGR3M.js";
+} from "./chunk-EEGKRFVP.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
@@ -734,8 +733,25 @@ var COMMANDS = [
   },
   {
     name: "rewind",
-    description: "Rewind conversation to a previous point",
-    aliases: ["undo"]
+    description: "Rewind conversation to a previous point"
+  },
+  {
+    name: "undo",
+    description: "Undo the last file change"
+  },
+  {
+    name: "checkpoints",
+    description: "List available file restore points"
+  },
+  {
+    name: "restore",
+    description: "Restore files to a specific checkpoint",
+    args: "<number>"
+  },
+  {
+    name: "diff",
+    description: "Show diff between current state and a checkpoint",
+    args: "[number]"
   },
   {
     name: "project-config",
@@ -1352,11 +1368,11 @@ var JobItem = React8.memo(function JobItem2({
   job,
   indented = false
 }) {
-  const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
+  const elapsed2 = Math.round((Date.now() - job.startTime) / 1e3);
   const maxTaskLength = indented ? 50 : 60;
   const taskPreview = job.task.length > maxTaskLength ? job.task.slice(0, maxTaskLength - 3) + "..." : job.task;
   const isQueued = job.status === "queued";
-  return /* @__PURE__ */ React8.createElement(Box7, null, indented && /* @__PURE__ */ React8.createElement(Text7, null, " "), isQueued ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u23F3") : /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner2, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text7, { color: isQueued ? "yellow" : "blue" }, " ", job.agentName), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " ", "[", job.id, "] ", taskPreview, " ", isQueued ? "(queued)" : `(${elapsed}s)`));
+  return /* @__PURE__ */ React8.createElement(Box7, null, indented && /* @__PURE__ */ React8.createElement(Text7, null, " "), isQueued ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u23F3") : /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner2, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text7, { color: isQueued ? "yellow" : "blue" }, " ", job.agentName), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " ", "[", job.id, "] ", taskPreview, " ", isQueued ? "(queued)" : `(${elapsed2}s)`));
 });
 function formatStatusCounts(jobs) {
   let running = 0;
@@ -2839,9 +2855,346 @@ var CommandHistoryStore = class {
   }
 };
 
-// src/storage/CustomCommandStore.ts
-import fs5 from "fs/promises";
+// src/storage/CheckpointStore.ts
+import { promises as fs5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, unlinkSync } from "fs";
+import { execFileSync } from "child_process";
 import path6 from "path";
+var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+var DEFAULT_KEEP_COUNT = 50;
+var ABSENT_MARKER = ".b4m-absent";
+var CheckpointStore = class {
+  constructor(projectDir) {
+    this.metadata = null;
+    this.sessionId = null;
+    this.initialized = false;
+    this.projectDir = projectDir;
+    this.shadowRepoDir = path6.join(projectDir, ".b4m", "shadow-repo");
+    this.metadataPath = path6.join(projectDir, ".b4m", "checkpoints.json");
+  }
+  /**
+   * Initialize the shadow git repository and load metadata
+   */
+  async init(sessionId) {
+    this.sessionId = sessionId;
+    await fs5.mkdir(path6.join(this.projectDir, ".b4m"), { recursive: true });
+    if (!existsSync4(path6.join(this.shadowRepoDir, ".git"))) {
+      await fs5.mkdir(this.shadowRepoDir, { recursive: true });
+      this.git("init");
+      this.git("config", "user.email", "checkpoint@b4m.local");
+      this.git("config", "user.name", "B4M Checkpoint");
+      this.git("commit", "--allow-empty", "-m", "checkpoint-init");
+    }
+    await this.loadMetadata();
+    await this.ensureGitignore();
+    await this.pruneCheckpoints(DEFAULT_KEEP_COUNT);
+    this.initialized = true;
+  }
+  /**
+   * Update session ID (e.g., on /clear or /resume)
+   */
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  /**
+   * Create a checkpoint by snapshotting the current state of target files
+   * before they are modified by a tool.
+   *
+   * @param toolName - The tool about to modify files
+   * @param filePaths - Relative paths of files about to be modified
+   * @param name - Optional human-readable checkpoint name
+   */
+  async createCheckpoint(toolName, filePaths, name) {
+    if (!this.initialized || !this.sessionId) {
+      return null;
+    }
+    const checkpointName = name || `before-${toolName}-${path6.basename(filePaths[0] || "unknown")}`;
+    try {
+      let hasChanges = false;
+      for (const filePath of filePaths) {
+        const absolutePath = this.validatePathWithinProject(filePath);
+        const shadowPath = path6.join(this.shadowRepoDir, filePath);
+        const shadowDir = path6.dirname(shadowPath);
+        const absentMarkerPath = path6.join(shadowDir, `${path6.basename(filePath)}${ABSENT_MARKER}`);
+        await fs5.mkdir(shadowDir, { recursive: true });
+        if (existsSync4(absolutePath)) {
+          const stats = await fs5.lstat(absolutePath);
+          if (stats.isSymbolicLink()) {
+            continue;
+          }
+          if (stats.size > MAX_FILE_SIZE2) {
+            continue;
+          }
+          if (existsSync4(absentMarkerPath)) {
+            await fs5.unlink(absentMarkerPath);
+          }
+          await fs5.copyFile(absolutePath, shadowPath);
+          hasChanges = true;
+        } else {
+          if (existsSync4(shadowPath)) {
+            await fs5.unlink(shadowPath);
+          }
+          await fs5.writeFile(absentMarkerPath, "", "utf-8");
+          hasChanges = true;
+        }
+      }
+      if (!hasChanges) {
+        return null;
+      }
+      this.git("add", "-A");
+      try {
+        this.git("diff", "--cached", "--quiet");
+        return null;
+      } catch {
+      }
+      this.git("commit", "-m", checkpointName);
+      const sha = this.git("rev-parse", "--short", "HEAD").trim();
+      const checkpoint = {
+        id: sha,
+        name: checkpointName,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        toolName,
+        filePaths: [...filePaths],
+        sessionId: this.sessionId
+      };
+      if (!this.metadata) {
+        this.metadata = { checkpoints: [], createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      this.metadata.checkpoints.push(checkpoint);
+      await this.saveMetadata();
+      return checkpoint;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * List checkpoints for the current session (most recent first)
+   */
+  listCheckpoints() {
+    if (!this.metadata || !this.sessionId) {
+      return [];
+    }
+    return this.metadata.checkpoints.filter((cp) => cp.sessionId === this.sessionId).reverse();
+  }
+  /**
+   * Get a specific checkpoint by 1-based index (1 = most recent)
+   */
+  getCheckpoint(index) {
+    const checkpoints = this.listCheckpoints();
+    if (index < 1 || index > checkpoints.length) {
+      return null;
+    }
+    return checkpoints[index - 1];
+  }
+  /**
+   * Restore files to the state captured in a specific checkpoint
+   *
+   * @param index - 1-based index (1 = most recent)
+   * @returns The checkpoint that was restored to
+   */
+  async restoreCheckpoint(index) {
+    const checkpoint = this.getCheckpoint(index);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint #${index} not found. Use /checkpoints to see available restore points.`);
+    }
+    for (const filePath of checkpoint.filePaths) {
+      const absolutePath = this.validatePathWithinProject(filePath);
+      try {
+        const content = this.git("show", `${checkpoint.id}:${filePath}`);
+        await fs5.mkdir(path6.dirname(absolutePath), { recursive: true });
+        await fs5.writeFile(absolutePath, content, "utf-8");
+      } catch {
+        try {
+          this.git("show", `${checkpoint.id}:${path6.dirname(filePath)}/${path6.basename(filePath)}${ABSENT_MARKER}`);
+          if (existsSync4(absolutePath)) {
+            await fs5.unlink(absolutePath);
+          }
+        } catch {
+        }
+      }
+    }
+    return checkpoint;
+  }
+  /**
+   * Undo the last file change (restore to most recent checkpoint)
+   */
+  async undoLast() {
+    return this.restoreCheckpoint(1);
+  }
+  /**
+   * Get diff between current file state and a checkpoint
+   *
+   * @param index - 1-based index (1 = most recent, default)
+   * @returns Unified diff string
+   */
+  getCheckpointDiff(index = 1) {
+    const checkpoint = this.getCheckpoint(index);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint #${index} not found. Use /checkpoints to see available restore points.`);
+    }
+    const diffParts = [];
+    for (const filePath of checkpoint.filePaths) {
+      const absolutePath = this.validatePathWithinProject(filePath);
+      const tmpCheckpoint = path6.join(this.shadowRepoDir, ".diff-a");
+      const tmpCurrent = path6.join(this.shadowRepoDir, ".diff-b");
+      try {
+        let checkpointContent;
+        try {
+          checkpointContent = this.git("show", `${checkpoint.id}:${filePath}`);
+        } catch {
+          checkpointContent = "";
+        }
+        let currentContent = "";
+        if (existsSync4(absolutePath)) {
+          currentContent = readFileSync4(absolutePath, "utf-8");
+        }
+        if (checkpointContent === currentContent) {
+          continue;
+        }
+        writeFileSync(tmpCheckpoint, checkpointContent, "utf-8");
+        writeFileSync(tmpCurrent, currentContent, "utf-8");
+        try {
+          this.git(
+            "diff",
+            "--no-index",
+            "--color",
+            `--src-prefix=checkpoint:`,
+            `--dst-prefix=current:`,
+            tmpCheckpoint,
+            tmpCurrent
+          );
+        } catch (diffError) {
+          if (diffError && typeof diffError === "object" && "stdout" in diffError) {
+            const output = diffError.stdout?.toString() || "";
+            if (output) {
+              diffParts.push(`--- ${filePath} (checkpoint #${index})
++++ ${filePath} (current)
+${output}`);
+            }
+          }
+        }
+      } catch {
+      } finally {
+        try {
+          unlinkSync(tmpCheckpoint);
+        } catch {
+        }
+        try {
+          unlinkSync(tmpCurrent);
+        } catch {
+        }
+      }
+    }
+    return diffParts.join("\n");
+  }
+  /**
+   * Prune old checkpoints beyond the keep count
+   */
+  async pruneCheckpoints(keepCount = DEFAULT_KEEP_COUNT) {
+    if (!this.metadata) return;
+    const total = this.metadata.checkpoints.length;
+    if (total <= keepCount) return;
+    this.metadata.checkpoints = this.metadata.checkpoints.slice(-keepCount);
+    await this.saveMetadata();
+    try {
+      this.git("gc", "--auto", "--quiet");
+    } catch {
+    }
+  }
+  /**
+   * Clean up the shadow repository entirely
+   */
+  async cleanup() {
+    try {
+      await fs5.rm(this.shadowRepoDir, { recursive: true, force: true });
+      if (existsSync4(this.metadataPath)) {
+        await fs5.unlink(this.metadataPath);
+      }
+      this.metadata = null;
+      this.initialized = false;
+    } catch {
+    }
+  }
+  // --- Private helpers ---
+  /**
+   * Validate that a file path resolves within the project directory.
+   * Prevents path traversal attacks (e.g., ../../etc/passwd).
+   */
+  validatePathWithinProject(filePath) {
+    const absolutePath = path6.resolve(this.projectDir, filePath);
+    const normalizedProject = path6.resolve(this.projectDir) + path6.sep;
+    if (!absolutePath.startsWith(normalizedProject) && absolutePath !== path6.resolve(this.projectDir)) {
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    return absolutePath;
+  }
+  /**
+   * Execute a git command in the shadow repo
+   */
+  git(...args) {
+    return execFileSync("git", args, {
+      cwd: this.shadowRepoDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+  }
+  /**
+   * Load checkpoint metadata from disk
+   */
+  async loadMetadata() {
+    try {
+      if (existsSync4(this.metadataPath)) {
+        const data = await fs5.readFile(this.metadataPath, "utf-8");
+        this.metadata = JSON.parse(data);
+      } else {
+        this.metadata = {
+          checkpoints: [],
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    } catch {
+      this.metadata = {
+        checkpoints: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  /**
+   * Save checkpoint metadata to disk
+   */
+  async saveMetadata() {
+    if (!this.metadata) return;
+    await fs5.writeFile(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
+  }
+  /**
+   * Ensure .b4m/ is in .gitignore
+   */
+  async ensureGitignore() {
+    const gitignorePath = path6.join(this.projectDir, ".gitignore");
+    const entryToAdd = ".b4m/";
+    try {
+      let content = "";
+      try {
+        content = await fs5.readFile(gitignorePath, "utf-8");
+      } catch {
+      }
+      if (content.includes(entryToAdd) || content.includes(".b4m")) {
+        return;
+      }
+      const newContent = content.trim() + (content ? "\n" : "") + `
+# B4M checkpoint data
+${entryToAdd}
+`;
+      await fs5.writeFile(gitignorePath, newContent, "utf-8");
+    } catch {
+    }
+  }
+};
+
+// src/storage/CustomCommandStore.ts
+import fs6 from "fs/promises";
+import path7 from "path";
 import os from "os";
 
 // src/utils/commandParser.ts
@@ -3005,14 +3358,14 @@ var CustomCommandStore = class {
     const home = os.homedir();
     const root = projectRoot || process.cwd();
     this.globalCommandsDirs = [
-      path6.join(home, ".bike4mind", "commands"),
-      path6.join(home, ".claude", "commands"),
-      path6.join(home, ".claude", "skills")
+      path7.join(home, ".bike4mind", "commands"),
+      path7.join(home, ".claude", "commands"),
+      path7.join(home, ".claude", "skills")
     ];
     this.projectCommandsDirs = [
-      path6.join(root, ".bike4mind", "commands"),
-      path6.join(root, ".claude", "commands"),
-      path6.join(root, ".claude", "skills")
+      path7.join(root, ".bike4mind", "commands"),
+      path7.join(root, ".claude", "commands"),
+      path7.join(root, ".claude", "skills")
     ];
   }
   /**
@@ -3037,7 +3390,7 @@ var CustomCommandStore = class {
    */
   async loadCommandsFromDirectory(directory, source) {
     try {
-      const stats = await fs5.stat(directory);
+      const stats = await fs6.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -3070,9 +3423,9 @@ var CustomCommandStore = class {
   async findCommandFiles(directory) {
     const files = [];
     try {
-      const entries = await fs5.readdir(directory, { withFileTypes: true });
+      const entries = await fs6.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path6.join(directory, entry.name);
+        const fullPath = path7.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findCommandFiles(fullPath);
           files.push(...subFiles);
@@ -3092,14 +3445,14 @@ var CustomCommandStore = class {
    * @param source - Source identifier ('global' or 'project')
    */
   async loadCommandFile(filePath, source) {
-    const filename = path6.basename(filePath);
+    const filename = path7.basename(filePath);
     const isSkillFile = filename.toLowerCase() === "skill.md";
     const commandName = isSkillFile ? this.extractSkillName(filePath) : extractCommandName(filename);
     if (!commandName) {
       console.warn(`Invalid command filename: ${filename} (must end with .md and have valid name)`);
       return;
     }
-    const fileContent = await fs5.readFile(filePath, "utf-8");
+    const fileContent = await fs6.readFile(filePath, "utf-8");
     const command = parseCommandFile(fileContent, filePath, commandName, source);
     this.commands.set(commandName, command);
   }
@@ -3111,7 +3464,7 @@ var CustomCommandStore = class {
    * @returns Skill name or null if invalid
    */
   extractSkillName(filePath) {
-    const parentDir = path6.basename(path6.dirname(filePath));
+    const parentDir = path7.basename(path7.dirname(filePath));
     return parentDir && parentDir !== "skills" ? parentDir : null;
   }
   /**
@@ -3173,15 +3526,15 @@ var CustomCommandStore = class {
    */
   async createCommandFile(name, isGlobal = false) {
     const targetDir = isGlobal ? this.globalCommandsDirs[0] : this.projectCommandsDirs[0];
-    const filePath = path6.join(targetDir, `${name}.md`);
-    const fileExists = await fs5.access(filePath).then(
+    const filePath = path7.join(targetDir, `${name}.md`);
+    const fileExists = await fs6.access(filePath).then(
       () => true,
       () => false
     );
     if (fileExists) {
       throw new Error(`Command file already exists: ${filePath}`);
     }
-    await fs5.mkdir(targetDir, { recursive: true });
+    await fs6.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} command
 argument-hint: [args]
@@ -3196,7 +3549,7 @@ You can use:
 - $1, $2, etc. for positional arguments
 - @filename for file references
 `;
-    await fs5.writeFile(filePath, template, "utf-8");
+    await fs6.writeFile(filePath, template, "utf-8");
     return filePath;
   }
 };
@@ -4428,7 +4781,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import OpenAI2 from "openai";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
-import fs6, { unlinkSync } from "fs";
+import fs7, { unlinkSync as unlinkSync2 } from "fs";
 import yauzl from "yauzl";
 import axios3 from "axios";
 
@@ -6119,8 +6472,8 @@ async function processAndStoreImages(images, context) {
     const buffer = await downloadImage(image);
     const fileType = await fileTypeFromBuffer2(buffer);
     const filename = `${uuidv45()}.${fileType?.ext}`;
-    const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
-    return path19;
+    const path21 = await context.imageGenerateStorage.upload(buffer, filename, {});
+    return path21;
   }));
 }
 async function updateQuestAndReturnMarkdown(storedImageUrls, context) {
@@ -6485,116 +6838,6 @@ var webFetchTool = {
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/wolfram_alpha/index.js
-var MAX_QUERY_LENGTH = 500;
-var MAX_RESPONSE_SIZE = 5e4;
-function validateQueryParams(params) {
-  if (!params.query || typeof params.query !== "string") {
-    return "Invalid query parameter: query must be a non-empty string.";
-  }
-  const trimmedQuery = params.query.trim();
-  if (trimmedQuery.length === 0) {
-    return "Query cannot be empty.";
-  }
-  if (params.query.length > MAX_QUERY_LENGTH) {
-    return `Query is too long. Maximum ${MAX_QUERY_LENGTH} characters allowed.`;
-  }
-  return null;
-}
-async function wolframAlphaQuery(adapters, params, logger2) {
-  const validationError = validateQueryParams(params);
-  if (validationError) {
-    logger2?.error("Wolfram Alpha: Validation failed", { error: validationError });
-    return validationError;
-  }
-  const appId = await getWolframAlphaKey(adapters);
-  if (!appId) {
-    logger2?.error("Wolfram Alpha: No API key configured");
-    return "Wolfram Alpha is not configured. Please contact your administrator to set up the WolframAlphaKey in admin settings.";
-  }
-  const url = new URL("https://www.wolframalpha.com/api/v1/llm-api");
-  url.searchParams.set("input", params.query.trim());
-  url.searchParams.set("appid", appId);
-  if (params.maxchars) {
-    url.searchParams.set("maxchars", params.maxchars.toString());
-  }
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 3e4);
-  try {
-    logger2?.log("\u{1F522} Wolfram Alpha: Querying:", params.query);
-    const response = await fetch(url.toString(), {
-      method: "GET",
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    logger2?.log("\u{1F4E1} Wolfram Alpha: Response status:", response.status);
-    if (!response.ok) {
-      const errorText = await response.text();
-      logger2?.error("Wolfram Alpha: API error", {
-        status: response.status,
-        statusText: response.statusText,
-        errorText
-      });
-      if (response.status === 501) {
-        return `Wolfram Alpha could not interpret this query. Try rephrasing with simpler keywords or mathematical notation.`;
-      }
-      if (response.status === 403) {
-        return `Wolfram Alpha API key is invalid or missing. Please contact your administrator.`;
-      }
-      return `Wolfram Alpha error: ${response.statusText}`;
-    }
-    const result = await response.text();
-    const maxSize = Math.min(params.maxchars || MAX_RESPONSE_SIZE, MAX_RESPONSE_SIZE);
-    const truncatedResult = result.slice(0, maxSize);
-    logger2?.log("\u2705 Wolfram Alpha: Query successful, response length:", truncatedResult.length);
-    return truncatedResult || "No results from Wolfram Alpha.";
-  } catch (error) {
-    clearTimeout(timeoutId);
-    if (error instanceof Error && error.name === "AbortError") {
-      logger2?.error("Wolfram Alpha: Request timed out");
-      return "Wolfram Alpha request timed out. Please try a simpler query.";
-    }
-    logger2?.error("Wolfram Alpha: Fetch error", error);
-    return "Failed to reach Wolfram Alpha. Please try again.";
-  }
-}
-var wolframAlphaTool = {
-  name: "wolfram_alpha",
-  implementation: (context) => ({
-    toolFn: async (value) => {
-      const params = value;
-      const result = await wolframAlphaQuery({ db: context.db }, params, context.logger);
-      return result;
-    },
-    toolSchema: {
-      name: "wolfram_alpha",
-      description: `Query Wolfram Alpha for computational knowledge. Use this tool for:
-- Mathematical calculations (algebra, calculus, statistics, symbolic math)
-- Unit conversions and physical constants
-- Scientific queries (physics, chemistry, astronomy, biology)
-- Data lookups (populations, distances, historical data, financial data)
-- Equation solving and plotting
-- Date/time calculations and conversions
-
-Do NOT use for: general knowledge questions, programming help, or simple arithmetic you can compute yourself.`,
-      parameters: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "Natural language query or mathematical expression. Use simplified keywords. For exponents, use notation like 6*10^14 (not 6e14)."
-          },
-          maxchars: {
-            type: "number",
-            description: "Maximum characters in response (default: 6800)"
-          }
-        },
-        required: ["query"]
-      }
-    }
-  })
-};
-
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/math/index.js
 import { create as create5, all } from "mathjs";
 var math = create5(all, {
@@ -7556,8 +7799,8 @@ async function processAndStoreImage(imageUrl, context) {
   const buffer = await downloadImage2(imageUrl);
   const fileType = await fileTypeFromBuffer3(buffer);
   const filename = `${uuidv46()}.${fileType?.ext}`;
-  const path19 = await context.imageGenerateStorage.upload(buffer, filename, {});
-  return path19;
+  const path21 = await context.imageGenerateStorage.upload(buffer, filename, {});
+  return path21;
 }
 async function generateFullMask(imageBuffer) {
   const sharp = (await import("sharp")).default;
@@ -9498,33 +9741,33 @@ var planetVisibilityTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
-import { promises as fs7 } from "fs";
-import { existsSync as existsSync4, statSync as statSync4 } from "fs";
-import path7 from "path";
-var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+import { promises as fs8 } from "fs";
+import { existsSync as existsSync5, statSync as statSync4 } from "fs";
+import path8 from "path";
+var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 async function readFileContent(params) {
   const { path: filePath, encoding = "utf-8", offset = 0, limit } = params;
-  const normalizedPath = path7.normalize(filePath);
-  const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
-  const cwd = path7.resolve(process.cwd());
+  const normalizedPath = path8.normalize(filePath);
+  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
+  const cwd = path8.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync4(resolvedPath)) {
+  if (!existsSync5(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   const stats = statSync4(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
-  if (stats.size > MAX_FILE_SIZE2) {
-    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE2 / 1024 / 1024}MB)`);
+  if (stats.size > MAX_FILE_SIZE3) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB (max ${MAX_FILE_SIZE3 / 1024 / 1024}MB)`);
   }
   const isBinary = await checkIfBinary(resolvedPath);
   if (isBinary && encoding === "utf-8") {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
-  const content = await fs7.readFile(resolvedPath, encoding);
+  const content = await fs8.readFile(resolvedPath, encoding);
   if (typeof content === "string") {
     const lines = content.split("\n");
     const totalLines = lines.length;
@@ -9562,7 +9805,7 @@ ${content}`;
 }
 async function checkIfBinary(filePath) {
   const buffer = Buffer.alloc(8192);
-  const fd = await fs7.open(filePath, "r");
+  const fd = await fs8.open(filePath, "r");
   try {
     const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
     const chunk = buffer.slice(0, bytesRead);
@@ -9579,7 +9822,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
+        const stats = statSync4(path8.resolve(process.cwd(), path8.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -9623,25 +9866,25 @@ var fileReadTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
-import { promises as fs8 } from "fs";
-import { existsSync as existsSync5 } from "fs";
-import path8 from "path";
+import { promises as fs9 } from "fs";
+import { existsSync as existsSync6 } from "fs";
+import path9 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
-  const normalizedPath = path8.normalize(filePath);
-  const resolvedPath = path8.resolve(process.cwd(), normalizedPath);
-  const cwd = path8.resolve(process.cwd());
+  const normalizedPath = path9.normalize(filePath);
+  const resolvedPath = path9.resolve(process.cwd(), normalizedPath);
+  const cwd = path9.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync5(resolvedPath);
+  const fileExists = existsSync6(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
-    const dir = path8.dirname(resolvedPath);
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path9.dirname(resolvedPath);
+    await fs9.mkdir(dir, { recursive: true });
   }
-  await fs8.writeFile(resolvedPath, content, "utf-8");
-  const stats = await fs8.stat(resolvedPath);
+  await fs9.writeFile(resolvedPath, content, "utf-8");
+  const stats = await fs9.stat(resolvedPath);
   const lines = content.split("\n").length;
   return `File ${action} successfully: ${filePath}
 Size: ${stats.size} bytes
@@ -9652,7 +9895,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync5(path8.resolve(process.cwd(), path8.normalize(params.path)));
+      const fileExists = existsSync6(path9.resolve(process.cwd(), path9.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -9694,7 +9937,7 @@ var createFileTool = {
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { glob } from "glob";
 import { stat } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 var DEFAULT_IGNORE_PATTERNS = [
   "**/node_modules/**",
   "**/.git/**",
@@ -9710,7 +9953,7 @@ var DEFAULT_IGNORE_PATTERNS = [
 async function findFiles(params) {
   const { pattern, dir_path, case_sensitive = true, respect_git_ignore = true } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path9.resolve(baseCwd, path9.normalize(dir_path)) : baseCwd;
+  const targetDir = dir_path ? path10.resolve(baseCwd, path10.normalize(dir_path)) : baseCwd;
   if (!targetDir.startsWith(baseCwd)) {
     throw new Error(`Access denied: Cannot search outside of current working directory`);
   }
@@ -9750,7 +9993,7 @@ async function findFiles(params) {
   const summary = `Found ${filesWithStats.length} file(s)${truncated ? ` (showing first ${MAX_RESULTS})` : ""} matching: ${pattern}`;
   const dirInfo = dir_path ? `
 Directory: ${dir_path}` : "";
-  const filesList = results.map((file) => path9.relative(baseCwd, file.path)).join("\n");
+  const filesList = results.map((file) => path10.relative(baseCwd, file.path)).join("\n");
   return `${summary}${dirInfo}
 
 ${filesList}`;
@@ -9804,27 +10047,48 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { stat as stat2 } from "fs/promises";
-import path10 from "path";
-import { execFile } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import path11 from "path";
+import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { promisify } from "util";
 import { createRequire } from "module";
 var execFileAsync = promisify(execFile);
 var require2 = createRequire(import.meta.url);
+var cachedRgPath = null;
 function getRipgrepPath() {
+  if (cachedRgPath)
+    return cachedRgPath;
   try {
     const ripgrepPath = require2.resolve("@vscode/ripgrep");
-    const ripgrepDir = path10.dirname(ripgrepPath);
-    const rgBinary = path10.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path11.dirname(ripgrepPath);
+    const rgBinary = path11.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    if (!existsSync7(rgBinary)) {
+      const postinstallScript = path11.join(ripgrepDir, "..", "lib", "postinstall.js");
+      if (existsSync7(postinstallScript)) {
+        execFileSync2(process.execPath, [postinstallScript], {
+          cwd: path11.join(ripgrepDir, ".."),
+          stdio: "pipe",
+          timeout: 3e4
+        });
+      }
+      if (!existsSync7(rgBinary)) {
+        throw new Error(`ripgrep binary not found at ${rgBinary}. The postinstall download may have failed. Try running: cd ${path11.join(ripgrepDir, "..")} && node lib/postinstall.js`);
+      }
+    }
+    cachedRgPath = rgBinary;
     return rgBinary;
   } catch (error) {
+    if (error instanceof Error && error.message.includes("ripgrep binary not found")) {
+      throw error;
+    }
     throw new Error("ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services");
   }
 }
 function isPathWithinWorkspace(targetPath, baseCwd) {
-  const resolvedTarget = path10.resolve(targetPath);
-  const resolvedBase = path10.resolve(baseCwd);
-  const relativePath = path10.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path10.isAbsolute(relativePath);
+  const resolvedTarget = path11.resolve(targetPath);
+  const resolvedBase = path11.resolve(baseCwd);
+  const relativePath = path11.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path11.isAbsolute(relativePath);
 }
 function convertGlobToRipgrepGlobs(globPattern) {
   if (!globPattern || globPattern === "**/*") {
@@ -9840,7 +10104,7 @@ function convertGlobToRipgrepGlobs(globPattern) {
 async function searchFiles2(params) {
   const { pattern, dir_path, include } = params;
   const baseCwd = process.cwd();
-  const targetDir = dir_path ? path10.resolve(baseCwd, dir_path) : baseCwd;
+  const targetDir = dir_path ? path11.resolve(baseCwd, dir_path) : baseCwd;
   if (!isPathWithinWorkspace(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${dir_path}" resolves outside the allowed workspace directory`);
   }
@@ -9902,7 +10166,7 @@ async function searchFiles2(params) {
       if (item.type === "match") {
         const match = item;
         allMatches.push({
-          filePath: path10.relative(targetDir, match.data.path.text) || path10.basename(match.data.path.text),
+          filePath: path11.relative(targetDir, match.data.path.text) || path11.basename(match.data.path.text),
           lineNumber: match.data.line_number,
           line: match.data.lines.text.trimEnd()
           // Remove trailing newline
@@ -9995,18 +10259,18 @@ var grepSearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
-import { promises as fs9 } from "fs";
-import { existsSync as existsSync6, statSync as statSync5 } from "fs";
-import path11 from "path";
+import { promises as fs10 } from "fs";
+import { existsSync as existsSync8, statSync as statSync5 } from "fs";
+import path12 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
-  const normalizedPath = path11.normalize(filePath);
-  const resolvedPath = path11.resolve(process.cwd(), normalizedPath);
-  const cwd = path11.resolve(process.cwd());
+  const normalizedPath = path12.normalize(filePath);
+  const resolvedPath = path12.resolve(process.cwd(), normalizedPath);
+  const cwd = path12.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync6(resolvedPath)) {
+  if (!existsSync8(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
   const stats = statSync5(resolvedPath);
@@ -10016,10 +10280,10 @@ async function deleteFile(params) {
     throw new Error(`Path is a directory: ${filePath}. Use recursive=true to delete directories and their contents.`);
   }
   if (isDirectory) {
-    await fs9.rm(resolvedPath, { recursive: true, force: true });
+    await fs10.rm(resolvedPath, { recursive: true, force: true });
     return `Directory deleted successfully: ${filePath}`;
   } else {
-    await fs9.unlink(resolvedPath);
+    await fs10.unlink(resolvedPath);
     return `File deleted successfully: ${filePath}
 Size: ${size} bytes`;
   }
@@ -10029,8 +10293,8 @@ var deleteFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const resolvedPath = path11.resolve(process.cwd(), path11.normalize(params.path));
-      const isDirectory = existsSync6(resolvedPath) && statSync5(resolvedPath).isDirectory();
+      const resolvedPath = path12.resolve(process.cwd(), path12.normalize(params.path));
+      const isDirectory = existsSync8(resolvedPath) && statSync5(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -10286,7 +10550,8 @@ var SchedulingProblemSchema = z139.object({
   name: z139.string(),
   description: z139.string().optional(),
   jobs: z139.array(JobSchema),
-  machines: z139.array(MachineSchema)
+  machines: z139.array(MachineSchema),
+  solvedJobUrl: z139.string().url().optional()
 });
 var SolverIdSchema = z139.enum([
   "greedy",
@@ -10951,44 +11216,389 @@ function constructSolution(allOps, pheromone, heuristic, rng) {
   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)",
+// ../../b4m-core/packages/quantum/dist/src/solvers/highs-formulation.js
+function analyzeProblemComplexity(problem) {
+  const numJobs = problem.jobs.length;
+  const numMachines = problem.machines.length;
+  const opsPerJob = problem.jobs[0]?.operations.length || 0;
+  const totalOps = problem.jobs.reduce((sum2, j) => sum2 + j.operations.length, 0);
+  const machineOpCounts = /* @__PURE__ */ new Map();
+  for (const job of problem.jobs) {
+    for (const op of job.operations) {
+      machineOpCounts.set(op.machineId, (machineOpCounts.get(op.machineId) || 0) + 1);
+    }
+  }
+  const opCounts = Array.from(machineOpCounts.values());
+  const minOps = opCounts.length > 0 ? Math.min(...opCounts) : 0;
+  const maxOps = opCounts.length > 0 ? Math.max(...opCounts) : 0;
+  const avgOps = opCounts.length > 0 ? opCounts.reduce((a, b) => a + b, 0) / opCounts.length : 0;
+  let binaryVars = 0;
+  for (const n of opCounts) {
+    binaryVars += n * (n - 1) / 2;
+  }
+  const startTimeVars = totalOps;
+  const totalVars = startTimeVars + binaryVars + 1;
+  const jobPrecedenceConstraints = problem.jobs.reduce((sum2, j) => sum2 + Math.max(0, j.operations.length - 1), 0);
+  const machineDisjunctionConstraints = 2 * binaryVars;
+  const makespanConstraints = totalOps;
+  const totalConstraints = jobPrecedenceConstraints + machineDisjunctionConstraints + makespanConstraints;
+  return {
+    numJobs,
+    numMachines,
+    opsPerJob,
+    totalOps,
+    startTimeVars,
+    binaryVars,
+    totalVars,
+    jobPrecedenceConstraints,
+    machineDisjunctionConstraints,
+    makespanConstraints,
+    totalConstraints,
+    opsPerMachine: { min: minOps, max: maxOps, avg: Math.round(avgOps * 10) / 10 }
+  };
+}
+function estimateViability(c) {
+  if (c.opsPerMachine.max > 10) {
+    return {
+      viable: false,
+      risk: "high",
+      recommendation: `Too many ops on one machine (${c.opsPerMachine.max}). Add more machines to spread the load, or use Simulated Annealing.`
+    };
+  }
+  if (c.binaryVars <= 80 && c.totalOps <= 40 && c.opsPerMachine.max <= 6) {
+    return {
+      viable: true,
+      risk: "low",
+      recommendation: "Should solve quickly (< 1 second)"
+    };
+  }
+  if (c.binaryVars <= 150 && c.totalOps <= 80 && c.opsPerMachine.max <= 8) {
+    return {
+      viable: true,
+      risk: "medium",
+      recommendation: "Should solve in 1-30 seconds. WASM may have occasional instability."
+    };
+  }
+  if (c.binaryVars > 150) {
+    return {
+      viable: false,
+      risk: "high",
+      recommendation: `Too many binary vars (${c.binaryVars} > 150). Use Simulated Annealing or Tabu Search for this size.`
+    };
+  }
+  if (c.totalOps > 80) {
+    return {
+      viable: false,
+      risk: "high",
+      recommendation: `Too many operations (${c.totalOps} > 80). Use Simulated Annealing or Tabu Search for this size.`
+    };
+  }
+  return {
+    viable: false,
+    risk: "high",
+    recommendation: "Exceeds tested parameters. Consider using Simulated Annealing or Tabu Search."
+  };
+}
+function generateLPFormulation(problem) {
+  const ops = [];
+  for (const job of problem.jobs) {
+    for (let opIdx = 0; opIdx < job.operations.length; opIdx++) {
+      const op = job.operations[opIdx];
+      const varName = `sJ${job.id}O${opIdx + 1}`;
+      ops.push({
+        jobId: job.id,
+        machineId: op.machineId,
+        opIndex: opIdx,
+        duration: op.duration,
+        varName
+      });
+    }
+  }
+  const bigM = ops.reduce((sum2, op) => sum2 + op.duration, 0);
+  const machineOps = /* @__PURE__ */ new Map();
+  for (const op of ops) {
+    const machOps = machineOps.get(op.machineId) || [];
+    machOps.push(op);
+    machineOps.set(op.machineId, machOps);
+  }
+  const lines = [];
+  lines.push("Minimize obj: Cmax");
+  lines.push("");
+  lines.push("Subject To");
+  for (const job of problem.jobs) {
+    for (let i = 0; i < job.operations.length - 1; i++) {
+      const op1VarName = `sJ${job.id}O${i + 1}`;
+      const op2VarName = `sJ${job.id}O${i + 2}`;
+      const duration = job.operations[i].duration;
+      const constraintName = `job${op1VarName}to${op2VarName}`;
+      lines.push(` ${constraintName}: ${op1VarName} - ${op2VarName} <= ${-duration}`);
+    }
+  }
+  const binaryVars = [];
+  for (const [, machOps] of machineOps) {
+    if (machOps.length < 2)
+      continue;
+    for (let i = 0; i < machOps.length; i++) {
+      for (let j = i + 1; j < machOps.length; j++) {
+        const op1 = machOps[i];
+        const op2 = machOps[j];
+        const yVar = `y${op1.varName}x${op2.varName}`;
+        binaryVars.push(yVar);
+        const c1Name = `d${op1.varName}b${op2.varName}`;
+        lines.push(` ${c1Name}: ${op1.varName} - ${op2.varName} + ${bigM} ${yVar} <= ${bigM - op1.duration}`);
+        const c2Name = `d${op2.varName}b${op1.varName}`;
+        lines.push(` ${c2Name}: ${op2.varName} - ${op1.varName} - ${bigM} ${yVar} <= ${-op2.duration}`);
+      }
+    }
+  }
+  for (const op of ops) {
+    const constraintName = `mk${op.varName}`;
+    lines.push(` ${constraintName}: ${op.varName} - Cmax <= ${-op.duration}`);
+  }
+  lines.push("");
+  lines.push("Bounds");
+  for (const op of ops) {
+    lines.push(` ${op.varName} >= 0`);
+  }
+  lines.push(" Cmax >= 0");
+  lines.push("");
+  if (binaryVars.length > 0) {
+    lines.push("Binary");
+    for (const v of binaryVars) {
+      lines.push(` ${v}`);
+    }
+    lines.push("");
+  }
+  lines.push("End");
+  return lines.join("\n");
+}
+function parseSolution(problem, columns) {
+  const schedule = [];
+  const varToOp = /* @__PURE__ */ new Map();
+  for (const job of problem.jobs) {
+    for (let opIdx = 0; opIdx < job.operations.length; opIdx++) {
+      const op = job.operations[opIdx];
+      const varName = `sJ${job.id}O${opIdx + 1}`;
+      varToOp.set(varName, {
+        jobId: job.id,
+        machineId: op.machineId,
+        opIndex: opIdx,
+        duration: op.duration
+      });
+    }
+  }
+  for (const [varName, col] of Object.entries(columns)) {
+    if (varName.startsWith("sJ")) {
+      const opInfo = varToOp.get(varName);
+      if (opInfo) {
+        const startTime = Math.round(col.Primal);
+        schedule.push({
+          jobId: opInfo.jobId,
+          machineId: opInfo.machineId,
+          operationIndex: opInfo.opIndex,
+          startTime,
+          endTime: startTime + opInfo.duration
+        });
+      }
+    }
+  }
+  schedule.sort((a, b) => a.startTime - b.startTime);
+  return schedule;
+}
+function validateSchedule(problem, schedule) {
+  const errors = [];
+  const scheduledKeys = new Set(schedule.map((s) => `${s.jobId}-${s.operationIndex}`));
+  for (const job of problem.jobs) {
+    for (let opIdx = 0; opIdx < job.operations.length; opIdx++) {
+      if (!scheduledKeys.has(`${job.id}-${opIdx}`)) {
+        errors.push(`Operation (job=${job.id}, opIndex=${opIdx}) not scheduled`);
+      }
+    }
+  }
+  const byMachine = /* @__PURE__ */ new Map();
+  for (const s of schedule) {
+    const mOps = byMachine.get(s.machineId) || [];
+    mOps.push(s);
+    byMachine.set(s.machineId, mOps);
+  }
+  for (const [machineId, mOps] of byMachine) {
+    mOps.sort((a, b) => a.startTime - b.startTime);
+    for (let i = 0; i < mOps.length - 1; i++) {
+      if (mOps[i].endTime > mOps[i + 1].startTime) {
+        errors.push(`Machine ${machineId}: (job=${mOps[i].jobId},op=${mOps[i].operationIndex}) ends ${mOps[i].endTime} overlaps (job=${mOps[i + 1].jobId},op=${mOps[i + 1].operationIndex}) starts ${mOps[i + 1].startTime}`);
+      }
+    }
+  }
+  const opEndTime = /* @__PURE__ */ new Map();
+  for (const s of schedule) {
+    opEndTime.set(`${s.jobId}-${s.operationIndex}`, s.endTime);
+  }
+  for (const job of problem.jobs) {
+    for (let i = 0; i < job.operations.length - 1; i++) {
+      const op1End = opEndTime.get(`${job.id}-${i}`) || 0;
+      const op2 = schedule.find((s) => s.jobId === job.id && s.operationIndex === i + 1);
+      if (op2 && op1End > op2.startTime) {
+        errors.push(`Job ${job.id}: op ${i} ends at ${op1End} but op ${i + 1} starts at ${op2.startTime}`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/highs-solver.js
+var MAX_BINARY_VARS = 150;
+var MAX_TOTAL_OPS = 80;
+var MAX_OPS_PER_MACHINE = 8;
+async function loadHiGHS() {
+  const highsLoader = (await import("highs")).default;
+  const highs = await highsLoader({
+    locateFile: (file) => {
+      const globalSelf = globalThis;
+      if (globalSelf.location?.origin) {
+        return `${globalSelf.location.origin}/${file}`;
+      }
+      return file;
+    }
+  });
+  return highs;
+}
+function elapsed(startTime) {
+  return typeof performance !== "undefined" ? performance.now() - startTime : Date.now() - startTime;
+}
+var highsSolver = {
+  id: "highs",
+  name: "HiGHS (WASM)",
+  description: "Open-source MIP solver providing provably optimal solutions for small-to-medium scheduling problems via WASM.",
+  async solve(problem, options) {
+    const startTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+    const reportProgress = (percentage, bestMakespan) => {
+      options?.onProgress?.({
+        solverId: "highs",
+        percentage,
+        bestMakespan
+      });
+    };
+    reportProgress(0);
+    try {
+      reportProgress(5);
+      const highs = await loadHiGHS();
+      reportProgress(10);
+      const complexity = analyzeProblemComplexity(problem);
+      const viability = estimateViability(complexity);
+      if (complexity.binaryVars > MAX_BINARY_VARS) {
+        throw new Error(`Problem has too many binary variables for HiGHS WASM: ${complexity.binaryVars} (max ${MAX_BINARY_VARS}). Tip: More machines spreads ops and reduces binary vars. Current: ${complexity.numMachines} machines. For this size, use Simulated Annealing or Tabu Search.`);
+      }
+      if (complexity.totalOps > MAX_TOTAL_OPS) {
+        throw new Error(`Problem too large for HiGHS WASM: ${complexity.totalOps} operations (max ${MAX_TOTAL_OPS}). For larger problems, use Simulated Annealing or Tabu Search.`);
+      }
+      if (complexity.opsPerMachine.max > MAX_OPS_PER_MACHINE) {
+        throw new Error(`Too many operations on one machine: ${complexity.opsPerMachine.max} ops (max ${MAX_OPS_PER_MACHINE}). Tip: Add more machines to spread the load. For this size, use Simulated Annealing or Tabu Search.`);
+      }
+      if (viability.risk === "high") {
+        console.warn(`[HiGHS] Warning: ${viability.recommendation}`);
+      }
+      reportProgress(15);
+      const lpString = generateLPFormulation(problem);
+      if (!lpString.includes("Subject To") || !lpString.includes("Bounds")) {
+        throw new Error("Invalid LP formulation - missing required sections");
+      }
+      reportProgress(20);
+      let solution;
+      try {
+        solution = highs.solve(lpString, {
+          time_limit: options?.timeoutMs ? options.timeoutMs / 1e3 : 60,
+          mip_rel_gap: 0,
+          presolve: "on",
+          log_to_console: true,
+          // MUST BE TRUE - see file header
+          output_flag: true
+          // MUST BE TRUE - see file header
+        });
+      } catch (solveError) {
+        console.error("[HiGHS] Solve error:", solveError);
+        console.error("[HiGHS] Problem config:", {
+          jobs: problem.jobs.length,
+          machines: problem.machines.length,
+          totalOps: problem.jobs.reduce((sum2, j) => sum2 + j.operations.length, 0)
+        });
+        const errMsg = solveError instanceof Error ? solveError.message : String(solveError);
+        if (errMsg.includes("Aborted")) {
+          throw new Error(`HiGHS WASM crashed. This may be a numerical issue with the problem configuration. Jobs: ${problem.jobs.length}, Machines: ${problem.machines.length}. Check browser console for details.`);
+        }
+        throw solveError;
+      }
+      if (solution.Status === "Infeasible") {
+        throw new Error("Problem is infeasible - check constraints");
+      }
+      if (solution.Status === "Unbounded") {
+        throw new Error("Problem is unbounded - check objective");
+      }
+      if (solution.Status !== "Optimal" && solution.Status !== "Time limit reached" && solution.Status !== "Bound on objective reached") {
+        throw new Error(`HiGHS returned unexpected status: ${solution.Status}`);
+      }
+      reportProgress(90);
+      const schedule = parseSolution(problem, solution.Columns);
+      const makespan = Math.ceil(solution.ObjectiveValue);
+      const validation = validateSchedule(problem, schedule);
+      if (!validation.valid) {
+        console.warn("[HiGHS] Solution validation failed:", validation.errors);
+        const errorDetails = validation.errors && validation.errors.length > 0 ? validation.errors.join("; ") : "Unknown validation error";
+        throw new Error(`[HiGHS] Solution validation failed: ${errorDetails}`);
+      }
+      reportProgress(100, makespan);
+      return {
+        solverId: "highs",
+        solverName: "HiGHS (WASM)",
+        makespan,
+        schedule,
+        elapsedMs: elapsed(startTime),
+        iterations: 1
+      };
+    } catch (error) {
+      reportProgress(0);
+      throw error;
+    }
+  }
+};
+
+// ../../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"
     ],
@@ -11219,7 +11829,6 @@ var solverMetadata = {
     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: [
@@ -11262,6 +11871,7 @@ var solverMetadata = {
     requires: "Backend compute",
     available: false,
     tagline: "Quantum-inspired classical simulation",
+    externalUrl: "https://q.bike4mind.com/jobs/e499f34a-d40e-4cfb-98e5-47e0a2091f3d",
     fullDescription: "A classical simulator of the Quantum Approximate Optimization Algorithm (QAOA). Encodes the job-shop scheduling problem as a QUBO (Quadratic Unconstrained Binary Optimization), then simulates the quantum variational circuit classically. Provides a preview of quantum advantage without requiring real quantum hardware.",
     howItWorks: [
       "Encode scheduling problem as QUBO matrix",
@@ -11293,7 +11903,10 @@ var solverMetadata = {
     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" }
+      {
+        label: "QUBO Formulation Guide",
+        url: "https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization"
+      }
     ]
   },
   "ionq-qaoa": {
@@ -11304,6 +11917,7 @@ var solverMetadata = {
     requires: "IonQ API key + credits",
     available: false,
     tagline: "Real quantum hardware optimization",
+    externalUrl: "https://cloud.ionq.com/jobs/019c07ff-205a-76d0-9f83-24098ea09589",
     fullDescription: "Runs the Quantum Approximate Optimization Algorithm on IonQ\u2019s trapped-ion quantum computers. This is real quantum computation \u2014 the problem is encoded as a QUBO, compiled to native quantum gates, and executed on physical qubits. Results include genuine quantum effects like superposition and entanglement.",
     howItWorks: [
       "Encode scheduling problem as QUBO matrix",
@@ -11351,7 +11965,8 @@ var allSolvers = [
   simulatedAnnealingLargeSolver,
   tabuSolver,
   geneticAlgorithmSolver,
-  antColonySolver
+  antColonySolver,
+  highsSolver
 ];
 var solverRegistry = new Map(allSolvers.map((s) => [s.id, s]));
 function getSolver(id) {
@@ -11362,7 +11977,6 @@ function getAvailableSolverIds() {
 }
 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 }
 ];
@@ -11387,11 +12001,17 @@ ${allSolvers.map((s) => `- **${s.name}** (\`${s.id}\`): ${s.description}`).join(
 
 ## 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
+### Concierge Flow (Default)
+When a user describes a scheduling problem:
+1. Use \`quantum_formulate\` to convert their description \u2014 the problem auto-loads into the Problem Editor
+2. Call \`navigate_view\` with viewId "opti.scheduling.problem" so the user gets a button to open the Problem tab
+3. Let the user review, tweak machines/durations, and run solvers from the dashboard
+Do NOT auto-call \`quantum_schedule\` unless the user explicitly asks to solve in chat.
+
+### Power User Fast Path
+If the user says "solve it", "find the optimal schedule", or explicitly requests an in-chat solution,
+use both \`quantum_formulate\` AND \`quantum_schedule\`. The problem still loads into the Editor
+so the user can explore results in the dashboard too.
 
 ### Running Solvers
 When solving a problem:
@@ -11456,6 +12076,581 @@ RESPOND WITH ONLY A JSON OBJECT matching this schema:
 
 No markdown, no explanation, no code blocks \u2014 just the raw JSON object.`;
 
+// ../../b4m-core/packages/quantum/dist/src/patterns.js
+var patternFamilies = [
+  {
+    id: "scheduling",
+    name: "Scheduling",
+    description: "Job shop, flow shop, resource allocation over time",
+    complexity: "NP-hard",
+    color: "#e53935",
+    quboFit: "excellent",
+    examples: ["Job Shop Scheduling", "Task Scheduling", "Production Planning"],
+    status: "available",
+    tagline: "When to do things, in what order, on what resources",
+    asciiDiagram: [
+      "  0  2  4  6  8  10 12",
+      "  \u251C\u2500\u2500\u253C\u2500\u2500\u253C\u2500\u2500\u253C\u2500\u2500\u253C\u2500\u2500\u253C\u2500\u2500\u2524",
+      "A [\u25A0\u25A0\u25A0\u25A0\u25A0][  \u2591\u2591\u2591\u2591\u2591\u2591  ]",
+      "B [\u2591\u2591\u2591\u2591\u2591][  \u25A0\u25A0\u25A0\u25A0\u25A0  ]",
+      "C [\u25A0\u25A0\u25A0]     [\u2591\u2591\u2591\u2591\u2591\u2591]",
+      "  \u2500\u2500\u2500\u2500 time \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u25BA"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Job Shop Scheduling",
+        subtitle: "The Classic",
+        description: "Assign jobs to machines with precedence constraints. Each job has a sequence of operations that must be processed on specific machines in order. The goal is to minimize the total makespan.",
+        asciiDiagram: [
+          "J1: [M-A 3t]->[M-B 2t]->[M-C 4t]",
+          "J2: [M-B 2t]->[M-C 3t]->[M-A 2t]",
+          "J3: [M-C 4t]->[M-A 1t]->[M-B 3t]",
+          "",
+          "Objective: Minimize total completion time"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Flow Shop Scheduling",
+        subtitle: "Fixed Sequence",
+        description: "All jobs follow the same machine order. Simpler than job shop but still NP-hard for 3+ machines. Common in assembly lines and manufacturing pipelines.",
+        asciiDiagram: [
+          "Job 1: -->[M1]-->[M2]-->[M3]--> Done",
+          "Job 2: -->[M1]-->[M2]-->[M3]--> Done",
+          "Job 3: -->[M1]-->[M2]-->[M3]--> Done",
+          "          Fixed order through all machines"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Timetabling",
+        subtitle: "Conflict Avoidance",
+        description: "Schedule events into time slots while avoiding conflicts. No professor teaches two classes at once, no student has overlapping classes, room capacities are respected.",
+        asciiDiagram: [
+          "       Mon   Tue   Wed   Thu",
+          " 9:00 |CS101|     |CS101|     |",
+          "10:00 |     |MATH |     |MATH |",
+          "11:00 |PHYS |     |PHYS |     |",
+          "  No conflicts for shared resources!"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Sequencing with Changeover",
+        subtitle: "Order Matters",
+        description: "Transition costs between tasks depend on the sequence. Paint lines minimize cleaning by ordering light-to-dark. Semiconductor fabs batch similar wafers together.",
+        asciiDiagram: [
+          "White->Yellow->Orange  $0 each",
+          "Orange->Red->Black     $0 each",
+          "White->Black directly  $50 clean!",
+          "",
+          "Objective: Minimize total changeover cost"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Dynamic Scheduling",
+        subtitle: "Continuous Arrival",
+        description: "New jobs arrive during execution, requiring real-time rescheduling. Common in hospitals, data centers, and cloud computing where demand is unpredictable.",
+        asciiDiagram: [
+          "Time --------------------------->",
+          "J1 ========",
+          "   J2 ==========",
+          "       J3 ======= (arrived t=3)",
+          "           J4 === (arrived t=5)",
+          "  Must reschedule as jobs arrive!"
+        ].join("\n"),
+        quboFitStars: 3
+      }
+    ],
+    quboExplainer: "Each binary variable x(j,m,t) = 1 if job j starts on machine m at time t. Penalty terms enforce: (1) each operation scheduled exactly once, (2) precedence constraints respected, (3) no machine processes two jobs simultaneously. Qubit count scales as O(jobs x machines x time_horizon).",
+    useCases: [
+      { industry: "Manufacturing", application: "Factory floor scheduling" },
+      { industry: "Healthcare", application: "Operating room scheduling" },
+      { industry: "Airlines", application: "Crew and gate scheduling" },
+      { industry: "Data Centers", application: "Batch job scheduling" },
+      { industry: "Construction", application: "Project task sequencing" },
+      { industry: "Restaurants", application: "Kitchen order optimization" }
+    ]
+  },
+  {
+    id: "routing",
+    name: "Routing",
+    description: "Vehicle routing, TSP, network path optimization",
+    complexity: "NP-hard",
+    color: "#66bb6a",
+    quboFit: "excellent",
+    examples: ["Traveling Salesman", "Vehicle Routing", "Delivery Optimization"],
+    status: "coming-soon",
+    tagline: "How to move through space efficiently",
+    asciiDiagram: [
+      "       A",
+      "      /|\\",
+      "    5/ | \\3",
+      "    /  |  \\",
+      "   B---+---C",
+      "    \\  |  /",
+      "    7\\ | /2",
+      "      \\|/",
+      "       D"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Traveling Salesman (TSP)",
+        subtitle: "The Classic",
+        description: "Visit all cities exactly once and return home via the shortest route. One of the most famous optimization problems \u2014 100+ cities makes exhaustive search impossible.",
+        asciiDiagram: [
+          "Start -> A -> B -> C -> D -> Start",
+          "",
+          "Find the shortest tour that visits",
+          "every city exactly once!"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Vehicle Routing (VRP)",
+        subtitle: "Multiple Vehicles",
+        description: "Partition customers among a fleet of vehicles, each with capacity limits and time windows. TSP generalized to multiple routes from a central depot.",
+        asciiDiagram: [
+          "      Depot",
+          "     / | \\",
+          "    /  |  \\",
+          " Route1 Route2 Route3",
+          " A->B  D->E   G->H",
+          " ->C   ->F    ->I"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Shortest Path",
+        subtitle: "Point-to-Point",
+        description: "Find the minimum-cost path between two nodes in a weighted graph. Foundation for GPS navigation, network routing, and supply chain logistics.",
+        asciiDiagram: [
+          "S --3-- A --2-- T",
+          "|       |       |",
+          "5       1       4",
+          "|       |       |",
+          "B --6-- C --2-- D"
+        ].join("\n"),
+        quboFitStars: 3
+      }
+    ],
+    quboExplainer: "Binary variable x(i,t) = 1 if city i is visited at step t. Constraints: each city visited exactly once, each step visits exactly one city. Objective minimizes total edge weights along the tour. Classic QUBO formulation.",
+    useCases: [
+      { industry: "Logistics", application: "Delivery route optimization" },
+      { industry: "Ride-sharing", application: "Driver dispatch routing" },
+      { industry: "Telecom", application: "Network packet routing" },
+      { industry: "Retail", application: "Supply chain distribution" },
+      { industry: "Field Service", application: "Technician visit scheduling" }
+    ]
+  },
+  {
+    id: "packing",
+    name: "Packing",
+    description: "Bin packing, knapsack, container optimization",
+    complexity: "NP-complete",
+    color: "#e91e63",
+    quboFit: "good",
+    examples: ["Bin Packing", "Knapsack Problem", "Container Loading"],
+    status: "coming-soon",
+    tagline: "How to fit things into space efficiently",
+    asciiDiagram: [
+      "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+      "\u2502 \u2588\u2588\u2588\u2588 \u2591\u2591\u2591\u2591 \u2588\u2588\u2588\u2588\u2588\u2588 \u2502 92%",
+      "\u2502 \u2588\u2588\u2588\u2588 \u2591\u2591\u2591\u2591 \u2588\u2588\u2588\u2588\u2588\u2588 \u2502",
+      "\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",
+      "\u2502 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2591\u2591\u2591\u2591\u2591\u2591\u2591 \u2502 68%",
+      "\u2502 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2591\u2591\u2591\u2591\u2591\u2591\u2591 \u2502",
+      "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Bin Packing",
+        subtitle: "1D/2D/3D",
+        description: "Fit items into the minimum number of bins. 1D (rod cutting, memory), 2D (sheet cutting, floor plans), 3D (container loading, truck packing). Items arrive online or in batch.",
+        asciiDiagram: [
+          "Items: [3] [5] [2] [4] [6]",
+          "",
+          "Bin 1: [3][5][2]  = 10/10",
+          "Bin 2: [4][6]     = 10/10",
+          "Minimum bins: 2"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Knapsack",
+        subtitle: "Value vs Weight",
+        description: "Select items to maximize total value without exceeding weight capacity. The 0/1 knapsack is a direct binary problem \u2014 include or exclude each item.",
+        asciiDiagram: [
+          "Item  Value  Weight",
+          " A      60     10",
+          " B      100    20  <-- pick",
+          " C      120    30  <-- pick",
+          "Capacity: 50   Best: $220"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Cutting Stock",
+        subtitle: "Minimize Waste",
+        description: "Cut raw material (steel rolls, fabric bolts, lumber) into required pieces with minimal waste. Dual of bin packing \u2014 subtract from fixed-size stock.",
+        asciiDiagram: [
+          "Stock roll: |============|",
+          "Cut:  |==A==|==B==|=C=|xx|",
+          "                     waste",
+          "Objective: Minimize total waste"
+        ].join("\n"),
+        quboFitStars: 4
+      }
+    ],
+    quboExplainer: "Binary variable x(i,b) = 1 if item i is placed in bin b. Constraints: each item in exactly one bin, bin capacity not exceeded. For knapsack, x(i) = 1 if item i is selected, with weight constraint as penalty term.",
+    useCases: [
+      { industry: "Shipping", application: "Container loading optimization" },
+      { industry: "Manufacturing", application: "Raw material cutting" },
+      { industry: "Cloud Computing", application: "VM placement on servers" },
+      { industry: "Retail", application: "Warehouse space allocation" },
+      { industry: "Finance", application: "Budget allocation (knapsack)" }
+    ]
+  },
+  {
+    id: "assignment",
+    name: "Assignment",
+    description: "Matching agents to tasks, resource allocation",
+    complexity: "NP-complete",
+    color: "#42a5f5",
+    quboFit: "excellent",
+    examples: ["Task Assignment", "Resource Matching", "Workforce Allocation"],
+    status: "coming-soon",
+    tagline: "Who does what \u2014 optimal matching",
+    asciiDiagram: [
+      " Agents    Tasks",
+      "  [A] \u2500\u2500\u2500\u2500\u2500\u2500 [1]",
+      "  [B] \u2500\u2500\u2510",
+      "        \u2514\u2500\u2500 [2]",
+      "  [C] \u2500\u2500\u2500\u2500\u2500\u2500 [3]",
+      "  [D] \u2500\u2500\u2500\u2500\u2500\u2500 [4]"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Bipartite Matching",
+        subtitle: "One-to-One",
+        description: "Match agents to tasks where each agent handles exactly one task and vice versa. Minimize total cost or maximize total benefit across all assignments.",
+        asciiDiagram: [
+          "Workers      Jobs",
+          "  Alice ---> Design   cost: 3",
+          "  Bob -----> Code     cost: 2",
+          "  Carol ---> Test     cost: 4",
+          "Total cost: 9 (optimal)"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Quadratic Assignment",
+        subtitle: "Location Matters",
+        description: "Assign facilities to locations minimizing the product of flow between facilities and distance between locations. Used for factory layout and chip placement.",
+        asciiDiagram: [
+          "Facility  Flow    Location  Dist",
+          " A <-50-> B       L1 <-3-> L2",
+          " A <-20-> C       L1 <-5-> L3",
+          "Minimize: sum(flow*distance)"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Generalized Assignment",
+        subtitle: "Many-to-One",
+        description: "Assign tasks to agents where each agent can handle multiple tasks within their capacity. Workers have different skills and capacities across task types.",
+        asciiDiagram: [
+          "Agent A (cap 10): [T1:3][T2:4][T3:3]",
+          "Agent B (cap 8):  [T4:5][T5:3]",
+          "Agent C (cap 12): [T6:6][T7:4]",
+          "Maximize quality within capacity"
+        ].join("\n"),
+        quboFitStars: 4
+      }
+    ],
+    quboExplainer: "Binary variable x(i,j) = 1 if agent i is assigned to task j. Constraints: each task assigned to exactly one agent (row sums = 1), each agent at most one task (column sums <= 1). Cost matrix entries become QUBO coefficients.",
+    useCases: [
+      { industry: "HR", application: "Employee-to-project matching" },
+      { industry: "Education", application: "Student-to-course assignment" },
+      { industry: "Healthcare", application: "Doctor-to-shift assignment" },
+      { industry: "Military", application: "Weapon-target assignment" },
+      { industry: "Sports", application: "Referee-to-game assignment" }
+    ]
+  },
+  {
+    id: "network",
+    name: "Network",
+    description: "Graph partitioning, max cut, community detection",
+    complexity: "NP-hard",
+    color: "#f4511e",
+    quboFit: "excellent",
+    examples: ["Graph Partitioning", "Max Cut", "Network Design"],
+    status: "coming-soon",
+    tagline: "How to structure and divide networks",
+    asciiDiagram: [
+      " a-b-c  |  d-e",
+      " |   |  |  |  |",
+      " f-g    |  h-i",
+      " -------+-------",
+      " Group A | Group B",
+      "    max cut  \u2702"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Max Cut",
+        subtitle: "The QUBO Natural",
+        description: "Partition graph nodes into two groups to maximize edges crossing the cut. The most natural QUBO problem \u2014 maps directly without any reformulation tricks.",
+        asciiDiagram: [
+          "Group 0    |    Group 1",
+          "  a--b     |     d--e",
+          "  |        |        |",
+          "  c  ------+------  f",
+          "     cut edges = 3 (max!)"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Graph Partitioning",
+        subtitle: "Balanced Split",
+        description: "Divide nodes into k equal-sized groups minimizing edges between groups. Used for parallel computing load balancing and VLSI chip layout.",
+        asciiDiagram: [
+          "Before: tangled graph",
+          "After:  [  A  ] | [  B  ] | [  C  ]",
+          "         n/3     |  n/3    |  n/3",
+          "Minimize cross-partition edges"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Community Detection",
+        subtitle: "Find Clusters",
+        description: "Discover densely connected groups within a network. Social networks, protein interactions, citation graphs. Related to modularity maximization.",
+        asciiDiagram: [
+          "(a-b-c)   (d-e-f)",
+          "  dense     dense",
+          "     \\     /",
+          "      sparse",
+          "Find the natural communities"
+        ].join("\n"),
+        quboFitStars: 4
+      }
+    ],
+    quboExplainer: "For Max Cut: x(i) = 0 or 1 assigns node i to a group. Objective maximizes sum of w(i,j) * x(i) * (1-x(j)) over all edges. This is already a QUBO \u2014 no reformulation needed! Graph partitioning adds a balance constraint as a penalty term.",
+    useCases: [
+      { industry: "Social Media", application: "Community detection" },
+      { industry: "VLSI Design", application: "Chip layout partitioning" },
+      { industry: "HPC", application: "Parallel workload balancing" },
+      { industry: "Biology", application: "Protein interaction clustering" },
+      { industry: "Telecom", application: "Network segmentation" }
+    ]
+  },
+  {
+    id: "selection",
+    name: "Selection",
+    description: "Portfolio optimization, feature selection, subset problems",
+    complexity: "NP-complete",
+    color: "#00897b",
+    quboFit: "good",
+    examples: ["Portfolio Selection", "Feature Selection", "Subset Sum"],
+    status: "coming-soon",
+    tagline: "Which items to choose from a set",
+    asciiDiagram: [
+      " [\u25A0] [\xB7] [\u25A0] [\xB7]",
+      " [\xB7] [\u25A0] [\xB7] [\u25A0]",
+      " [\u25A0] [\xB7] [\xB7] [\xB7]",
+      " \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      " \u25A0 = selected  5/12",
+      " score: 847 / 1000"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Portfolio Optimization",
+        subtitle: "Risk vs Return",
+        description: "Select assets to maximize return while minimizing risk (variance). Markowitz model is naturally quadratic \u2014 covariance matrix maps directly to QUBO interactions.",
+        asciiDiagram: [
+          "Return ^",
+          "       |     * efficient frontier",
+          "       |   *",
+          "       | *  <- optimal portfolio",
+          "       |* ",
+          "       +---------> Risk"
+        ].join("\n"),
+        quboFitStars: 5
+      },
+      {
+        name: "Feature Selection",
+        subtitle: "Signal vs Noise",
+        description: "Choose the best subset of features for a machine learning model. Too many features cause overfitting; too few miss signal. Binary choice per feature makes this naturally QUBO.",
+        asciiDiagram: [
+          "Features: [x1] [x2] [x3] ... [xN]",
+          "Select:    Y    N    Y   ...   N",
+          "",
+          "Maximize: accuracy - lambda*count"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Set Cover",
+        subtitle: "Minimum Coverage",
+        description: "Choose the fewest subsets that together cover all elements. Used for sensor placement, test suite minimization, and service location planning.",
+        asciiDiagram: [
+          "Universe: {1,2,3,4,5,6,7}",
+          "S1={1,2,3}  S2={2,4}  S3={3,4,5}",
+          "S4={5,6,7}  S5={1,6}",
+          "Solution: S1 + S3 + S4 (covers all)"
+        ].join("\n"),
+        quboFitStars: 4
+      }
+    ],
+    quboExplainer: "Binary variable x(i) = 1 if item i is selected. For portfolio: minimize x^T * Sigma * x - lambda * mu^T * x where Sigma is covariance and mu is expected return. The quadratic form IS the QUBO \u2014 no conversion needed.",
+    useCases: [
+      { industry: "Finance", application: "Portfolio construction" },
+      { industry: "Machine Learning", application: "Feature subset selection" },
+      { industry: "Telecom", application: "Cell tower placement" },
+      { industry: "Insurance", application: "Product bundle selection" },
+      { industry: "Military", application: "Sensor network deployment" }
+    ]
+  },
+  {
+    id: "economic",
+    name: "Economic",
+    description: "Market equilibrium, auction design, pricing",
+    complexity: "NP-hard",
+    color: "#ab47bc",
+    quboFit: "experimental",
+    examples: ["Market Clearing", "Auction Optimization", "Price Discovery"],
+    status: "coming-soon",
+    tagline: "Finding optimal prices and market equilibria",
+    asciiDiagram: [
+      " P \u2502\\    /",
+      "   \u2502 \\  / Supply",
+      "   \u2502  \\/",
+      "   \u2502  /\\  \u2190 equilibrium",
+      "   \u2502 /  \\",
+      "   \u2502/    \\ Demand",
+      "   \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 Q"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Market Clearing",
+        subtitle: "Equilibrium",
+        description: "Find prices where supply meets demand across multiple goods simultaneously. Power grid markets clear hourly; financial exchanges clear in microseconds.",
+        asciiDiagram: [
+          "Buyers:  B1=$50 B2=$40 B3=$30",
+          "Sellers: S1=$20 S2=$35 S3=$45",
+          "Clear price: $35-40 (2 trades)",
+          "Maximize social welfare"
+        ].join("\n"),
+        quboFitStars: 3
+      },
+      {
+        name: "Combinatorial Auction",
+        subtitle: "Bundle Bidding",
+        description: "Bidders submit bids on bundles of items. Winner determination maximizes revenue while ensuring each item sold at most once. Directly maps to weighted set packing.",
+        asciiDiagram: [
+          "Bid 1: {A,B} = $100",
+          "Bid 2: {B,C} = $80",
+          "Bid 3: {A}   = $60",
+          "Bid 4: {C}   = $50",
+          "Best: Bid 1 + Bid 4 = $150"
+        ].join("\n"),
+        quboFitStars: 4
+      },
+      {
+        name: "Pricing Optimization",
+        subtitle: "Revenue Maximization",
+        description: "Set prices across products to maximize total revenue considering demand elasticity, competition, and cross-product effects (substitutes and complements).",
+        asciiDiagram: [
+          "Price  Demand  Revenue",
+          " $10    100    $1000",
+          " $15     70    $1050  <- optimal",
+          " $20     40     $800",
+          " $25     15     $375"
+        ].join("\n"),
+        quboFitStars: 2
+      }
+    ],
+    quboExplainer: "Auction winner determination: x(i) = 1 if bid i is accepted. Maximize sum of bid values. Constraint: for each item, sum of accepted bids containing that item <= 1. Requires discretizing continuous prices into binary tiers for QUBO encoding.",
+    useCases: [
+      { industry: "Energy", application: "Power market clearing" },
+      { industry: "Advertising", application: "Ad auction optimization" },
+      { industry: "Spectrum", application: "FCC spectrum auctions" },
+      { industry: "Retail", application: "Dynamic pricing strategy" },
+      { industry: "Agriculture", application: "Commodity market design" }
+    ]
+  },
+  {
+    id: "continuous",
+    name: "Continuous",
+    description: "Continuous optimization with discretization",
+    complexity: "NP-hard",
+    color: "#78909c",
+    quboFit: "fair",
+    examples: ["Parameter Tuning", "Function Optimization", "Calibration"],
+    status: "coming-soon",
+    tagline: "Finding the best point in continuous space",
+    asciiDiagram: [
+      " f(x)",
+      "  \u2502  \u2571\u2572",
+      "  \u2502 \u2571  \u2572   \u2571\u2572",
+      "  \u2502\u2571    \u2572 \u2571  \u2572",
+      "  \u2502      \u2573    \u2572",
+      "  \u2502     \u2191 min   \u2572",
+      "  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 x"
+    ].join("\n"),
+    subPatterns: [
+      {
+        name: "Parameter Tuning",
+        subtitle: "Find the Sweet Spot",
+        description: "Optimize continuous parameters (temperature, pressure, learning rate) by discretizing into binary-encoded levels. Each parameter gets log2(levels) qubits.",
+        asciiDiagram: [
+          "Param A: [0.1, 0.2, 0.3, 0.4]",
+          "Param B: [10, 20, 30, 40, 50]",
+          "",
+          "Encode: 2 bits per param (4 levels)",
+          "Search 4x5 = 20 combinations"
+        ].join("\n"),
+        quboFitStars: 3
+      },
+      {
+        name: "Function Minimization",
+        subtitle: "Global Optimum",
+        description: "Find the global minimum of a multivariate function with many local minima. Discretize the domain and encode as QUBO. Quantum tunneling helps escape local optima.",
+        asciiDiagram: [
+          "f(x) ^",
+          "     |  /\\    /\\",
+          "     | /  \\  /  \\",
+          "     |/    \\/    \\",
+          "     |    global  \\",
+          "     +-----min-----> x"
+        ].join("\n"),
+        quboFitStars: 3
+      },
+      {
+        name: "Calibration",
+        subtitle: "Model Fitting",
+        description: "Adjust model parameters to best fit observed data. When the error landscape is non-convex, classical gradient descent gets stuck. QUBO explores the full landscape.",
+        asciiDiagram: [
+          "Data:  * * *   *  * *",
+          "Model: ----\\--/--------",
+          "            \\/  <- fit here",
+          "Minimize: sum(error^2)"
+        ].join("\n"),
+        quboFitStars: 2
+      }
+    ],
+    quboExplainer: "Continuous variables are discretized into binary representation. For N levels, use log2(N) qubits per variable. The continuous objective function is approximated as a polynomial in binary variables, yielding a QUBO. Precision trades off against qubit count.",
+    useCases: [
+      { industry: "Engineering", application: "Design parameter optimization" },
+      { industry: "ML/AI", application: "Hyperparameter tuning" },
+      { industry: "Chemistry", application: "Reaction condition optimization" },
+      { industry: "Finance", application: "Model calibration" },
+      { industry: "Manufacturing", application: "Process control tuning" }
+    ]
+  }
+];
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/quantumSchedule/index.js
 function formatResult(result) {
   const lines = [
@@ -11680,14 +12875,15 @@ ${problem.description}` : "",
           "### 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."
+          'A problem is ready to load. Navigate to the Problem tab and click "Load Problem" to review, tweak, and run solvers.'
         ];
-        return lines.filter((l) => l !== void 0).join("\n");
+        const humanReadableSummary = lines.filter((l) => l !== void 0).join("\n");
+        return JSON.stringify({
+          __uiSideEffect: true,
+          type: "populateProblem",
+          payload: problem,
+          displayMessage: humanReadableSummary
+        });
       } catch (err) {
         return `Error formulating problem: ${err instanceof Error ? err.message : String(err)}`;
       }
@@ -11779,7 +12975,7 @@ var navigateViewTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
-import path12 from "path";
+import path13 from "path";
 var DEFAULT_TIMEOUT_MS = 6e4;
 var MAX_OUTPUT_SIZE = 100 * 1024;
 var DANGEROUS_PATTERNS = [
@@ -11963,7 +13159,7 @@ async function executeBashCommand(params) {
     };
   }
   const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path12.resolve(baseCwd, relativeCwd) : baseCwd;
+  const targetCwd = relativeCwd ? path13.resolve(baseCwd, relativeCwd) : baseCwd;
   const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
   return new Promise((resolve3) => {
     let stdout = "";
@@ -12966,9 +14162,9 @@ function parseQuery(query) {
 }
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editLocalFile/index.js
-import { promises as fs10 } from "fs";
-import { existsSync as existsSync7 } from "fs";
-import path13 from "path";
+import { promises as fs11 } from "fs";
+import { existsSync as existsSync9 } from "fs";
+import path14 from "path";
 import { diffLines as diffLines3 } from "diff";
 function generateDiff(original, modified) {
   const differences = diffLines3(original, modified);
@@ -12992,16 +14188,16 @@ function generateDiff(original, modified) {
 }
 async function editLocalFile(params) {
   const { path: filePath, old_string, new_string } = params;
-  const normalizedPath = path13.normalize(filePath);
-  const resolvedPath = path13.resolve(process.cwd(), normalizedPath);
-  const cwd = path13.resolve(process.cwd());
+  const normalizedPath = path14.normalize(filePath);
+  const resolvedPath = path14.resolve(process.cwd(), normalizedPath);
+  const cwd = path14.resolve(process.cwd());
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot edit files outside of current working directory`);
   }
-  if (!existsSync7(resolvedPath)) {
+  if (!existsSync9(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const currentContent = await fs10.readFile(resolvedPath, "utf-8");
+  const currentContent = await fs11.readFile(resolvedPath, "utf-8");
   if (!currentContent.includes(old_string)) {
     const preview = old_string.length > 100 ? old_string.substring(0, 100) + "..." : old_string;
     throw new Error(`String to replace not found in file. Make sure the old_string matches exactly (including whitespace and line endings). Searched for: "${preview}"`);
@@ -13011,7 +14207,7 @@ async function editLocalFile(params) {
     throw new Error(`Found ${occurrences} occurrences of the string to replace. Please provide a more specific old_string that matches exactly one location.`);
   }
   const newContent = currentContent.replace(old_string, new_string);
-  await fs10.writeFile(resolvedPath, newContent, "utf-8");
+  await fs11.writeFile(resolvedPath, newContent, "utf-8");
   const diffResult = generateDiff(old_string, new_string);
   return `File edited successfully: ${filePath}
 Changes: +${diffResult.additions} lines, -${diffResult.deletions} lines
@@ -13406,7 +14602,6 @@ var b4mTools = {
   edit_image: imageEditTool,
   web_search: webSearchTool,
   web_fetch: webFetchTool,
-  wolfram_alpha: wolframAlphaTool,
   math_evaluate: mathTool,
   mermaid_chart: mermaidChartTool,
   current_datetime: currentDateTimeTool,
@@ -13661,12 +14856,27 @@ var GithubManagerAgent = (config) => ({
   exclusiveMcpServers: ["github"],
   systemPrompt: `You are a GitHub specialist with access to GitHub's API. Your job is to help manage repositories, issues, pull requests, code search, branches, and CI/CD workflows.
 
-## First Step: Resolve Repository Context
-ALWAYS start by calling the \`github__current_user\` tool. The response includes:
+## First Step: ALWAYS Resolve Repository Context Automatically
+Before doing ANYTHING else, call the \`github__current_user\` tool. The response includes:
 - **selected_repositories**: The list of repositories the user has enabled for AI access (in \`owner/repo\` format)
 - **user**: The authenticated user's profile (login, name, etc.)
 
-Use this to resolve the owner and repo name when the user does not specify them. If only one repository is selected, default to that repository. If multiple are selected and the user's request is ambiguous, mention the available repositories and ask for clarification via your response.
+### Repository Resolution Rules (CRITICAL)
+You MUST use the selected_repositories list to automatically resolve the owner and repo. NEVER ask the user for the org, owner, or full repository path. Instead:
+
+1. **Exact match**: If the user says a repo name that exactly matches a repo name in selected_repositories, use it immediately.
+2. **Partial/fuzzy match**: If the user provides a partial name, match it against any repo in selected_repositories whose name contains that term (e.g., if the user says "lumina" and selected_repositories contains \`SomeOrg/lumina5\`, use that).
+3. **Single repo shortcut**: If only one repository is selected, ALWAYS default to it \u2014 no questions asked.
+4. **Multiple matches**: Only if multiple selected repos match the user's term AND you truly cannot disambiguate, list the matching repos and ask which one. Do NOT list repos that don't match.
+5. **No match**: If nothing in selected_repositories matches, tell the user which repos are available and ask them to clarify.
+
+**NEVER ask the user to "paste the GitHub URL" or provide the org/owner name.** You already have this information from \`github__current_user\`. The owner and repo are embedded in the \`owner/repo\` format of each selected repository entry.
+
+### Defaults for Ambiguous Requests
+- **Timezone**: Default to UTC unless the user specifies otherwise.
+- **PR/Issue state**: Default to \`open\` unless the user specifies otherwise.
+- **Scope**: All matching repos unless the user narrows it down.
+- **When in doubt, act**: Prefer making reasonable assumptions and proceeding over asking clarifying questions. You can always note your assumptions in the response.
 
 ## Capabilities
 
@@ -13707,7 +14917,7 @@ Use this to resolve the owner and repo name when the user does not specify them.
 ## Output Format
 Provide a clear summary of actions taken:
 1. What was done (created, searched, merged, etc.)
-2. Links to relevant items (e.g., owner/repo#123, PR URLs)
+2. Always provide links to relevant items (e.g., owner/repo#123, PR URLs)
 3. Any issues or warnings encountered
 
 Be precise with repository names, issue numbers, and PR numbers. Your results will be used by the main agent.`
@@ -14402,10 +15612,10 @@ var ToolErrorType;
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync10(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -14443,10 +15653,10 @@ ${diffLines4.join("\n")}`;
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync8(args.path)) {
+    if (!existsSync10(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
-    const stats = await import("fs/promises").then((fs14) => fs14.stat(args.path));
+    const stats = await import("fs/promises").then((fs15) => fs15.stat(args.path));
     return `[File will be deleted]
 
 Path: ${args.path}
@@ -14745,25 +15955,26 @@ var DEFAULT_AGENT_MODEL = "claude-3-5-haiku-20241022";
 var DEFAULT_THOROUGHNESS = "medium";
 
 // src/utils/toolsAdapter.ts
+import path15 from "path";
 var NoOpStorage = class extends BaseStorage {
   async upload(input, destination, options) {
     return `/tmp/${destination}`;
   }
-  async download(path19) {
+  async download(path21) {
     throw new Error("Download not supported in CLI");
   }
-  async delete(path19) {
+  async delete(path21) {
   }
-  async getSignedUrl(path19) {
-    return `/tmp/${path19}`;
+  async getSignedUrl(path21) {
+    return `/tmp/${path21}`;
   }
-  getPublicUrl(path19) {
-    return `/tmp/${path19}`;
+  getPublicUrl(path21) {
+    return `/tmp/${path21}`;
   }
-  async getPreview(path19) {
-    return `/tmp/${path19}`;
+  async getPreview(path21) {
+    return `/tmp/${path21}`;
   }
-  async getMetadata(path19) {
+  async getMetadata(path21) {
     return { size: 0, contentType: "application/octet-stream" };
   }
 };
@@ -14936,6 +16147,27 @@ function wrapToolWithHooks(tool, hooks, hookContext) {
     }
   };
 }
+var CHECKPOINT_TOOLS = /* @__PURE__ */ new Set(["create_file", "edit_local_file", "delete_file"]);
+function wrapToolWithCheckpointing(tool, checkpointStore) {
+  if (!checkpointStore || !CHECKPOINT_TOOLS.has(tool.toolSchema.name)) {
+    return tool;
+  }
+  const originalFn = tool.toolFn;
+  const toolName = tool.toolSchema.name;
+  return {
+    ...tool,
+    toolFn: async (args) => {
+      const filePath = args?.path;
+      if (filePath) {
+        try {
+          await checkpointStore.createCheckpoint(toolName, [filePath], `before-${toolName}-${path15.basename(filePath)}`);
+        } catch {
+        }
+      }
+      return originalFn(args);
+    }
+  };
+}
 var TOOL_NAME_MAPPING = {
   // Claude Code -> B4M
   read: "file_read",
@@ -14960,7 +16192,7 @@ function normalizeToolName(toolName) {
   }
   return TOOL_NAME_MAPPING[toolName] || toolName;
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter) {
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter, checkpointStore) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -15019,9 +16251,17 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     // imageProcessorLambdaName (not needed for CLI)
     tools_to_generate
   );
-  let tools = Object.entries(toolsMap).map(
-    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
-  );
+  let tools = Object.entries(toolsMap).map(([_, tool]) => {
+    const permissionWrapped = wrapToolWithPermission(
+      tool,
+      permissionManager,
+      showPermissionPrompt,
+      agentContext,
+      configStore,
+      apiClient
+    );
+    return wrapToolWithCheckpointing(permissionWrapped, checkpointStore ?? null);
+  });
   if (toolFilter) {
     const { allowedTools, deniedTools } = toolFilter;
     const normalizedAllowed = allowedTools?.map(normalizeToolName);
@@ -15199,8 +16439,8 @@ function getEnvironmentName(configApiConfig) {
 }
 
 // src/utils/contextLoader.ts
-import * as fs11 from "fs";
-import * as path14 from "path";
+import * as fs12 from "fs";
+import * as path16 from "path";
 import { homedir as homedir3 } from "os";
 var CONTEXT_FILE_SIZE_LIMIT = 100 * 1024;
 var PROJECT_CONTEXT_FILES = [
@@ -15221,9 +16461,9 @@ function formatFileSize2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 function tryReadContextFile(dir, filename, source) {
-  const filePath = path14.join(dir, filename);
+  const filePath = path16.join(dir, filename);
   try {
-    const stats = fs11.lstatSync(filePath);
+    const stats = fs12.lstatSync(filePath);
     if (stats.isDirectory()) {
       return null;
     }
@@ -15237,7 +16477,7 @@ function tryReadContextFile(dir, filename, source) {
         error: `${source === "global" ? "Global" : "Project"} ${filename} exceeds 100KB limit (${formatFileSize2(stats.size)})`
       };
     }
-    const content = fs11.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return {
       filename,
       content,
@@ -15289,7 +16529,7 @@ ${project.content}`;
 }
 async function loadContextFiles(projectDir) {
   const errors = [];
-  const globalDir = path14.join(homedir3(), ".bike4mind");
+  const globalDir = path16.join(homedir3(), ".bike4mind");
   const projectDirectory = projectDir || process.cwd();
   const [globalResult, projectResult] = await Promise.all([
     Promise.resolve(findContextFile(globalDir, GLOBAL_CONTEXT_FILES, "global")),
@@ -15560,8 +16800,8 @@ function substituteArguments(template, args) {
 // ../../b4m-core/packages/mcp/dist/src/client.js
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import path15 from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import path17 from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -15602,18 +16842,18 @@ var MCPClient = class {
         const root = process.env.INIT_CWD || process.cwd();
         const candidatePaths = [
           // When running from SST Lambda with node_modules structure (copyFiles)
-          path15.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `node_modules/@bike4mind/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda deployed environment (/var/task)
-          path15.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from SST Lambda (.sst/artifacts/mcpHandler-dev), navigate to monorepo root (3 levels up)
-          path15.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `../../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // When running from packages/client (Next.js app), navigate to monorepo root (2 levels up)
-          path15.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, `../../b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           // Original paths (backward compatibility)
-          path15.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
-          path15.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
+          path17.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
+          path17.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync9(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync11(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -16444,6 +17684,10 @@ var ServerLlmBackend = class {
    */
   getFallbackModels() {
     return [
+      {
+        id: "claude-sonnet-4-6",
+        name: "Claude 4.6 Sonnet"
+      },
       {
         id: "claude-sonnet-4-5-20250929",
         name: "Claude 4.5 Sonnet"
@@ -16539,6 +17783,7 @@ var WebSocketLlmBackend = class {
         settled = true;
         this.wsManager.offRequest(requestId);
         this.wsManager.offDisconnect(onDisconnect);
+        options.abortSignal?.removeEventListener("abort", abortHandler);
         action();
       };
       const settleResolve = () => settle(() => resolve3());
@@ -16548,19 +17793,16 @@ var WebSocketLlmBackend = class {
         settleReject(new Error("WebSocket connection lost during completion"));
       };
       this.wsManager.onDisconnect(onDisconnect);
+      const abortHandler = () => {
+        logger.debug("[WebSocketLlmBackend] Abort signal received");
+        settleResolve();
+      };
       if (options.abortSignal) {
         if (options.abortSignal.aborted) {
           settleResolve();
           return;
         }
-        options.abortSignal.addEventListener(
-          "abort",
-          () => {
-            logger.debug("[WebSocketLlmBackend] Abort signal received");
-            settleResolve();
-          },
-          { once: true }
-        );
+        options.abortSignal.addEventListener("abort", abortHandler, { once: true });
       }
       const updateUsage = (usage) => {
         if (usage) {
@@ -16654,6 +17896,7 @@ var WebSocketLlmBackend = class {
   }
   getFallbackModels() {
     return [
+      { id: "claude-sonnet-4-6", name: "Claude 4.6 Sonnet" },
       { 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" },
@@ -16897,27 +18140,35 @@ var WebSocketToolExecutor = class {
     const requestId = uuidv412();
     return new Promise((resolve3, reject) => {
       let settled = false;
+      let timeoutTimer;
       const settle = (action) => {
         if (settled) return;
         settled = true;
+        clearTimeout(timeoutTimer);
         this.wsManager.offRequest(requestId);
         this.wsManager.offDisconnect(onDisconnect);
+        abortSignal?.removeEventListener("abort", abortHandler);
         action();
       };
       const settleResolve = (result) => settle(() => resolve3(result));
       const settleReject = (err) => settle(() => reject(err));
+      const TOOL_TIMEOUT_MS = 5 * 60 * 1e3;
+      timeoutTimer = setTimeout(() => {
+        settleReject(new Error(`Tool execution timed out after ${TOOL_TIMEOUT_MS / 1e3}s`));
+      }, TOOL_TIMEOUT_MS);
       const onDisconnect = () => {
         settleReject(new Error("WebSocket connection lost during tool execution"));
       };
       this.wsManager.onDisconnect(onDisconnect);
+      const abortHandler = () => {
+        settleReject(new Error("Tool execution aborted"));
+      };
       if (abortSignal) {
         if (abortSignal.aborted) {
           settleReject(new Error("Tool execution aborted"));
           return;
         }
-        abortSignal.addEventListener("abort", () => settleReject(new Error("Tool execution aborted")), {
-          once: true
-        });
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
       }
       this.wsManager.onRequest(requestId, (message) => {
         if (message.action === "cli_tool_response") {
@@ -17365,7 +18616,10 @@ var SubagentOrchestrator = class {
       this.deps.showPermissionPrompt,
       agentContext,
       this.deps.configStore,
-      this.deps.apiClient
+      this.deps.apiClient,
+      void 0,
+      // toolFilter (applied separately below)
+      this.deps.checkpointStore
     );
     const filteredTools = filterToolsByPatterns2(allTools, toolFilter.allowedTools, toolFilter.deniedTools);
     if (this.deps.customCommandStore) {
@@ -17518,8 +18772,8 @@ var SubagentOrchestrator = class {
 };
 
 // src/agents/AgentStore.ts
-import fs12 from "fs/promises";
-import path16 from "path";
+import fs13 from "fs/promises";
+import path18 from "path";
 import os2 from "os";
 import matter2 from "gray-matter";
 var FULL_MODEL_ID_PREFIXES = [
@@ -17552,6 +18806,7 @@ var MODEL_ALIASES = {
   "claude-haiku": "claude-3-5-haiku-20241022",
   // Version-specific Claude aliases
   "claude-4.6-opus": "claude-opus-4-6",
+  "claude-4.6-sonnet": "claude-sonnet-4-6",
   "claude-4.5-opus": "claude-opus-4-5-20251101",
   "claude-4.5-sonnet": "claude-sonnet-4-5-20250929",
   "claude-4.5-haiku": "claude-haiku-4-5-20251001",
@@ -17668,10 +18923,10 @@ var AgentStore = class {
     const root = projectRoot || process.cwd();
     const home = os2.homedir();
     this.builtinAgentsDir = builtinDir;
-    this.globalB4MAgentsDir = path16.join(home, ".bike4mind", "agents");
-    this.globalClaudeAgentsDir = path16.join(home, ".claude", "agents");
-    this.projectB4MAgentsDir = path16.join(root, ".bike4mind", "agents");
-    this.projectClaudeAgentsDir = path16.join(root, ".claude", "agents");
+    this.globalB4MAgentsDir = path18.join(home, ".bike4mind", "agents");
+    this.globalClaudeAgentsDir = path18.join(home, ".claude", "agents");
+    this.projectB4MAgentsDir = path18.join(root, ".bike4mind", "agents");
+    this.projectClaudeAgentsDir = path18.join(root, ".claude", "agents");
   }
   /**
    * Load all agents from all directories
@@ -17695,7 +18950,7 @@ var AgentStore = class {
    */
   async loadAgentsFromDirectory(directory, source) {
     try {
-      const stats = await fs12.stat(directory);
+      const stats = await fs13.stat(directory);
       if (!stats.isDirectory()) {
         return;
       }
@@ -17723,9 +18978,9 @@ var AgentStore = class {
   async findAgentFiles(directory) {
     const files = [];
     try {
-      const entries = await fs12.readdir(directory, { withFileTypes: true });
+      const entries = await fs13.readdir(directory, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path16.join(directory, entry.name);
+        const fullPath = path18.join(directory, entry.name);
         if (entry.isDirectory()) {
           const subFiles = await this.findAgentFiles(fullPath);
           files.push(...subFiles);
@@ -17742,10 +18997,10 @@ var AgentStore = class {
    * Parse a single agent markdown file
    */
   async parseAgentFile(filePath, source) {
-    const content = await fs12.readFile(filePath, "utf-8");
+    const content = await fs13.readFile(filePath, "utf-8");
     const { data: frontmatter, content: body } = matter2(content);
     const parsed = AgentFrontmatterSchema.parse(frontmatter);
-    const name = path16.basename(filePath, ".md");
+    const name = path18.basename(filePath, ".md");
     const modelInput = parsed.model || DEFAULT_AGENT_MODEL;
     const resolution = resolveModelAlias(modelInput, name, filePath);
     if (!resolution.resolved && resolution.warning) {
@@ -17825,16 +19080,16 @@ var AgentStore = class {
    */
   async createAgentFile(name, isGlobal = false, useClaude = true) {
     const targetDir = isGlobal ? useClaude ? this.globalClaudeAgentsDir : this.globalB4MAgentsDir : useClaude ? this.projectClaudeAgentsDir : this.projectB4MAgentsDir;
-    const filePath = path16.join(targetDir, `${name}.md`);
+    const filePath = path18.join(targetDir, `${name}.md`);
     try {
-      await fs12.access(filePath);
+      await fs13.access(filePath);
       throw new Error(`Agent file already exists: ${filePath}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
     }
-    await fs12.mkdir(targetDir, { recursive: true });
+    await fs13.mkdir(targetDir, { recursive: true });
     const template = `---
 description: ${name} agent description
 model: claude-3-5-haiku-20241022
@@ -17869,7 +19124,7 @@ You are a ${name} specialist. Your job is to [describe primary task].
 ## Output Format
 Describe the expected output format here.
 `;
-    await fs12.writeFile(filePath, template, "utf-8");
+    await fs13.writeFile(filePath, template, "utf-8");
     return filePath;
   }
   /**
@@ -18313,8 +19568,8 @@ function createBackgroundAgentTools(manager) {
         case "queued":
           return `Agent "${job.agentName}" is queued (waiting for a concurrency slot). Task: ${job.task}`;
         case "running": {
-          const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
-          return `Agent "${job.agentName}" is still running (${elapsed}s elapsed). Task: ${job.task}`;
+          const elapsed2 = Math.round((Date.now() - job.startTime) / 1e3);
+          return `Agent "${job.agentName}" is still running (${elapsed2}s elapsed). Task: ${job.task}`;
         }
         case "completed": {
           const result = manager.getResult(job_id);
@@ -18346,7 +19601,7 @@ function createBackgroundAgentTools(manager) {
       const jobs = manager.listJobs();
       if (jobs.length === 0) return "No background agents.";
       return jobs.map((job) => {
-        const elapsed = Math.round(((job.endTime || Date.now()) - job.startTime) / 1e3);
+        const elapsed2 = Math.round(((job.endTime || Date.now()) - job.startTime) / 1e3);
         const statusIcons = {
           queued: "\u{1F550}",
           running: "\u23F3",
@@ -18355,7 +19610,7 @@ function createBackgroundAgentTools(manager) {
           cancelled: "\u{1F6AB}"
         };
         const statusIcon = statusIcons[job.status] || "\u2753";
-        return `${statusIcon} [${job.id}] ${job.agentName} (${job.status}, ${elapsed}s) - ${job.task.slice(0, 80)}`;
+        return `${statusIcon} [${job.id}] ${job.agentName} (${job.status}, ${elapsed2}s) - ${job.task.slice(0, 80)}`;
       }).join("\n");
     },
     toolSchema: {
@@ -18522,7 +19777,7 @@ function createTodoStore(onUpdate) {
 
 // src/tools/findDefinitionTool.ts
 import { stat as stat3 } from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { createRequire as createRequire2 } from "module";
@@ -18543,8 +19798,8 @@ var ALL_KEYWORDS = Object.values(KIND_KEYWORDS).flat();
 function getRipgrepPath2() {
   try {
     const ripgrepPath = require3.resolve("@vscode/ripgrep");
-    const ripgrepDir = path17.dirname(ripgrepPath);
-    return path17.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
+    const ripgrepDir = path19.dirname(ripgrepPath);
+    return path19.join(ripgrepDir, "..", "bin", "rg" + (process.platform === "win32" ? ".exe" : ""));
   } catch {
     throw new Error(
       "ripgrep is not available. Please install @vscode/ripgrep: pnpm add @vscode/ripgrep --filter @bike4mind/services"
@@ -18552,10 +19807,10 @@ function getRipgrepPath2() {
   }
 }
 function isPathWithinWorkspace2(targetPath, baseCwd) {
-  const resolvedTarget = path17.resolve(targetPath);
-  const resolvedBase = path17.resolve(baseCwd);
-  const relativePath = path17.relative(resolvedBase, resolvedTarget);
-  return !relativePath.startsWith("..") && !path17.isAbsolute(relativePath);
+  const resolvedTarget = path19.resolve(targetPath);
+  const resolvedBase = path19.resolve(baseCwd);
+  const relativePath = path19.relative(resolvedBase, resolvedTarget);
+  return !relativePath.startsWith("..") && !path19.isAbsolute(relativePath);
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -18588,7 +19843,7 @@ async function findDefinitions(params) {
     throw new Error("symbol_name is required");
   }
   const baseCwd = process.cwd();
-  const targetDir = search_path ? path17.resolve(baseCwd, search_path) : baseCwd;
+  const targetDir = search_path ? path19.resolve(baseCwd, search_path) : baseCwd;
   if (!isPathWithinWorkspace2(targetDir, baseCwd)) {
     throw new Error(`Path validation failed: "${search_path}" resolves outside the allowed workspace directory`);
   }
@@ -18643,7 +19898,7 @@ async function findDefinitions(params) {
         const lineText = match.data.lines.text.trimEnd();
         if (isLikelyDefinition(lineText)) {
           allMatches.push({
-            filePath: path17.relative(targetDir, match.data.path.text) || path17.basename(match.data.path.text),
+            filePath: path19.relative(targetDir, match.data.path.text) || path19.basename(match.data.path.text),
             lineNumber: match.data.line_number,
             line: lineText
           });
@@ -18721,8 +19976,8 @@ function createFindDefinitionTool() {
 }
 
 // src/tools/getFileStructure/index.ts
-import { existsSync as existsSync10, promises as fs13, statSync as statSync6 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync12, promises as fs14, statSync as statSync6 } from "fs";
+import path20 from "path";
 
 // src/tools/getFileStructure/formatter.ts
 var SECTIONS = [
@@ -18759,35 +20014,35 @@ function formatSection(lines, title, items, format) {
 }
 
 // src/tools/getFileStructure/index.ts
-var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
+var MAX_FILE_SIZE4 = 10 * 1024 * 1024;
 function createGetFileStructureTool() {
   return {
     toolFn: async (value) => {
       const params = value;
       try {
         const cwd = process.cwd();
-        const resolvedPath = path18.resolve(cwd, params.path);
+        const resolvedPath = path20.resolve(cwd, params.path);
         if (!resolvedPath.startsWith(cwd)) {
           return "Error: Access denied - cannot read files outside of current working directory";
         }
-        if (!existsSync10(resolvedPath)) {
+        if (!existsSync12(resolvedPath)) {
           return `Error: File not found: ${params.path}`;
         }
         const stats = statSync6(resolvedPath);
         if (stats.isDirectory()) {
           return `Error: Path is a directory, not a file: ${params.path}`;
         }
-        if (stats.size > MAX_FILE_SIZE3) {
-          return `Error: File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max: ${MAX_FILE_SIZE3 / 1024 / 1024}MB`;
+        if (stats.size > MAX_FILE_SIZE4) {
+          return `Error: File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Max: ${MAX_FILE_SIZE4 / 1024 / 1024}MB`;
         }
-        const ext = path18.extname(resolvedPath).toLowerCase();
+        const ext = path20.extname(resolvedPath).toLowerCase();
         const { getLanguageForExtension, parseFileStructure, getSupportedLanguages } = await import("./treeSitterEngine-4SGFQDY3.js");
         const languageId = getLanguageForExtension(ext);
         if (!languageId) {
           const supported = getSupportedLanguages();
           return `Error: Unsupported file type "${ext}". Supported languages: ${supported.join(", ")}`;
         }
-        const sourceCode = await fs13.readFile(resolvedPath, "utf-8");
+        const sourceCode = await fs14.readFile(resolvedPath, "utf-8");
         const lineCount = sourceCode.split("\n").length;
         const items = await parseFileStructure(sourceCode, languageId);
         return formatStructureOutput(params.path, items, stats.size, lineCount);
@@ -18849,7 +20104,8 @@ function CliApp() {
     abortController: null,
     contextContent: "",
     backgroundManager: null,
-    wsManager: null
+    wsManager: null,
+    checkpointStore: null
   });
   const [isInitialized, setIsInitialized] = useState10(false);
   const [initError, setInitError] = useState10(null);
@@ -19103,6 +20359,12 @@ function CliApp() {
           enqueuePermissionPrompt(prompt);
         });
       };
+      const checkpointProjectDir = state.configStore.getProjectConfigDir() || process.cwd();
+      const checkpointStore = new CheckpointStore(checkpointProjectDir);
+      try {
+        await checkpointStore.init(newSession.id);
+      } catch {
+      }
       const agentContext = {
         currentAgent: null,
         observationQueue: []
@@ -19115,7 +20377,10 @@ function CliApp() {
         promptFn,
         agentContext,
         state.configStore,
-        apiClient
+        apiClient,
+        void 0,
+        // toolFilter
+        checkpointStore
       );
       startupLog.push(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
@@ -19146,7 +20411,8 @@ function CliApp() {
         apiClient,
         agentStore,
         customCommandStore: state.customCommandStore,
-        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
+        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
+        checkpointStore
       });
       const backgroundManager = new BackgroundAgentManager(orchestrator);
       backgroundManager.setOnStatusChange((job) => {
@@ -19269,8 +20535,10 @@ function CliApp() {
         // Store raw context for compact instructions
         backgroundManager,
         // Store for grouped notification turn tracking
-        wsManager
+        wsManager,
         // WebSocket connection manager (null if using SSE fallback)
+        checkpointStore
+        // File change checkpointing for undo/restore
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -19963,6 +21231,10 @@ Available commands:
   /exit - Exit the CLI
   /clear - Start a new session
   /rewind - Rewind conversation to a previous point
+  /undo - Undo the last file change
+  /checkpoints - List available file restore points
+  /restore <n> - Restore files to a specific checkpoint
+  /diff [n] - Show diff between current state and a checkpoint
   /login - Authenticate with your B4M account
   /logout - Clear authentication and sign out
   /whoami - Show current authenticated user
@@ -20055,6 +21327,9 @@ Keyboard Shortcuts:
           }
           await logger.initialize(loadedSession.id);
           logger.debug("=== Session Resumed ===");
+          if (state.checkpointStore) {
+            state.checkpointStore.setSessionId(loadedSession.id);
+          }
           setState((prev) => ({ ...prev, session: loadedSession }));
           setStoreSession(loadedSession);
           useCliStore.getState().clearPendingMessages();
@@ -20293,6 +21568,9 @@ Keyboard Shortcuts:
         };
         await logger.initialize(newSession.id);
         logger.debug("=== New Session Started via /clear ===");
+        if (state.checkpointStore) {
+          state.checkpointStore.setSessionId(newSession.id);
+        }
         setState((prev) => ({ ...prev, session: newSession }));
         setStoreSession(newSession);
         useCliStore.getState().clearPendingMessages();
@@ -20303,8 +21581,7 @@ Keyboard Shortcuts:
 `);
         break;
       }
-      case "rewind":
-      case "undo": {
+      case "rewind": {
         if (!state.session) {
           console.log("No active session to rewind");
           return;
@@ -20363,6 +21640,103 @@ Keyboard Shortcuts:
         }));
         break;
       }
+      case "undo": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const undoCheckpoints = state.checkpointStore.listCheckpoints();
+        if (undoCheckpoints.length === 0) {
+          console.log("No checkpoints available. No file changes have been made yet.");
+          return;
+        }
+        try {
+          const restored = await state.checkpointStore.undoLast();
+          console.log(`
+\u2705 Restored ${restored.filePaths.length} file(s) to state before: ${restored.name}`);
+          for (const f of restored.filePaths) {
+            console.log(`  - ${f}`);
+          }
+          console.log("");
+        } catch (err) {
+          console.log(`Failed to undo: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
+      case "checkpoints": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const cpList = state.checkpointStore.listCheckpoints();
+        if (cpList.length === 0) {
+          console.log("No checkpoints yet. Checkpoints are created automatically before file changes.");
+          return;
+        }
+        console.log("\nCheckpoints (most recent first):\n");
+        cpList.forEach((cp, idx) => {
+          const ageMs = Date.now() - new Date(cp.timestamp).getTime();
+          const ageSec = Math.floor(ageMs / 1e3);
+          let age;
+          if (ageSec < 60) age = `${ageSec}s ago`;
+          else if (ageSec < 3600) age = `${Math.floor(ageSec / 60)}m ago`;
+          else age = `${Math.floor(ageSec / 3600)}h ago`;
+          console.log(`  ${idx + 1}. ${cp.name} (${age}) - ${cp.filePaths.length} file(s)`);
+        });
+        console.log("\nUse /restore <number> to restore, /diff <number> to see changes.\n");
+        break;
+      }
+      case "restore": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const restoreTarget = args[0];
+        if (!restoreTarget) {
+          console.log("Usage: /restore <checkpoint-number>");
+          console.log("Use /checkpoints to list available restore points.");
+          return;
+        }
+        const restoreNum = parseInt(restoreTarget, 10);
+        if (isNaN(restoreNum) || restoreNum < 1) {
+          console.log("Please provide a valid checkpoint number. Use /checkpoints to list.");
+          return;
+        }
+        try {
+          const restoredCp = await state.checkpointStore.restoreCheckpoint(restoreNum);
+          console.log(`
+\u2705 Restored to checkpoint: ${restoredCp.name}`);
+          for (const f of restoredCp.filePaths) {
+            console.log(`  - ${f}`);
+          }
+          console.log("");
+        } catch (err) {
+          console.log(`Failed to restore: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
+      case "diff": {
+        if (!state.checkpointStore) {
+          console.log("Checkpointing not available.");
+          return;
+        }
+        const diffTarget = args[0] ? parseInt(args[0], 10) : 1;
+        if (isNaN(diffTarget) || diffTarget < 1) {
+          console.log("Usage: /diff [checkpoint-number] (defaults to 1, most recent)");
+          return;
+        }
+        try {
+          const diffOutput = state.checkpointStore.getCheckpointDiff(diffTarget);
+          if (!diffOutput.trim()) {
+            console.log("No differences found between checkpoint and current state.");
+          } else {
+            console.log(diffOutput);
+          }
+        } catch (err) {
+          console.log(`Failed to generate diff: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        break;
+      }
       case "usage": {
         const usageAuthTokens = await state.configStore.getAuthTokens();
         if (!usageAuthTokens || new Date(usageAuthTokens.expiresAt) <= /* @__PURE__ */ new Date()) {