@bike4mind/cli 0.2.29 → 0.2.30-feat-quantum-optimize-architecture.19202

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-22VR7SKO.js";
+} from "./chunk-KKZY4BRH.js";
 import "./chunk-RUI6HNLO.js";
 import {
   ConfigStore,
@@ -15,8 +15,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-UYN4HMRF.js";
-import "./chunk-YQWFK5O2.js";
+import "./chunk-Z3I7SVZ6.js";
+import "./chunk-VRGHGJAL.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -28,7 +28,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-5J4RL57F.js";
+} from "./chunk-TSB6M7IB.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -83,8 +83,10 @@ import {
   VideoModels,
   XAI_IMAGE_MODELS,
   b4mLLMTools,
-  getMcpProviderMetadata
-} from "./chunk-TNFZP7FG.js";
+  getMcpProviderMetadata,
+  getViewById,
+  resolveNavigationIntents
+} from "./chunk-DUEP3HCS.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -3964,6 +3966,7 @@ var updateUserSchema = z7.object({
   preferredLanguage: z7.string().nullable().optional(),
   preferredContact: z7.string().nullable().optional(),
   preferredVoice: z7.string().nullable().optional(),
+  preferredReasoningEffort: z7.enum(["auto", "none", "minimal", "low", "medium", "high", "xhigh"]).nullable().optional(),
   tshirtSize: z7.string().nullable().optional(),
   geoLocation: z7.string().nullable().optional(),
   lastNotebookId: z7.string().nullable().optional(),
@@ -9000,8 +9003,8 @@ var getHeliocentricCoords = (planet, T) => {
   const sinNode = Math.sin(longNode);
   const x = r * (cosNode * cosOmega - sinNode * sinOmega * cosI);
   const y = r * (sinNode * cosOmega + cosNode * sinOmega * cosI);
-  const z147 = r * sinOmega * sinI;
-  return { x, y, z: z147, r };
+  const z148 = r * sinOmega * sinI;
+  return { x, y, z: z148, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -9885,13 +9888,13 @@ function formatSearchResults(files) {
     const notes = file.notes ? `
    Notes: ${file.notes}` : "";
     const fileType = file.type || "FILE";
-    return `${index + 1}. **${file.fileName}**
+    return `${index + 1}. **${file.fileName}** (ID: ${file.id})
    Type: ${fileType} | MIME: ${file.mimeType}
    Tags: ${tags}${notes}`;
   });
   return `Found ${files.length} document(s) in your knowledge base:
 
-` + formattedFiles.join("\n\n") + "\n\n*To use these documents in your conversation, you can ask me to reference specific files by name.*";
+` + formattedFiles.join("\n\n") + "\n\n*Use retrieve_knowledge_content with a file ID or tags to read the actual document content.*";
 }
 var knowledgeBaseSearchTool = {
   name: "search_knowledge_base",
@@ -9918,6 +9921,8 @@ var knowledgeBaseSearchTool = {
           by: "fileName",
           direction: "asc"
         }, {
+          textSearch: true,
+          // Search across fileName + tags + notes for better recall
           includeShared: true,
           // Include owned + explicitly shared + org-shared files
           userGroups: context.user.groups || []
@@ -9932,18 +9937,18 @@ var knowledgeBaseSearchTool = {
     },
     toolSchema: {
       name: "search_knowledge_base",
-      description: "Search the user's uploaded knowledge base (fab files). Returns relevant documents from the user's own files, organization-shared files, and files explicitly shared with them. Use this tool when the user asks about their own documents, uploaded files, or organization knowledge.",
+      description: "Search the user's uploaded knowledge base (fab files). Searches across file names, tags, and notes for broad recall. Returns relevant documents from the user's own files, organization-shared files, and files explicitly shared with them. Use this tool when the user asks about their own documents, uploaded files, or organization knowledge.",
       parameters: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "The search query to find relevant documents by filename or content"
+            description: "The search query to find relevant documents. Matches against file names, tags, and notes."
           },
           tags: {
             type: "array",
             items: { type: "string" },
-            description: "Optional: filter results to only include files with these tags"
+            description: 'Optional: filter results by tag names. Supports partial matching. For optimization docs, use tags like "opti:family:scheduling", "opti:QUBO", "opti:solver:highs", etc. Any matching tag qualifies the file.'
           },
           file_type: {
             type: "string",
@@ -9963,6 +9968,1235 @@ var knowledgeBaseSearchTool = {
   })
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/knowledgeBaseRetrieve/index.js
+var DEFAULT_MAX_CHARS = 8e3;
+var ABSOLUTE_MAX_CHARS = 16e3;
+var knowledgeBaseRetrieveTool = {
+  name: "retrieve_knowledge_content",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { file_id, tags, query, max_chars } = params;
+      const charBudget = Math.min(max_chars ?? DEFAULT_MAX_CHARS, ABSOLUTE_MAX_CHARS);
+      context.logger.log("\u{1F4D6} Knowledge Retrieve: params", { file_id, tags, query, max_chars: charBudget });
+      if (!file_id && !tags?.length && !query) {
+        return "Error: You must provide at least one of file_id, tags, or query.";
+      }
+      if (!context.db.fabfiles) {
+        context.logger.error("\u274C Knowledge Retrieve: fabfiles repository not available");
+        return "Knowledge base retrieval is not available at this time.";
+      }
+      if (!context.db.fabfilechunks) {
+        context.logger.error("\u274C Knowledge Retrieve: fabfilechunks repository not available");
+        return "Knowledge base retrieval is not available at this time (chunk reader unavailable).";
+      }
+      try {
+        let files = [];
+        if (file_id) {
+          const file = await context.db.fabfiles.findByIdAndUserId(file_id, context.userId);
+          if (file) {
+            files = [file];
+          } else {
+            const searchResults = await context.db.fabfiles.search(context.userId, file_id, { tags: [], shared: false }, { page: 1, limit: 1 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+            files = searchResults.data;
+          }
+          if (files.length === 0) {
+            return `No document found with ID "${file_id}". The file may not exist or you may not have access to it. Try using search_knowledge_base to find the correct file ID.`;
+          }
+        }
+        if (files.length === 0 && (tags?.length || query)) {
+          const searchResults = await context.db.fabfiles.search(context.userId, query || "", { tags: tags || [], shared: false }, { page: 1, limit: 5 }, { by: "fileName", direction: "asc" }, { textSearch: true, includeShared: true, userGroups: context.user.groups || [] });
+          files = searchResults.data;
+          if (files.length === 0) {
+            const searchDesc = [
+              query && `query "${query}"`,
+              tags?.length && `tags [${tags.join(", ")}]`
+            ].filter(Boolean).join(" and ");
+            return `No documents found matching ${searchDesc}. Try broadening your search with search_knowledge_base.`;
+          }
+        }
+        let totalCharsUsed = 0;
+        const sections = [];
+        let filesRetrieved = 0;
+        for (const file of files) {
+          if (totalCharsUsed >= charBudget)
+            break;
+          const chunks = await context.db.fabfilechunks.findByFabFileId(file.id);
+          if (chunks.length === 0) {
+            context.logger.log(`\u{1F4D6} Knowledge Retrieve: No chunks for file ${file.fileName} (${file.id})`);
+            continue;
+          }
+          const fullText = chunks.map((c) => c.text).join("\n");
+          const remainingBudget = charBudget - totalCharsUsed;
+          const truncated = fullText.length > remainingBudget;
+          const content = truncated ? fullText.slice(0, remainingBudget) : fullText;
+          const fileTags = file.tags?.map((t) => t.name).join(", ") || "none";
+          const charLabel = truncated ? `${content.length} (truncated from ${fullText.length})` : `${content.length}`;
+          sections.push(`### ${file.fileName} (ID: ${file.id})
+Tags: ${fileTags}
+Chunks: ${chunks.length} | Characters: ${charLabel}
+---
+` + content);
+          totalCharsUsed += content.length;
+          filesRetrieved++;
+        }
+        if (filesRetrieved === 0) {
+          return "Found matching documents but they have no indexed content. The files may not have been processed yet.";
+        }
+        const header = `Retrieved content from ${filesRetrieved} of ${files.length} document(s):
+`;
+        return header + "\n" + sections.join("\n\n---\n\n");
+      } catch (error) {
+        context.logger.error("\u274C Knowledge Retrieve: Error during retrieval:", error);
+        return "An error occurred while retrieving document content. Please try again.";
+      }
+    },
+    toolSchema: {
+      name: "retrieve_knowledge_content",
+      description: "Read the actual text content of knowledge base documents. Use this after search_knowledge_base to read documents by file ID, or provide tags/query to find and read documents in one step. Returns the full text content (up to the character budget) for grounding your responses in the user's curated knowledge.",
+      parameters: {
+        type: "object",
+        properties: {
+          file_id: {
+            type: "string",
+            description: "The file ID to retrieve (from search_knowledge_base results). Most efficient for single-document retrieval."
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Filter documents by tags. For optimization docs, use tags like "opti:family:scheduling", "opti:solver:highs", etc.'
+          },
+          query: {
+            type: "string",
+            description: "Search query to find documents. Can be combined with tags for more targeted retrieval."
+          },
+          max_chars: {
+            type: "number",
+            description: "Maximum characters of content to return (default: 8000, max: 16000). Lower values for quick lookups, higher for detailed reading.",
+            minimum: 500,
+            maximum: 16e3
+          }
+        }
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/quantum/dist/src/types.js
+import { z as z139 } from "zod";
+var OperationSchema = z139.object({
+  jobId: z139.number(),
+  machineId: z139.number(),
+  duration: z139.number().positive()
+});
+var JobSchema = z139.object({
+  id: z139.number(),
+  name: z139.string(),
+  operations: z139.array(OperationSchema)
+});
+var MachineSchema = z139.object({
+  id: z139.number(),
+  name: z139.string()
+});
+var SchedulingProblemSchema = z139.object({
+  name: z139.string(),
+  description: z139.string().optional(),
+  jobs: z139.array(JobSchema),
+  machines: z139.array(MachineSchema)
+});
+var SolverIdSchema = z139.enum([
+  "greedy",
+  "naive",
+  "random-restart",
+  "simulated-annealing",
+  "simulated-annealing-medium",
+  "simulated-annealing-large",
+  "tabu",
+  "genetic-algorithm",
+  "ant-colony",
+  "highs"
+]);
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/greedy-solver.js
+var greedySolver = {
+  id: "greedy",
+  name: "Greedy (Earliest Start)",
+  description: "Schedules each operation at the earliest available time on its machine, respecting job ordering.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const machineAvailableAt = /* @__PURE__ */ new Map();
+    for (const machine of problem.machines) {
+      machineAvailableAt.set(machine.id, 0);
+    }
+    const jobCompletedAt = /* @__PURE__ */ new Map();
+    for (const job of problem.jobs) {
+      jobCompletedAt.set(job.id, 0);
+    }
+    const schedule = [];
+    const totalOps = problem.jobs.reduce((sum2, job) => sum2 + job.operations.length, 0);
+    let opsScheduled = 0;
+    for (const job of problem.jobs) {
+      for (let opIndex = 0; opIndex < job.operations.length; opIndex++) {
+        const op = job.operations[opIndex];
+        const machineReady = machineAvailableAt.get(op.machineId) ?? 0;
+        const jobReady = jobCompletedAt.get(job.id) ?? 0;
+        const opStart = Math.max(machineReady, jobReady);
+        const opEnd = opStart + op.duration;
+        schedule.push({
+          jobId: job.id,
+          machineId: op.machineId,
+          operationIndex: opIndex,
+          startTime: opStart,
+          endTime: opEnd
+        });
+        machineAvailableAt.set(op.machineId, opEnd);
+        jobCompletedAt.set(job.id, opEnd);
+        opsScheduled++;
+        if (options?.onProgress) {
+          options.onProgress({
+            solverId: "greedy",
+            percentage: Math.round(opsScheduled / totalOps * 100),
+            bestMakespan: opEnd,
+            currentIteration: opsScheduled,
+            totalIterations: totalOps
+          });
+        }
+      }
+    }
+    const makespan = Math.max(...schedule.map((op) => op.endTime));
+    const elapsedMs = performance.now() - startTime;
+    return {
+      solverId: "greedy",
+      solverName: "Greedy (Earliest Start)",
+      makespan,
+      schedule,
+      elapsedMs,
+      iterations: totalOps
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/schedule-utils.js
+function buildOperationList(problem) {
+  const ops = [];
+  for (const job of problem.jobs) {
+    for (let i = 0; i < job.operations.length; i++) {
+      ops.push({ jobId: job.id, opIndex: i });
+    }
+  }
+  return ops;
+}
+function decodePermutation(permutation, problem) {
+  const schedule = [];
+  const machineAvailableAt = /* @__PURE__ */ new Map();
+  const jobCompletedAt = /* @__PURE__ */ new Map();
+  const jobNextOp = /* @__PURE__ */ new Map();
+  for (const machine of problem.machines) {
+    machineAvailableAt.set(machine.id, 0);
+  }
+  for (const job of problem.jobs) {
+    jobCompletedAt.set(job.id, 0);
+    jobNextOp.set(job.id, 0);
+  }
+  const remaining = [...permutation];
+  const maxPasses = remaining.length * remaining.length;
+  let passes = 0;
+  while (remaining.length > 0 && passes < maxPasses) {
+    let scheduled = false;
+    for (let i = 0; i < remaining.length; i++) {
+      const ref = remaining[i];
+      const nextOp = jobNextOp.get(ref.jobId) ?? 0;
+      if (ref.opIndex !== nextOp)
+        continue;
+      const job = problem.jobs.find((j) => j.id === ref.jobId);
+      const op = job.operations[ref.opIndex];
+      const machineReady = machineAvailableAt.get(op.machineId) ?? 0;
+      const jobReady = jobCompletedAt.get(ref.jobId) ?? 0;
+      const start = Math.max(machineReady, jobReady);
+      const end = start + op.duration;
+      schedule.push({
+        jobId: ref.jobId,
+        machineId: op.machineId,
+        operationIndex: ref.opIndex,
+        startTime: start,
+        endTime: end
+      });
+      machineAvailableAt.set(op.machineId, end);
+      jobCompletedAt.set(ref.jobId, end);
+      jobNextOp.set(ref.jobId, nextOp + 1);
+      remaining.splice(i, 1);
+      scheduled = true;
+      break;
+    }
+    if (!scheduled) {
+      remaining.push(remaining.shift());
+    }
+    passes++;
+  }
+  return schedule;
+}
+function computeMakespan(schedule) {
+  if (schedule.length === 0)
+    return 0;
+  return Math.max(...schedule.map((op) => op.endTime));
+}
+function randomPermutation(problem, rng = Math.random) {
+  const ops = buildOperationList(problem);
+  for (let i = ops.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [ops[i], ops[j]] = [ops[j], ops[i]];
+  }
+  return ops;
+}
+function swapNeighbor(perm, rng = Math.random) {
+  const newPerm = [...perm];
+  const i = Math.floor(rng() * newPerm.length);
+  let j = Math.floor(rng() * (newPerm.length - 1));
+  if (j >= i)
+    j++;
+  [newPerm[i], newPerm[j]] = [newPerm[j], newPerm[i]];
+  return newPerm;
+}
+function createRng(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/naive-solver.js
+var MAX_PERMUTATIONS = 40320;
+function* permutations(arr) {
+  if (arr.length <= 1) {
+    yield [...arr];
+    return;
+  }
+  for (let i = 0; i < arr.length; i++) {
+    const rest = [...arr.slice(0, i), ...arr.slice(i + 1)];
+    for (const perm of permutations(rest)) {
+      yield [arr[i], ...perm];
+    }
+  }
+}
+var naiveSolver = {
+  id: "naive",
+  name: "Naive (Brute Force)",
+  description: "Evaluates all permutations to find the optimal schedule. Only feasible for small problems.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const ops = buildOperationList(problem);
+    const totalPerms = factorial(ops.length);
+    const cappedTotal = Math.min(totalPerms, MAX_PERMUTATIONS);
+    let bestMakespan = Infinity;
+    let bestSchedule = decodePermutation(ops, problem);
+    let count = 0;
+    for (const perm of permutations(ops)) {
+      if (count >= MAX_PERMUTATIONS)
+        break;
+      const schedule = decodePermutation(perm, problem);
+      const makespan = computeMakespan(schedule);
+      if (makespan < bestMakespan) {
+        bestMakespan = makespan;
+        bestSchedule = schedule;
+      }
+      count++;
+      if (options?.onProgress && count % 100 === 0) {
+        options.onProgress({
+          solverId: "naive",
+          percentage: Math.min(99, Math.round(count / cappedTotal * 100)),
+          bestMakespan,
+          currentIteration: count,
+          totalIterations: cappedTotal
+        });
+      }
+    }
+    options?.onProgress?.({
+      solverId: "naive",
+      percentage: 100,
+      bestMakespan,
+      currentIteration: count,
+      totalIterations: cappedTotal
+    });
+    return {
+      solverId: "naive",
+      solverName: "Naive (Brute Force)",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: count
+    };
+  }
+};
+function factorial(n) {
+  if (n <= 1)
+    return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++)
+    result *= i;
+  return result;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/random-restart-solver.js
+var RESTARTS = 50;
+var HILL_CLIMB_ITERATIONS = 500;
+var randomRestartSolver = {
+  id: "random-restart",
+  name: "Random Restart Hill Climbing",
+  description: "Multiple random starts with local search improvement via operation swaps.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 1e4;
+    const rng = createRng(42);
+    let globalBestMakespan = Infinity;
+    let globalBestSchedule = decodePermutation(randomPermutation(problem, rng), problem);
+    let totalIterations = 0;
+    for (let restart = 0; restart < RESTARTS; restart++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      let currentPerm = randomPermutation(problem, rng);
+      let currentSchedule = decodePermutation(currentPerm, problem);
+      let currentMakespan = computeMakespan(currentSchedule);
+      for (let i = 0; i < HILL_CLIMB_ITERATIONS; i++) {
+        if (performance.now() - startTime > timeoutMs)
+          break;
+        const neighborPerm = swapNeighbor(currentPerm, rng);
+        const neighborSchedule = decodePermutation(neighborPerm, problem);
+        const neighborMakespan = computeMakespan(neighborSchedule);
+        if (neighborMakespan < currentMakespan) {
+          currentPerm = neighborPerm;
+          currentSchedule = neighborSchedule;
+          currentMakespan = neighborMakespan;
+        }
+        totalIterations++;
+      }
+      if (currentMakespan < globalBestMakespan) {
+        globalBestMakespan = currentMakespan;
+        globalBestSchedule = currentSchedule;
+      }
+      options?.onProgress?.({
+        solverId: "random-restart",
+        percentage: Math.round((restart + 1) / RESTARTS * 100),
+        bestMakespan: globalBestMakespan,
+        currentIteration: restart + 1,
+        totalIterations: RESTARTS
+      });
+    }
+    return {
+      solverId: "random-restart",
+      solverName: "Random Restart Hill Climbing",
+      makespan: globalBestMakespan,
+      schedule: globalBestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: totalIterations
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/simulated-annealing-solver.js
+var SA_CONFIGS = [
+  {
+    id: "simulated-annealing",
+    name: "Simulated Annealing (S)",
+    description: "Fast simulated annealing with 5,000 iterations. Good for quick estimates.",
+    initialTemp: 100,
+    coolingRate: 0.995,
+    iterations: 5e3
+  },
+  {
+    id: "simulated-annealing-medium",
+    name: "Simulated Annealing (M)",
+    description: "Medium simulated annealing with 25,000 iterations. Balanced speed/quality.",
+    initialTemp: 200,
+    coolingRate: 0.9985,
+    iterations: 25e3
+  },
+  {
+    id: "simulated-annealing-large",
+    name: "Simulated Annealing (L)",
+    description: "Long simulated annealing with 100,000 iterations. Best solution quality.",
+    initialTemp: 500,
+    coolingRate: 0.99995,
+    iterations: 1e5
+  }
+];
+function createSASolver(config) {
+  return {
+    id: config.id,
+    name: config.name,
+    description: config.description,
+    async solve(problem, options) {
+      const startTime = performance.now();
+      const timeoutMs = options?.timeoutMs ?? 3e4;
+      const rng = createRng(42);
+      let currentPerm = randomPermutation(problem, rng);
+      let currentSchedule = decodePermutation(currentPerm, problem);
+      let currentMakespan = computeMakespan(currentSchedule);
+      let bestPerm = currentPerm;
+      let bestSchedule = currentSchedule;
+      let bestMakespan = currentMakespan;
+      let temperature = config.initialTemp;
+      const progressInterval = Math.max(1, Math.floor(config.iterations / 100));
+      for (let i = 0; i < config.iterations; i++) {
+        if (performance.now() - startTime > timeoutMs)
+          break;
+        const neighborPerm = swapNeighbor(currentPerm, rng);
+        const neighborSchedule = decodePermutation(neighborPerm, problem);
+        const neighborMakespan = computeMakespan(neighborSchedule);
+        const delta = neighborMakespan - currentMakespan;
+        if (delta < 0 || rng() < Math.exp(-delta / temperature)) {
+          currentPerm = neighborPerm;
+          currentSchedule = neighborSchedule;
+          currentMakespan = neighborMakespan;
+          if (currentMakespan < bestMakespan) {
+            bestPerm = currentPerm;
+            bestSchedule = currentSchedule;
+            bestMakespan = currentMakespan;
+          }
+        }
+        temperature *= config.coolingRate;
+        if (options?.onProgress && i % progressInterval === 0) {
+          options.onProgress({
+            solverId: config.id,
+            percentage: Math.round(i / config.iterations * 100),
+            bestMakespan,
+            currentIteration: i,
+            totalIterations: config.iterations
+          });
+        }
+      }
+      options?.onProgress?.({
+        solverId: config.id,
+        percentage: 100,
+        bestMakespan,
+        currentIteration: config.iterations,
+        totalIterations: config.iterations
+      });
+      return {
+        solverId: config.id,
+        solverName: config.name,
+        makespan: bestMakespan,
+        schedule: bestSchedule,
+        elapsedMs: performance.now() - startTime,
+        iterations: config.iterations
+      };
+    }
+  };
+}
+var simulatedAnnealingSolver = createSASolver(SA_CONFIGS[0]);
+var simulatedAnnealingMediumSolver = createSASolver(SA_CONFIGS[1]);
+var simulatedAnnealingLargeSolver = createSASolver(SA_CONFIGS[2]);
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/tabu-solver.js
+var ITERATIONS = 1e4;
+var TABU_TENURE = 15;
+var NEIGHBORHOOD_SIZE = 20;
+var tabuSolver = {
+  id: "tabu",
+  name: "Tabu Search",
+  description: "Hill climbing with short-term memory to avoid revisiting recent solutions.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 15e3;
+    const rng = createRng(42);
+    let currentPerm = randomPermutation(problem, rng);
+    let currentSchedule = decodePermutation(currentPerm, problem);
+    let currentMakespan = computeMakespan(currentSchedule);
+    let bestSchedule = currentSchedule;
+    let bestMakespan = currentMakespan;
+    const tabuList = /* @__PURE__ */ new Map();
+    const progressInterval = Math.max(1, Math.floor(ITERATIONS / 100));
+    for (let iter = 0; iter < ITERATIONS; iter++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      let bestNeighborPerm = null;
+      let bestNeighborMakespan = Infinity;
+      let bestSwapKey = "";
+      for (let n = 0; n < NEIGHBORHOOD_SIZE; n++) {
+        const i = Math.floor(rng() * currentPerm.length);
+        let j = Math.floor(rng() * (currentPerm.length - 1));
+        if (j >= i)
+          j++;
+        const swapKey = `${Math.min(i, j)},${Math.max(i, j)}`;
+        const candidatePerm = [...currentPerm];
+        [candidatePerm[i], candidatePerm[j]] = [candidatePerm[j], candidatePerm[i]];
+        const candidateSchedule = decodePermutation(candidatePerm, problem);
+        const candidateMakespan = computeMakespan(candidateSchedule);
+        const isTabu = (tabuList.get(swapKey) ?? 0) > iter;
+        const aspirationMet = candidateMakespan < bestMakespan;
+        if ((!isTabu || aspirationMet) && candidateMakespan < bestNeighborMakespan) {
+          bestNeighborPerm = candidatePerm;
+          bestNeighborMakespan = candidateMakespan;
+          bestSwapKey = swapKey;
+        }
+      }
+      if (bestNeighborPerm) {
+        currentPerm = bestNeighborPerm;
+        currentSchedule = decodePermutation(currentPerm, problem);
+        currentMakespan = bestNeighborMakespan;
+        tabuList.set(bestSwapKey, iter + TABU_TENURE);
+        if (currentMakespan < bestMakespan) {
+          bestMakespan = currentMakespan;
+          bestSchedule = currentSchedule;
+        }
+      }
+      if (iter % 100 === 0) {
+        for (const [key, expiry] of tabuList) {
+          if (expiry <= iter)
+            tabuList.delete(key);
+        }
+      }
+      if (options?.onProgress && iter % progressInterval === 0) {
+        options.onProgress({
+          solverId: "tabu",
+          percentage: Math.round(iter / ITERATIONS * 100),
+          bestMakespan,
+          currentIteration: iter,
+          totalIterations: ITERATIONS
+        });
+      }
+    }
+    options?.onProgress?.({
+      solverId: "tabu",
+      percentage: 100,
+      bestMakespan,
+      currentIteration: ITERATIONS,
+      totalIterations: ITERATIONS
+    });
+    return {
+      solverId: "tabu",
+      solverName: "Tabu Search",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: ITERATIONS
+    };
+  }
+};
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/genetic-algorithm-solver.js
+var POPULATION_SIZE = 50;
+var GENERATIONS = 200;
+var TOURNAMENT_SIZE = 5;
+var MUTATION_RATE = 0.15;
+var geneticAlgorithmSolver = {
+  id: "genetic-algorithm",
+  name: "Genetic Algorithm",
+  description: "Population-based search with tournament selection, crossover, and mutation.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 2e4;
+    const rng = createRng(42);
+    let population = [];
+    for (let i = 0; i < POPULATION_SIZE; i++) {
+      const perm = randomPermutation(problem, rng);
+      const schedule = decodePermutation(perm, problem);
+      const makespan = computeMakespan(schedule);
+      population.push({ perm, makespan });
+    }
+    let bestIndividual = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
+    for (let gen = 0; gen < GENERATIONS; gen++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      const newPopulation = [];
+      newPopulation.push({ ...bestIndividual });
+      while (newPopulation.length < POPULATION_SIZE) {
+        const parent1 = tournamentSelect(population, TOURNAMENT_SIZE, rng);
+        const parent2 = tournamentSelect(population, TOURNAMENT_SIZE, rng);
+        let childPerm = crossover(parent1.perm, parent2.perm, rng);
+        if (rng() < MUTATION_RATE) {
+          childPerm = swapNeighbor(childPerm, rng);
+        }
+        const childSchedule = decodePermutation(childPerm, problem);
+        const childMakespan = computeMakespan(childSchedule);
+        newPopulation.push({ perm: childPerm, makespan: childMakespan });
+      }
+      population = newPopulation;
+      const genBest = population.reduce((best, ind) => ind.makespan < best.makespan ? ind : best);
+      if (genBest.makespan < bestIndividual.makespan) {
+        bestIndividual = genBest;
+      }
+      options?.onProgress?.({
+        solverId: "genetic-algorithm",
+        percentage: Math.round((gen + 1) / GENERATIONS * 100),
+        bestMakespan: bestIndividual.makespan,
+        currentIteration: gen + 1,
+        totalIterations: GENERATIONS
+      });
+    }
+    const bestSchedule = decodePermutation(bestIndividual.perm, problem);
+    return {
+      solverId: "genetic-algorithm",
+      solverName: "Genetic Algorithm",
+      makespan: bestIndividual.makespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: GENERATIONS * POPULATION_SIZE
+    };
+  }
+};
+function tournamentSelect(population, size, rng) {
+  let best = population[Math.floor(rng() * population.length)];
+  for (let i = 1; i < size; i++) {
+    const candidate = population[Math.floor(rng() * population.length)];
+    if (candidate.makespan < best.makespan) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function crossover(parent1, parent2, rng) {
+  const len = parent1.length;
+  const start = Math.floor(rng() * len);
+  const end = start + Math.floor(rng() * (len - start));
+  const child = new Array(len).fill(null);
+  const used = /* @__PURE__ */ new Set();
+  for (let i = start; i <= end && i < len; i++) {
+    child[i] = parent1[i];
+    used.add(`${parent1[i].jobId}-${parent1[i].opIndex}`);
+  }
+  let pos = 0;
+  for (const op of parent2) {
+    const key = `${op.jobId}-${op.opIndex}`;
+    if (!used.has(key)) {
+      while (child[pos] !== null)
+        pos++;
+      child[pos] = op;
+      used.add(key);
+    }
+  }
+  return child;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/ant-colony-solver.js
+var NUM_ANTS = 20;
+var ITERATIONS2 = 100;
+var ALPHA = 1;
+var BETA = 2;
+var EVAPORATION = 0.1;
+var Q = 100;
+var antColonySolver = {
+  id: "ant-colony",
+  name: "Ant Colony Optimization",
+  description: "Swarm intelligence using pheromone trails to guide solution construction.",
+  async solve(problem, options) {
+    const startTime = performance.now();
+    const timeoutMs = options?.timeoutMs ?? 2e4;
+    const rng = createRng(42);
+    const allOps = buildOperationList(problem);
+    const numOps = allOps.length;
+    const pheromone = Array.from({ length: numOps }, () => new Array(numOps).fill(1));
+    const heuristic = allOps.map((ref) => {
+      const job = problem.jobs.find((j) => j.id === ref.jobId);
+      const op = job.operations[ref.opIndex];
+      return 1 / op.duration;
+    });
+    let bestMakespan = Infinity;
+    let bestSchedule = decodePermutation(allOps, problem);
+    for (let iter = 0; iter < ITERATIONS2; iter++) {
+      if (performance.now() - startTime > timeoutMs)
+        break;
+      const antSolutions = [];
+      for (let ant = 0; ant < NUM_ANTS; ant++) {
+        const perm = constructSolution(allOps, pheromone, heuristic, rng);
+        const schedule = decodePermutation(perm, problem);
+        const makespan = computeMakespan(schedule);
+        antSolutions.push({ perm, makespan });
+        if (makespan < bestMakespan) {
+          bestMakespan = makespan;
+          bestSchedule = schedule;
+        }
+      }
+      for (let i = 0; i < numOps; i++) {
+        for (let j = 0; j < numOps; j++) {
+          pheromone[i][j] *= 1 - EVAPORATION;
+        }
+      }
+      for (const solution of antSolutions) {
+        const deposit = Q / solution.makespan;
+        for (let pos = 0; pos < solution.perm.length; pos++) {
+          const opIdx = allOps.findIndex((o) => o.jobId === solution.perm[pos].jobId && o.opIndex === solution.perm[pos].opIndex);
+          if (opIdx >= 0) {
+            pheromone[pos][opIdx] += deposit;
+          }
+        }
+      }
+      options?.onProgress?.({
+        solverId: "ant-colony",
+        percentage: Math.round((iter + 1) / ITERATIONS2 * 100),
+        bestMakespan,
+        currentIteration: iter + 1,
+        totalIterations: ITERATIONS2
+      });
+    }
+    return {
+      solverId: "ant-colony",
+      solverName: "Ant Colony Optimization",
+      makespan: bestMakespan,
+      schedule: bestSchedule,
+      elapsedMs: performance.now() - startTime,
+      iterations: ITERATIONS2 * NUM_ANTS
+    };
+  }
+};
+function constructSolution(allOps, pheromone, heuristic, rng) {
+  const remaining = new Set(allOps.map((_, i) => i));
+  const result = [];
+  for (let pos = 0; pos < allOps.length; pos++) {
+    const candidates = Array.from(remaining);
+    const weights = candidates.map((opIdx) => {
+      const tau = Math.pow(pheromone[pos][opIdx], ALPHA);
+      const eta = Math.pow(heuristic[opIdx], BETA);
+      return tau * eta;
+    });
+    const totalWeight = weights.reduce((sum2, w) => sum2 + w, 0);
+    let r = rng() * totalWeight;
+    let selectedIdx = candidates[0];
+    for (let i = 0; i < candidates.length; i++) {
+      r -= weights[i];
+      if (r <= 0) {
+        selectedIdx = candidates[i];
+        break;
+      }
+    }
+    result.push(allOps[selectedIdx]);
+    remaining.delete(selectedIdx);
+  }
+  return result;
+}
+
+// ../../b4m-core/packages/quantum/dist/src/solvers/index.js
+var allSolvers = [
+  greedySolver,
+  naiveSolver,
+  randomRestartSolver,
+  simulatedAnnealingSolver,
+  simulatedAnnealingMediumSolver,
+  simulatedAnnealingLargeSolver,
+  tabuSolver,
+  geneticAlgorithmSolver,
+  antColonySolver
+];
+var solverRegistry = new Map(allSolvers.map((s) => [s.id, s]));
+function getSolver(id) {
+  return solverRegistry.get(id);
+}
+function getAvailableSolverIds() {
+  return Array.from(solverRegistry.keys());
+}
+
+// ../../b4m-core/packages/quantum/dist/src/prompts/system-prompt.js
+var QUANTUM_CANVASSER_SYSTEM_PROMPT = `You are the Optimization Canvasser, an AI agent specializing in combinatorial optimization and job-shop scheduling. You help users formulate scheduling problems, run solver algorithms, and interpret optimization results. You are solver-agnostic \u2014 you route problems to the best solver whether classical (greedy, simulated annealing, genetic algorithms, HiGHS MIP) or quantum (QAOA), building credibility through honest recommendations.
+
+## Your Capabilities
+
+You have two specialized tools:
+
+### quantum_formulate
+Converts natural language descriptions into structured SchedulingProblem definitions. When a user describes a scheduling scenario in plain English, use this tool to extract:
+- Jobs (ordered sequences of operations)
+- Machines (resources that process operations)
+- Operation durations and machine assignments
+- Precedence constraints (operations within a job must execute in order)
+
+### quantum_schedule
+Runs optimization solvers on a structured SchedulingProblem. Available solvers:
+${allSolvers.map((s) => `- **${s.name}** (\`${s.id}\`): ${s.description}`).join("\n")}
+
+## How to Help Users
+
+### Problem Formulation
+When a user describes a scheduling scenario:
+1. Use \`quantum_formulate\` to convert their description into a structured problem
+2. Present the formulated problem clearly, showing jobs, machines, and operation sequences
+3. Ask if adjustments are needed before solving
+
+### Running Solvers
+When solving a problem:
+1. Start with the \`greedy\` solver for a quick baseline result
+2. For better solutions, suggest running multiple solvers: \`greedy\`, \`simulated-annealing\`, \`tabu\`, \`genetic-algorithm\`
+3. Explain that metaheuristic solvers explore larger solution spaces but take longer
+4. Compare results across solvers when multiple are run
+
+### Interpreting Results
+When presenting solver results:
+- Explain the **makespan** (total schedule length) and why lower is better
+- Walk through the schedule showing which jobs run on which machines at what times
+- Identify bottleneck machines (those with the most continuous utilization)
+- Suggest improvements if the problem structure allows (e.g., rebalancing operations)
+
+### QUBO Encoding
+If asked about quantum computing aspects:
+- Explain how scheduling problems are encoded as QUBO (Quadratic Unconstrained Binary Optimization) matrices
+- Time-indexed binary variables: x_{o,t} = 1 if operation o starts at time t
+- Three constraint families: exactly-once (each operation starts exactly once), no-overlap (no two operations on same machine at same time), precedence (operations within a job maintain order)
+- QUBO matrices can be solved by quantum annealers (D-Wave) or quantum-inspired classical solvers
+
+## Communication Style
+- Be precise with numbers and scheduling terminology
+- Use clear formatting: tables for schedules, bullet points for comparisons
+- When explaining optimization concepts, ground them in the user's specific problem
+- Proactively suggest next steps (e.g., "Would you like to try more solvers?" or "Should I adjust the problem?")
+
+## Important Notes
+- All solvers run client-side in the browser via Web Workers \u2014 no server compute needed
+- The greedy solver is deterministic and instant; metaheuristic solvers involve randomness
+- For very large problems (50+ operations), recommend the greedy and simulated-annealing solvers
+- The HiGHS MIP solver uses WASM and provides optimal solutions for small problems but may be slow on large ones`;
+var PROBLEM_FORMULATION_PROMPT = `You are a job-shop scheduling problem formulator. Convert the user's natural language description into a structured SchedulingProblem JSON object.
+
+RULES:
+1. Each job has an id (number starting from 0), a name, and an ordered array of operations
+2. Each machine has an id (number starting from 0) and a name
+3. Each operation has jobId (matching its parent job), machineId (which machine it runs on), and duration (positive integer)
+4. Operations within a job execute in order (first operation must finish before second starts)
+5. Each machine can only process one operation at a time
+6. Assign reasonable durations if not specified (use whole numbers)
+7. Create meaningful names for jobs and machines based on context
+
+RESPOND WITH ONLY A JSON OBJECT matching this schema:
+{
+  "name": "string - descriptive problem name",
+  "description": "string - brief description",
+  "jobs": [
+    {
+      "id": 0,
+      "name": "Job Name",
+      "operations": [
+        { "jobId": 0, "machineId": 0, "duration": 3 }
+      ]
+    }
+  ],
+  "machines": [
+    { "id": 0, "name": "Machine Name" }
+  ]
+}
+
+No markdown, no explanation, no code blocks \u2014 just the raw JSON object.`;
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/quantumSchedule/index.js
+function formatResult(result) {
+  const lines = [
+    `Solver: ${result.solverName} (${result.solverId})`,
+    `Makespan: ${result.makespan}`,
+    `Elapsed: ${result.elapsedMs.toFixed(1)}ms`
+  ];
+  if (result.iterations !== void 0) {
+    lines.push(`Iterations: ${result.iterations}`);
+  }
+  lines.push("Schedule:");
+  const byMachine = /* @__PURE__ */ new Map();
+  for (const op of result.schedule) {
+    if (!byMachine.has(op.machineId))
+      byMachine.set(op.machineId, []);
+    byMachine.get(op.machineId).push(op);
+  }
+  for (const [machineId, ops] of byMachine) {
+    const sorted = ops.sort((a, b) => a.startTime - b.startTime);
+    const timeline = sorted.map((op) => `Job${op.jobId}[${op.startTime}-${op.endTime}]`).join(" -> ");
+    lines.push(`  Machine ${machineId}: ${timeline}`);
+  }
+  return lines.join("\n");
+}
+async function runQuantumSchedule(params) {
+  const parseResult = SchedulingProblemSchema.safeParse(params.problem);
+  if (!parseResult.success) {
+    return `Error: Invalid scheduling problem format.
+${parseResult.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+
+Expected format: { name, jobs: [{ id, name, operations: [{ jobId, machineId, duration }] }], machines: [{ id, name }] }`;
+  }
+  const problem = parseResult.data;
+  let solverIds;
+  if (params.solverIds && params.solverIds.length > 0) {
+    const invalid = params.solverIds.filter((id) => !SolverIdSchema.safeParse(id).success);
+    if (invalid.length > 0) {
+      return `Error: Unknown solver IDs: ${invalid.join(", ")}.
+Available solvers: ${getAvailableSolverIds().join(", ")}`;
+    }
+    solverIds = params.solverIds;
+  } else {
+    solverIds = ["greedy"];
+  }
+  const timeoutMs = params.timeoutMs ?? 1e4;
+  const results = [];
+  const errors = [];
+  for (const solverId of solverIds) {
+    const solver = getSolver(solverId);
+    if (!solver) {
+      errors.push(`Solver "${solverId}" not found`);
+      continue;
+    }
+    try {
+      const result = await solver.solve(problem, { timeoutMs });
+      results.push(result);
+    } catch (err) {
+      errors.push(`${solver.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (results.length === 0) {
+    return `Error: No solvers completed successfully.
+${errors.join("\n")}`;
+  }
+  results.sort((a, b) => a.makespan - b.makespan);
+  const lines = [];
+  lines.push(`## Scheduling Results for "${problem.name}"`);
+  lines.push(`Problem: ${problem.jobs.length} jobs, ${problem.machines.length} machines, ${problem.jobs.reduce((s, j) => s + j.operations.length, 0)} operations`);
+  lines.push("");
+  if (results.length > 1) {
+    lines.push(`### Winner: ${results[0].solverName} (makespan: ${results[0].makespan})`);
+    lines.push("");
+  }
+  for (const result of results) {
+    lines.push(`### ${result.solverName}`);
+    lines.push(formatResult(result));
+    lines.push("");
+  }
+  if (errors.length > 0) {
+    lines.push("### Errors");
+    errors.forEach((e) => lines.push(`- ${e}`));
+  }
+  return lines.join("\n");
+}
+var quantumScheduleTool = {
+  name: "quantum_schedule",
+  implementation: () => ({
+    toolFn: (value) => runQuantumSchedule(value),
+    toolSchema: {
+      name: "quantum_schedule",
+      description: `Run quantum-inspired optimization solvers on a job-shop scheduling problem. Finds optimal or near-optimal schedules that minimize makespan (total completion time).
+
+Available solvers: ${allSolvers.map((s) => `${s.id} (${s.name})`).join(", ")}.
+
+The "greedy" solver runs instantly. Metaheuristic solvers (simulated-annealing, tabu, genetic-algorithm, ant-colony) explore larger solution spaces but take longer. Use multiple solvers to race them against each other.
+
+The problem must define jobs (each with ordered operations) and machines. Each operation runs on a specific machine for a specific duration. Operations within a job must run in order.`,
+      parameters: {
+        type: "object",
+        properties: {
+          problem: {
+            type: "object",
+            description: "The scheduling problem to solve. Must include name, jobs array, and machines array.",
+            properties: {
+              name: { type: "string", description: "Name of the scheduling problem" },
+              description: { type: "string", description: "Optional description" },
+              jobs: {
+                type: "array",
+                description: "Array of jobs, each with id, name, and operations",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: { type: "number" },
+                    name: { type: "string" },
+                    operations: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          jobId: { type: "number", description: "Must match the parent job id" },
+                          machineId: { type: "number", description: "Which machine this operation runs on" },
+                          duration: { type: "number", description: "Processing time" }
+                        },
+                        required: ["jobId", "machineId", "duration"]
+                      }
+                    }
+                  },
+                  required: ["id", "name", "operations"]
+                }
+              },
+              machines: {
+                type: "array",
+                description: "Array of machines with id and name",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: { type: "number" },
+                    name: { type: "string" }
+                  },
+                  required: ["id", "name"]
+                }
+              }
+            },
+            required: ["name", "jobs", "machines"]
+          },
+          solverIds: {
+            type: "array",
+            items: { type: "string" },
+            description: `Which solvers to run. Defaults to ["greedy"]. Available: ${getAvailableSolverIds().join(", ")}. Use multiple to race solvers.`
+          },
+          timeoutMs: {
+            type: "number",
+            description: "Maximum time per solver in milliseconds (default: 10000)"
+          }
+        },
+        required: ["problem"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/quantumFormulate/index.js
+var quantumFormulateTool = {
+  name: "quantum_formulate",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const userDescription = params.description?.trim();
+      if (!userDescription) {
+        return "Error: Please provide a description of the scheduling problem to formulate.";
+      }
+      try {
+        let rawContent = "";
+        await context.llm.complete(context.model ?? "gpt-4", [
+          { role: "system", content: PROBLEM_FORMULATION_PROMPT },
+          { role: "user", content: userDescription }
+        ], { temperature: 0.2, stream: false }, async (texts) => {
+          rawContent = texts.filter((t) => t !== null && t !== void 0).join("");
+        });
+        let jsonStr = rawContent.trim();
+        const codeBlockMatch = jsonStr.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (codeBlockMatch) {
+          jsonStr = codeBlockMatch[1].trim();
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonStr);
+        } catch {
+          return `Error: Could not parse LLM response as JSON. Raw response:
+${rawContent}
+
+Please try rephrasing your description with more specific details about jobs, machines, and processing times.`;
+        }
+        const validated = SchedulingProblemSchema.safeParse(parsed);
+        if (!validated.success) {
+          return `Error: LLM generated an invalid problem structure.
+${validated.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+
+Raw output:
+${jsonStr}
+
+Please try rephrasing your description.`;
+        }
+        const problem = validated.data;
+        const totalOps = problem.jobs.reduce((s, j) => s + j.operations.length, 0);
+        const lines = [
+          `## Formulated: "${problem.name}"`,
+          problem.description ? `
+${problem.description}` : "",
+          "",
+          `**${problem.jobs.length} jobs, ${problem.machines.length} machines, ${totalOps} operations**`,
+          "",
+          "### Jobs:",
+          ...problem.jobs.map((j) => {
+            const ops = j.operations.map((op, i) => {
+              const machine = problem.machines.find((m) => m.id === op.machineId);
+              return `Step ${i + 1}: ${machine?.name ?? `Machine ${op.machineId}`} (${op.duration}t)`;
+            });
+            return `- **${j.name}**: ${ops.join(" -> ")}`;
+          }),
+          "",
+          "### Machines:",
+          ...problem.machines.map((m) => `- ${m.name} (id: ${m.id})`),
+          "",
+          "### Structured Problem (JSON):",
+          "```json",
+          JSON.stringify(problem, null, 2),
+          "```",
+          "",
+          "You can now use the `quantum_schedule` tool to solve this problem with various optimization algorithms."
+        ];
+        return lines.filter((l) => l !== void 0).join("\n");
+      } catch (err) {
+        return `Error formulating problem: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    },
+    toolSchema: {
+      name: "quantum_formulate",
+      description: `Convert a natural language description of a scheduling/optimization problem into a structured SchedulingProblem that can be solved by the quantum_schedule tool.
+
+Describe the problem in plain English \u2014 what jobs need to be done, what machines or resources are available, how long each step takes, and any ordering constraints. The tool will produce a structured problem definition.
+
+Examples:
+- "I have 3 orders to manufacture. Each needs cutting, welding, and painting. Cutting takes 2h, welding 3h, painting 1h."
+- "Schedule 4 software builds across 2 CI runners. Build A needs compile (5min) then test (3min)..."
+- "A bakery needs to make 5 cakes. Each cake goes through mixing, baking, and decorating on separate stations."`,
+      parameters: {
+        type: "object",
+        properties: {
+          description: {
+            type: "string",
+            description: "Natural language description of the scheduling problem to formulate"
+          }
+        },
+        required: ["description"]
+      }
+    }
+  })
+};
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/navigateView/index.js
+var navigateViewTool = {
+  name: "navigate_view",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { suggestions } = params;
+      context.logger.log("\u{1F9ED} navigate_view: Received suggestions:", JSON.stringify(suggestions));
+      if (!suggestions || !Array.isArray(suggestions) || suggestions.length === 0) {
+        return "No navigation suggestions provided.";
+      }
+      const capped = suggestions.slice(0, 3);
+      const invalid = capped.filter((s) => !getViewById(s.viewId));
+      if (invalid.length > 0) {
+        context.logger.log("\u{1F9ED} navigate_view: Unknown viewIds:", invalid.map((s) => s.viewId));
+      }
+      const isAdmin = context.user?.isAdmin === true;
+      const intents = resolveNavigationIntents(capped, isAdmin);
+      if (intents.length === 0) {
+        return "No valid navigation views matched the provided viewIds.";
+      }
+      context.logger.log("\u{1F9ED} navigate_view: Resolved intents:", intents.map((i) => i.viewId));
+      return JSON.stringify({
+        __navigationIntents: true,
+        intents,
+        message: `Suggested ${intents.length} navigation option(s): ${intents.map((i) => i.label).join(", ")}`
+      });
+    },
+    toolSchema: {
+      name: "navigate_view",
+      description: "Suggest navigation to relevant app views. Returns inline action buttons the user can click. ALWAYS use this tool when your response discusses a topic that has a matching view (e.g., scheduling \u2192 opti.scheduling, user management \u2192 admin.users). Call this tool alongside your text answer \u2014 answer the question AND suggest where to go.",
+      parameters: {
+        type: "object",
+        properties: {
+          suggestions: {
+            type: "array",
+            description: "Navigation suggestions (1-3 items). Each suggests a view the user might want to visit.",
+            items: {
+              type: "object",
+              properties: {
+                viewId: {
+                  type: "string",
+                  description: 'The view ID from the available views list (e.g., "opti.scheduling", "admin.users")'
+                },
+                reason: {
+                  type: "string",
+                  description: "Brief reason why this view is relevant (max 80 chars, shown as tooltip)"
+                }
+              },
+              required: ["viewId", "reason"]
+            },
+            maxItems: 3,
+            minItems: 1
+          }
+        },
+        required: ["suggestions"]
+      }
+    }
+  })
+};
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
 import { spawn } from "child_process";
 import path12 from "path";
@@ -10212,7 +11446,7 @@ async function executeBashCommand(params) {
     });
   });
 }
-function formatResult(result, command) {
+function formatResult2(result, command) {
   const parts = [];
   parts.push(`$ ${command}`);
   parts.push("");
@@ -10266,7 +11500,7 @@ var bashExecuteTool = {
       }
       try {
         const result = await executeBashCommand(params);
-        const formattedResult = formatResult(result, params.command);
+        const formattedResult = formatResult2(result, params.command);
         context.logger.info("Bash: Command completed", {
           exitCode: result.exitCode,
           timedOut: result.timedOut,
@@ -11435,7 +12669,7 @@ async function getFileStats(files, since, filterPath) {
     });
   });
 }
-function formatResult2(result) {
+function formatResult3(result) {
   const parts = [];
   if (result.error) {
     parts.push(`Error: ${result.error}`);
@@ -11510,7 +12744,7 @@ var recentChangesTool = {
       }
       try {
         const result = await getRecentChanges(params);
-        const formattedResult = formatResult2(result);
+        const formattedResult = formatResult3(result);
         context.logger.info("RecentChanges: Retrieved file changes", {
           totalFiles: result.totalFiles,
           displayedFiles: result.files.length,
@@ -11608,8 +12842,14 @@ var b4mTools = {
   sunrise_sunset: sunriseSunsetTool,
   iss_tracker: issTrackerTool,
   planet_visibility: planetVisibilityTool,
-  // Knowledge base search
-  search_knowledge_base: knowledgeBaseSearchTool
+  // Knowledge base tools
+  search_knowledge_base: knowledgeBaseSearchTool,
+  retrieve_knowledge_content: knowledgeBaseRetrieveTool,
+  // Quantum optimization tools
+  quantum_schedule: quantumScheduleTool,
+  quantum_formulate: quantumFormulateTool,
+  // Navigation tool
+  navigate_view: navigateViewTool
 };
 var cliOnlyTools = {
   // File operation tools
@@ -11739,50 +12979,50 @@ var generateMcpTools = async (mcpData) => {
 import throttle2 from "lodash/throttle.js";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionFeatures.js
-import { z as z139 } from "zod";
+import { z as z140 } from "zod";
 import uniq4 from "lodash/uniq.js";
-var QuestStartBodySchema = z139.object({
-  userId: z139.string(),
-  sessionId: z139.string(),
-  questId: z139.string(),
-  message: z139.string(),
-  messageFileIds: z139.array(z139.string()),
-  historyCount: z139.number(),
-  fabFileIds: z139.array(z139.string()),
+var QuestStartBodySchema = z140.object({
+  userId: z140.string(),
+  sessionId: z140.string(),
+  questId: z140.string(),
+  message: z140.string(),
+  messageFileIds: z140.array(z140.string()),
+  historyCount: z140.number(),
+  fabFileIds: z140.array(z140.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z139.boolean().optional(),
-  enableMementos: z139.boolean().optional(),
-  enableArtifacts: z139.boolean().optional(),
-  enableAgents: z139.boolean().optional(),
-  enableLattice: z139.boolean().optional(),
+  enableQuestMaster: z140.boolean().optional(),
+  enableMementos: z140.boolean().optional(),
+  enableArtifacts: z140.boolean().optional(),
+  enableAgents: z140.boolean().optional(),
+  enableLattice: z140.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
-  mcpServers: z139.array(z139.string()).optional(),
-  projectId: z139.string().optional(),
-  organizationId: z139.string().nullable().optional(),
+  tools: z140.array(z140.union([b4mLLMTools, z140.string()])).optional(),
+  mcpServers: z140.array(z140.string()).optional(),
+  projectId: z140.string().optional(),
+  organizationId: z140.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z139.string().optional(),
+  toolPromptId: z140.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z139.string().optional(),
-  embeddingModel: z139.string().optional(),
-  queryComplexity: z139.string(),
+  fallbackModel: z140.string().optional(),
+  embeddingModel: z140.string().optional(),
+  queryComplexity: z140.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z139.object({
-    maxDepth: z139.number().optional(),
-    duration: z139.number().optional(),
+  deepResearchConfig: z140.object({
+    maxDepth: z140.number().optional(),
+    duration: z140.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z139.array(z139.any()).optional()
+    searchers: z140.array(z140.any()).optional()
   }).optional(),
-  extraContextMessages: z139.array(z139.object({
-    role: z139.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z139.union([z139.string(), z139.array(z139.any())]),
-    fabFileIds: z139.array(z139.string()).optional()
+  extraContextMessages: z140.array(z140.object({
+    role: z140.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z140.union([z140.string(), z140.array(z140.any())]),
+    fabFileIds: z140.array(z140.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z139.string().optional(),
+  timezone: z140.string().optional(),
   /** Pre-fetched API key table from invoke phase — avoids redundant DB call in process (#6616 P1-a) */
-  apiKeyTable: z139.record(z139.string(), z139.string().nullable()).optional()
+  apiKeyTable: z140.record(z140.string(), z140.string().nullable()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -12282,89 +13522,89 @@ var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z140 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  organizationId: z140.string().nullable().optional(),
-  safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z140.boolean().optional().default(false),
-  seed: z140.number().nullable().optional(),
-  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
-  width: z140.number().optional(),
-  height: z140.number().optional(),
-  aspect_ratio: z140.string().optional(),
-  fabFileIds: z140.array(z140.string()).optional()
+  sessionId: z141.string(),
+  questId: z141.string(),
+  userId: z141.string(),
+  prompt: z141.string(),
+  organizationId: z141.string().nullable().optional(),
+  safety_tolerance: z141.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z141.boolean().optional().default(false),
+  seed: z141.number().nullable().optional(),
+  output_format: z141.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  width: z141.number().optional(),
+  height: z141.number().optional(),
+  aspect_ratio: z141.string().optional(),
+  fabFileIds: z141.array(z141.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z141 } from "zod";
+import { z as z142 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-var VideoGenerationBodySchema = z141.object({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  model: z141.nativeEnum(VideoModels).default(VideoModels.SORA_2),
-  seconds: z141.union([z141.literal(4), z141.literal(8), z141.literal(12)]).default(4),
-  size: z141.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
-  organizationId: z141.string().nullable().optional()
+var VideoGenerationBodySchema = z142.object({
+  sessionId: z142.string(),
+  questId: z142.string(),
+  userId: z142.string(),
+  prompt: z142.string(),
+  model: z142.nativeEnum(VideoModels).default(VideoModels.SORA_2),
+  seconds: z142.union([z142.literal(4), z142.literal(8), z142.literal(12)]).default(4),
+  size: z142.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
+  organizationId: z142.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
 import axios10 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
 import { v4 as uuidv49 } from "uuid";
-import { z as z142 } from "zod";
+import { z as z143 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
 var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z142.string(),
-  questId: z142.string(),
-  userId: z142.string(),
-  prompt: z142.string(),
-  organizationId: z142.string().nullable().optional(),
-  safety_tolerance: z142.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z142.boolean().optional().default(false),
-  seed: z142.number().nullable().optional(),
-  output_format: z142.enum(["jpeg", "png"]).optional().default("png"),
-  width: z142.number().optional(),
-  height: z142.number().optional(),
-  aspect_ratio: z142.string().optional(),
-  size: z142.string().optional(),
-  fabFileIds: z142.array(z142.string()).optional(),
-  image: z142.string()
+  sessionId: z143.string(),
+  questId: z143.string(),
+  userId: z143.string(),
+  prompt: z143.string(),
+  organizationId: z143.string().nullable().optional(),
+  safety_tolerance: z143.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z143.boolean().optional().default(false),
+  seed: z143.number().nullable().optional(),
+  output_format: z143.enum(["jpeg", "png"]).optional().default("png"),
+  width: z143.number().optional(),
+  height: z143.number().optional(),
+  aspect_ratio: z143.string().optional(),
+  size: z143.string().optional(),
+  fabFileIds: z143.array(z143.string()).optional(),
+  image: z143.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z143 } from "zod";
-var refineTextLLMSchema = z143.object({
-  text: z143.string(),
-  context: z143.string().optional()
+import { z as z144 } from "zod";
+var refineTextLLMSchema = z144.object({
+  text: z144.string(),
+  context: z144.string().optional()
   // tone: z.enum(['formal', 'informal', 'neutral']).optional(),
   // style: z.enum(['technical', 'creative', 'academic', 'business', 'narrative']).optional(),
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/MementoEvaluationService.js
-import { z as z144 } from "zod";
-var SingleMementoEvalSchema = z144.object({
-  importance: z144.number().min(1).max(10),
+import { z as z145 } from "zod";
+var SingleMementoEvalSchema = z145.object({
+  importance: z145.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z144.string(),
-  tags: z144.array(z144.string()).optional()
+  summary: z145.string(),
+  tags: z145.array(z145.string()).optional()
 });
-var MementoEvalResponseSchema = z144.object({
-  isPersonal: z144.boolean(),
-  mementos: z144.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z145.object({
+  isPersonal: z145.boolean(),
+  mementos: z145.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z145 } from "zod";
+import { z as z146 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -12657,7 +13897,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z146 } from "zod";
+import { z as z147 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -12669,40 +13909,40 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z146.object({
-  type: z146.literal("command"),
-  command: z146.string().min(1, "Command is required for command hooks"),
-  timeout: z146.number().optional()
+var CommandHookSchema = z147.object({
+  type: z147.literal("command"),
+  command: z147.string().min(1, "Command is required for command hooks"),
+  timeout: z147.number().optional()
 });
-var PromptHookSchema = z146.object({
-  type: z146.literal("prompt"),
-  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
-  timeout: z146.number().optional()
+var PromptHookSchema = z147.object({
+  type: z147.literal("prompt"),
+  prompt: z147.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z147.number().optional()
 });
-var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z146.object({
-  matcher: z146.string().optional(),
-  hooks: z146.array(HookDefinitionSchema)
+var HookDefinitionSchema = z147.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z147.object({
+  matcher: z147.string().optional(),
+  hooks: z147.array(HookDefinitionSchema)
 });
-var AgentHooksSchema = z146.object({
-  PreToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUse: z146.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
-  Stop: z146.array(HookMatcherSchema).optional()
+var AgentHooksSchema = z147.object({
+  PreToolUse: z147.array(HookMatcherSchema).optional(),
+  PostToolUse: z147.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z147.array(HookMatcherSchema).optional(),
+  Stop: z147.array(HookMatcherSchema).optional()
 }).optional();
-var AgentFrontmatterSchema = z146.object({
-  description: z146.string().min(1, "Agent description is required"),
-  model: z146.string().optional(),
-  "allowed-tools": z146.array(z146.string()).optional(),
-  "denied-tools": z146.array(z146.string()).optional(),
-  skills: z146.array(z146.string()).optional(),
-  "max-iterations": z146.object({
-    quick: z146.number().int().positive().optional(),
-    medium: z146.number().int().positive().optional(),
-    very_thorough: z146.number().int().positive().optional()
+var AgentFrontmatterSchema = z147.object({
+  description: z147.string().min(1, "Agent description is required"),
+  model: z147.string().optional(),
+  "allowed-tools": z147.array(z147.string()).optional(),
+  "denied-tools": z147.array(z147.string()).optional(),
+  skills: z147.array(z147.string()).optional(),
+  "max-iterations": z147.object({
+    quick: z147.number().int().positive().optional(),
+    medium: z147.number().int().positive().optional(),
+    very_thorough: z147.number().int().positive().optional()
   }).optional(),
-  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z146.record(z146.string()).optional(),
+  "default-thoroughness": z147.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z147.record(z147.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -14635,7 +15875,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29",
+  version: "0.2.30-feat-quantum-optimize-architecture.19202+f15461eb1",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -14749,10 +15989,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.51.0",
-    "@bike4mind/mcp": "1.30.0",
-    "@bike4mind/services": "2.49.0",
-    "@bike4mind/utils": "2.6.0",
+    "@bike4mind/common": "2.51.1-feat-quantum-optimize-architecture.19202+f15461eb1",
+    "@bike4mind/mcp": "1.30.1-feat-quantum-optimize-architecture.19202+f15461eb1",
+    "@bike4mind/services": "2.49.1-feat-quantum-optimize-architecture.19202+f15461eb1",
+    "@bike4mind/utils": "2.6.1-feat-quantum-optimize-architecture.19202+f15461eb1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -14770,7 +16010,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "dd78e3f7ac6eb31fbbae8df3be1f33310779a9d5"
+  gitHead: "f15461eb1db88413308b9575f8e000d99dcf36cd"
 };
 
 // src/config/constants.ts