@bike4mind/cli 0.2.31-b4m-cli-undo-command.19534 → 0.2.31-b4m-cli-undo-command.19598

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import "./chunk-GQGOWACU.js";
-import "./chunk-F4PXVLZX.js";
-import "./chunk-ERV5G6MX.js";
+import "./chunk-4P27WV34.js";
+import "./chunk-S6AUIWWB.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-JWJF6O4L.js";
+} from "./chunk-DQHCE3TN.js";
 import {
   ConfigStore,
   logger
@@ -16,7 +16,7 @@ import {
 import {
   checkForUpdate,
   package_default
-} from "./chunk-WVFOWKNW.js";
+} from "./chunk-BXNVLTPU.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -32,7 +32,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-3SPW5FYJ.js";
+} from "./chunk-PV6PZFPC.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -90,7 +90,7 @@ import {
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-NI22LIK3.js";
+} from "./chunk-PLA2VBQW.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
@@ -1368,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;
@@ -2912,13 +2912,16 @@ var CheckpointStore = class {
     try {
       let hasChanges = false;
       for (const filePath of filePaths) {
-        const absolutePath = path6.resolve(this.projectDir, filePath);
+        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.stat(absolutePath);
+          const stats = await fs5.lstat(absolutePath);
+          if (stats.isSymbolicLink()) {
+            continue;
+          }
           if (stats.size > MAX_FILE_SIZE2) {
             continue;
           }
@@ -2995,7 +2998,7 @@ var CheckpointStore = class {
       throw new Error(`Checkpoint #${index} not found. Use /checkpoints to see available restore points.`);
     }
     for (const filePath of checkpoint.filePaths) {
-      const absolutePath = path6.resolve(this.projectDir, filePath);
+      const absolutePath = this.validatePathWithinProject(filePath);
       try {
         const content = this.git("show", `${checkpoint.id}:${filePath}`);
         await fs5.mkdir(path6.dirname(absolutePath), { recursive: true });
@@ -3031,7 +3034,9 @@ var CheckpointStore = class {
     }
     const diffParts = [];
     for (const filePath of checkpoint.filePaths) {
-      const absolutePath = path6.resolve(this.projectDir, filePath);
+      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 {
@@ -3046,8 +3051,6 @@ var CheckpointStore = class {
         if (checkpointContent === currentContent) {
           continue;
         }
-        const tmpCheckpoint = path6.join(this.shadowRepoDir, ".diff-a");
-        const tmpCurrent = path6.join(this.shadowRepoDir, ".diff-b");
         writeFileSync(tmpCheckpoint, checkpointContent, "utf-8");
         writeFileSync(tmpCurrent, currentContent, "utf-8");
         try {
@@ -3070,12 +3073,16 @@ ${output}`);
             }
           }
         }
+      } catch {
+      } finally {
         try {
           unlinkSync(tmpCheckpoint);
+        } catch {
+        }
+        try {
           unlinkSync(tmpCurrent);
         } catch {
         }
-      } catch {
       }
     }
     return diffParts.join("\n");
@@ -3109,6 +3116,18 @@ ${output}`);
     }
   }
   // --- 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
    */
@@ -10531,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",
@@ -11196,6 +11216,351 @@ function constructSolution(allOps, pheromone, heuristic, rng) {
   return result;
 }
 
+// ../../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: {
@@ -11464,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: [
@@ -11538,7 +11902,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": {
@@ -11596,7 +11963,8 @@ var allSolvers = [
   simulatedAnnealingLargeSolver,
   tabuSolver,
   geneticAlgorithmSolver,
-  antColonySolver
+  antColonySolver,
+  highsSolver
 ];
 var solverRegistry = new Map(allSolvers.map((s) => [s.id, s]));
 function getSolver(id) {
@@ -11607,7 +11975,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 }
 ];
@@ -11632,11 +11999,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:
@@ -11701,6 +12074,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 = [
@@ -11925,14 +12873,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)}`;
       }
@@ -16733,6 +17682,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"
@@ -16943,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" },
@@ -17844,6 +18798,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",
@@ -18605,8 +19560,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);
@@ -18638,7 +19593,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",
@@ -18647,7 +19602,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: {