@bike4mind/cli 0.2.29-feat-quantum-optimize-architecture.18875 → 0.2.29-feat-cli-websocket-streaming.18881

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-MHDNMNRT.js";
+} from "./chunk-QQL3OBKL.js";
 import {
   ConfigStore,
   logger
@@ -14,8 +14,8 @@ import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-Z7V2ITXT.js";
-import "./chunk-KFGSOQ6A.js";
+import "./chunk-BXCARBUQ.js";
+import "./chunk-EC2VEDD2.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -27,7 +27,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-H66G775W.js";
+} from "./chunk-TY6Z2UV2.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -82,10 +82,8 @@ import {
   VideoModels,
   XAI_IMAGE_MODELS,
   b4mLLMTools,
-  getMcpProviderMetadata,
-  getViewById,
-  resolveNavigationIntents
-} from "./chunk-KISWANWA.js";
+  getMcpProviderMetadata
+} from "./chunk-KPOK6V6E.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -95,7 +93,7 @@ import React21, { useState as useState9, useEffect as useEffect6, useCallback as
 import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
 import { execSync } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
-import { v4 as uuidv411 } from "uuid";
+import { v4 as uuidv413 } from "uuid";
 
 // src/components/App.tsx
 import React15, { useState as useState5, useEffect as useEffect4 } from "react";
@@ -3589,6 +3587,50 @@ function isReadOnlyTool(toolName, customCategories) {
   return getToolCategory(toolName, customCategories) !== "prompt_always";
 }
 
+// src/core/skillsPrompt.ts
+function getSkillDisplayName(cmd) {
+  return cmd.displayName || cmd.name;
+}
+function formatSkillEntry(cmd) {
+  const displayName = getSkillDisplayName(cmd);
+  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
+  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
+  return `- ${nameDisplay}${argHint}: ${cmd.description}
+`;
+}
+function formatSkillGroup(heading, commands) {
+  if (commands.length === 0) {
+    return "";
+  }
+  return `
+### ${heading}
+${commands.map(formatSkillEntry).join("")}`;
+}
+function filterAIVisibleSkills(commands) {
+  return commands.filter((cmd) => !cmd.disableModelInvocation);
+}
+function filterSkillsByAllowedList(commands, allowedSkills) {
+  if (!allowedSkills || allowedSkills.length === 0) {
+    return commands;
+  }
+  return commands.filter((cmd) => allowedSkills.includes(cmd.name));
+}
+function buildSkillsPromptSection(commands, allowedSkills) {
+  const filteredByAllowed = filterSkillsByAllowedList(commands, allowedSkills);
+  const visibleCommands = filterAIVisibleSkills(filteredByAllowed);
+  if (visibleCommands.length === 0) {
+    return "";
+  }
+  const projectSkills = visibleCommands.filter((c) => c.source === "project");
+  const globalSkills = visibleCommands.filter((c) => c.source === "global");
+  return `
+
+## Available Skills
+
+Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
+` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
+}
+
 // src/core/prompts.ts
 var TOOL_GREP_SEARCH = "grep_search";
 var TOOL_GLOB_FILES = "glob_files";
@@ -3599,7 +3641,38 @@ var TOOL_BASH_EXECUTE = "bash_execute";
 var TOOL_SUBAGENT_DELEGATE = "subagent_delegate";
 var TOOL_WRITE_TODOS = "write_todos";
 var EXPLORE_SUBAGENT_TYPE = "explore";
-function buildCoreSystemPrompt(contextSection = "") {
+function buildCoreSystemPrompt(contextSection, config) {
+  let projectContextSection = "";
+  let agentDirectoryContext = "";
+  let skillsSection = "";
+  if (typeof contextSection === "string") {
+    projectContextSection = contextSection;
+    if (config) {
+      if (config.enableSkillTool !== false && config.customCommands && config.customCommands.length > 0) {
+        skillsSection = buildSkillsPromptSection(config.customCommands);
+      }
+      if (config.agentStore) {
+        agentDirectoryContext = config.agentStore.getDirectoryContext();
+      }
+    }
+  } else if (contextSection && typeof contextSection === "object") {
+    config = contextSection;
+    if (config.contextContent) {
+      projectContextSection = `
+
+## Project Context
+
+Follow these project-specific instructions:
+
+${config.contextContent}`;
+    }
+    if (config.enableSkillTool !== false && config.customCommands && config.customCommands.length > 0) {
+      skillsSection = buildSkillsPromptSection(config.customCommands);
+    }
+    if (config.agentStore) {
+      agentDirectoryContext = config.agentStore.getDirectoryContext();
+    }
+  }
   return `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
 
 CORE BEHAVIOR:
@@ -3629,12 +3702,8 @@ When requested to perform tasks like fixing bugs, adding features, refactoring,
 
 SUBAGENT DELEGATION:
 - You have access to specialized subagents via the ${TOOL_SUBAGENT_DELEGATE} tool
-- Use subagents for focused exploration, planning, or review tasks:
-  * explore: Fast read-only codebase search (e.g., "find all auth files", "locate API endpoints")
-  * plan: Break down complex tasks into actionable steps
-  * review: Analyze code quality and identify issues
+- ${agentDirectoryContext ? `${agentDirectoryContext}` : ""}
 - Subagents keep the main conversation clean and run faster with optimized models
-- Delegate when you need to search extensively or analyze code structure
 
 CODE SEARCH BEST PRACTICES:
 When searching code, follow this hierarchy for speed and efficiency:
@@ -3691,7 +3760,7 @@ EXAMPLES:
 - "what packages installed?" \u2192 ${TOOL_GLOB_FILES} "**/package.json" \u2192 ${TOOL_FILE_READ}
 - "find all components using React hooks" \u2192 ${TOOL_SUBAGENT_DELEGATE}(task="find all components using React hooks", type="explore")
 
-Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
+Remember: Use context from previous messages to understand follow-up questions.${projectContextSection}${skillsSection}`;
 }
 
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
@@ -8781,8 +8850,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 z148 = r * sinOmega * sinI;
-  return { x, y, z: z148, r };
+  const z147 = r * sinOmega * sinI;
+  return { x, y, z: z147, r };
 };
 var getGeocentricEcliptic = (planet, earth) => {
   const dx = planet.x - earth.x;
@@ -9666,13 +9735,13 @@ function formatSearchResults(files) {
     const notes = file.notes ? `
    Notes: ${file.notes}` : "";
     const fileType = file.type || "FILE";
-    return `${index + 1}. **${file.fileName}** (ID: ${file.id})
+    return `${index + 1}. **${file.fileName}**
    Type: ${fileType} | MIME: ${file.mimeType}
    Tags: ${tags}${notes}`;
   });
   return `Found ${files.length} document(s) in your knowledge base:
 
-` + formattedFiles.join("\n\n") + "\n\n*Use retrieve_knowledge_content with a file ID or tags to read the actual document content.*";
+` + formattedFiles.join("\n\n") + "\n\n*To use these documents in your conversation, you can ask me to reference specific files by name.*";
 }
 var knowledgeBaseSearchTool = {
   name: "search_knowledge_base",
@@ -9699,8 +9768,6 @@ 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 || []
@@ -9715,18 +9782,18 @@ var knowledgeBaseSearchTool = {
     },
     toolSchema: {
       name: "search_knowledge_base",
-      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.",
+      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.",
       parameters: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "The search query to find relevant documents. Matches against file names, tags, and notes."
+            description: "The search query to find relevant documents by filename or content"
           },
           tags: {
             type: "array",
             items: { type: "string" },
-            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.'
+            description: "Optional: filter results to only include files with these tags"
           },
           file_type: {
             type: "string",
@@ -9746,1297 +9813,68 @@ 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 = [
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
+import { spawn } from "child_process";
+import path11 from "path";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_OUTPUT_SIZE = 100 * 1024;
+var DANGEROUS_PATTERNS = [
+  // Destructive file operations
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
+    reason: "Recursive delete with path",
+    block: true
+  },
   {
-    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
+    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
+    reason: "Force delete without preserve root",
+    block: true
   },
   {
-    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
+    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
+    reason: "Recursive force delete on root paths",
+    block: true
   },
   {
-    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 path11 from "path";
-var DEFAULT_TIMEOUT_MS = 6e4;
-var MAX_OUTPUT_SIZE = 100 * 1024;
-var DANGEROUS_PATTERNS = [
-  // Destructive file operations
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
-    reason: "Recursive delete with path",
-    block: true
-  },
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
-    reason: "Force delete without preserve root",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
-    reason: "Recursive force delete on root paths",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
-    reason: "Force recursive delete on root paths",
-    block: true
-  },
-  // System-level dangerous commands
-  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
-  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
-  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
-  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
-  // Disk/partition operations
-  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
-  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
-  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
-  // Network attacks
-  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
-  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  // Fork bombs and resource exhaustion
-  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
-  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
-  // Credential/sensitive data access
-  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
-  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
-  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
-  // History/log manipulation
-  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
-  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
-  // Dangerous redirects
-  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
-  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
-  // Environment manipulation
-  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
-  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
-  // Process/system control
-  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
-  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
-  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
-  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
-  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
+    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
+    reason: "Force recursive delete on root paths",
+    block: true
+  },
+  // System-level dangerous commands
+  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
+  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
+  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
+  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
+  // Disk/partition operations
+  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
+  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
+  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
+  // Network attacks
+  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
+  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  // Fork bombs and resource exhaustion
+  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
+  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
+  // Credential/sensitive data access
+  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
+  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
+  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
+  // History/log manipulation
+  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
+  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
+  // Dangerous redirects
+  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
+  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
+  // Environment manipulation
+  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
+  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
+  // Process/system control
+  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
+  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
+  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
+  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
+  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
 ];
 var SAFE_COMMAND_PREFIXES = [
   "ls",
@@ -11224,7 +10062,7 @@ async function executeBashCommand(params) {
     });
   });
 }
-function formatResult2(result, command) {
+function formatResult(result, command) {
   const parts = [];
   parts.push(`$ ${command}`);
   parts.push("");
@@ -11278,7 +10116,7 @@ var bashExecuteTool = {
       }
       try {
         const result = await executeBashCommand(params);
-        const formattedResult = formatResult2(result, params.command);
+        const formattedResult = formatResult(result, params.command);
         context.logger.info("Bash: Command completed", {
           exitCode: result.exitCode,
           timedOut: result.timedOut,
@@ -11634,7 +10472,7 @@ async function getFileStats(files, since, filterPath) {
     });
   });
 }
-function formatResult3(result) {
+function formatResult2(result) {
   const parts = [];
   if (result.error) {
     parts.push(`Error: ${result.error}`);
@@ -11709,7 +10547,7 @@ var recentChangesTool = {
       }
       try {
         const result = await getRecentChanges(params);
-        const formattedResult = formatResult3(result);
+        const formattedResult = formatResult2(result);
         context.logger.info("RecentChanges: Retrieved file changes", {
           totalFiles: result.totalFiles,
           displayedFiles: result.files.length,
@@ -11807,14 +10645,8 @@ var b4mTools = {
   sunrise_sunset: sunriseSunsetTool,
   iss_tracker: issTrackerTool,
   planet_visibility: planetVisibilityTool,
-  // 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
+  // Knowledge base search
+  search_knowledge_base: knowledgeBaseSearchTool
 };
 var cliOnlyTools = {
   // File operation tools
@@ -11937,49 +10769,49 @@ var generateMcpTools = async (mcpData) => {
 import throttle2 from "lodash/throttle.js";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionFeatures.js
-import { z as z140 } from "zod";
+import { z as z139 } from "zod";
 import uniq4 from "lodash/uniq.js";
-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()),
+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()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z140.boolean().optional(),
-  enableMementos: z140.boolean().optional(),
-  enableArtifacts: z140.boolean().optional(),
-  enableAgents: z140.boolean().optional(),
+  enableQuestMaster: z139.boolean().optional(),
+  enableMementos: z139.boolean().optional(),
+  enableArtifacts: z139.boolean().optional(),
+  enableAgents: z139.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z140.array(z140.union([b4mLLMTools, z140.string()])).optional(),
-  mcpServers: z140.array(z140.string()).optional(),
-  projectId: z140.string().optional(),
-  organizationId: z140.string().nullable().optional(),
+  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
+  mcpServers: z139.array(z139.string()).optional(),
+  projectId: z139.string().optional(),
+  organizationId: z139.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z140.string().optional(),
+  toolPromptId: z139.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z140.string().optional(),
-  embeddingModel: z140.string().optional(),
-  queryComplexity: z140.string(),
+  fallbackModel: z139.string().optional(),
+  embeddingModel: z139.string().optional(),
+  queryComplexity: z139.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z140.object({
-    maxDepth: z140.number().optional(),
-    duration: z140.number().optional(),
+  deepResearchConfig: z139.object({
+    maxDepth: z139.number().optional(),
+    duration: z139.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z140.array(z140.any()).optional()
+    searchers: z139.array(z139.any()).optional()
   }).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()
+  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()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z140.string().optional(),
+  timezone: z139.string().optional(),
   /** Pre-fetched API key table from invoke phase — avoids redundant DB call in process (#6616 P1-a) */
-  apiKeyTable: z140.record(z140.string(), z140.string().nullable()).optional()
+  apiKeyTable: z139.record(z139.string(), z139.string().nullable()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -12479,89 +11311,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 z141 } from "zod";
+import { z as z140 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
-  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()
+  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()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z142 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-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()
+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()
 });
 
 // ../../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 z143 } from "zod";
+import { z as z142 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
 var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z143.string(),
-  questId: z143.string(),
-  userId: z143.string(),
-  prompt: z143.string(),
-  organizationId: z143.string().nullable().optional(),
-  safety_tolerance: z143.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z143.boolean().optional().default(false),
-  seed: z143.number().nullable().optional(),
-  output_format: z143.enum(["jpeg", "png"]).optional().default("png"),
-  width: z143.number().optional(),
-  height: z143.number().optional(),
-  aspect_ratio: z143.string().optional(),
-  size: z143.string().optional(),
-  fabFileIds: z143.array(z143.string()).optional(),
-  image: z143.string()
+  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()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z144 } from "zod";
-var refineTextLLMSchema = z144.object({
-  text: z144.string(),
-  context: z144.string().optional()
+import { z as z143 } from "zod";
+var refineTextLLMSchema = z143.object({
+  text: z143.string(),
+  context: z143.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 z145 } from "zod";
-var SingleMementoEvalSchema = z145.object({
-  importance: z145.number().min(1).max(10),
+import { z as z144 } from "zod";
+var SingleMementoEvalSchema = z144.object({
+  importance: z144.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z145.string(),
-  tags: z145.array(z145.string()).optional()
+  summary: z144.string(),
+  tags: z144.array(z144.string()).optional()
 });
-var MementoEvalResponseSchema = z145.object({
-  isPersonal: z145.boolean(),
-  mementos: z145.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z144.object({
+  isPersonal: z144.boolean(),
+  mementos: z144.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z146 } from "zod";
+import { z as z145 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -12677,6 +11509,10 @@ var ServerToolExecutor = class {
 };
 
 // src/llm/ToolRouter.ts
+var wsToolExecutor = null;
+function setWebSocketToolExecutor(executor) {
+  wsToolExecutor = executor;
+}
 var SERVER_TOOLS = ["weather_info", "web_search", "web_fetch"];
 var LOCAL_TOOLS = [
   "file_read",
@@ -12699,7 +11535,15 @@ function isLocalTool(toolName) {
 }
 async function executeTool(toolName, input, apiClient, localToolFn) {
   if (isServerTool(toolName)) {
-    logger.debug(`[ToolRouter] Routing ${toolName} to server`);
+    if (wsToolExecutor) {
+      logger.debug(`[ToolRouter] Routing ${toolName} to server via WebSocket`);
+      const result = await wsToolExecutor.execute(toolName, input);
+      if (!result.success) {
+        return `Error executing ${toolName}: ${result.error || "Tool execution failed"}`;
+      }
+      return typeof result.content === "string" ? result.content : JSON.stringify(result.content ?? "");
+    }
+    logger.debug(`[ToolRouter] Routing ${toolName} to server via HTTP`);
     const executor = new ServerToolExecutor(apiClient);
     return await executor.executeTool(toolName, input);
   } else if (isLocalTool(toolName)) {
@@ -12854,7 +11698,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z147 } from "zod";
+import { z as z146 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -12866,40 +11710,40 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z147.object({
-  type: z147.literal("command"),
-  command: z147.string().min(1, "Command is required for command hooks"),
-  timeout: z147.number().optional()
+var CommandHookSchema = z146.object({
+  type: z146.literal("command"),
+  command: z146.string().min(1, "Command is required for command 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 PromptHookSchema = z146.object({
+  type: z146.literal("prompt"),
+  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z146.number().optional()
 });
-var HookDefinitionSchema = z147.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z147.object({
-  matcher: z147.string().optional(),
-  hooks: z147.array(HookDefinitionSchema)
+var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z146.object({
+  matcher: z146.string().optional(),
+  hooks: z146.array(HookDefinitionSchema)
 });
-var AgentHooksSchema = z147.object({
-  PreToolUse: z147.array(HookMatcherSchema).optional(),
-  PostToolUse: z147.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z147.array(HookMatcherSchema).optional(),
-  Stop: z147.array(HookMatcherSchema).optional()
+var AgentHooksSchema = z146.object({
+  PreToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
+  Stop: z146.array(HookMatcherSchema).optional()
 }).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()
+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()
   }).optional(),
-  "default-thoroughness": z147.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z147.record(z147.string()).optional(),
+  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z146.record(z146.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -14629,6 +13473,173 @@ var ServerLlmBackend = class {
   }
 };
 
+// src/llm/WebSocketLlmBackend.ts
+import { v4 as uuidv411 } from "uuid";
+function stripThinkingBlocks2(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+}
+var WebSocketLlmBackend = class {
+  constructor(options) {
+    this.wsManager = options.wsManager;
+    this.apiClient = options.apiClient;
+    this.currentModel = options.model;
+    this.tokenGetter = options.tokenGetter;
+    this.wsCompletionUrl = options.wsCompletionUrl;
+  }
+  /**
+   * Send completion request via HTTP POST, receive streaming response via WebSocket.
+   * Collects all streamed chunks, then calls callback once at completion
+   * with the full accumulated content.
+   */
+  async complete(model, messages, options, callback) {
+    logger.debug(`[WebSocketLlmBackend] Starting complete() with model: ${model}`);
+    if (options.abortSignal?.aborted) {
+      logger.debug("[WebSocketLlmBackend] Request aborted before start");
+      return;
+    }
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const requestId = uuidv411();
+    return new Promise((resolve3, reject) => {
+      const isVerbose = process.env.B4M_VERBOSE === "1";
+      const isUltraVerbose = process.env.B4M_DEBUG_STREAM === "1";
+      const streamLogger = new StreamLogger(logger, "WebSocketLlmBackend", isVerbose, isUltraVerbose);
+      streamLogger.streamStart();
+      let eventCount = 0;
+      let accumulatedText = "";
+      let lastUsageInfo = {};
+      let toolsUsed = [];
+      let thinkingBlocks = [];
+      let settled = false;
+      const settle = (action) => {
+        if (settled) return;
+        settled = true;
+        this.wsManager.offRequest(requestId);
+        this.wsManager.offDisconnect(onDisconnect);
+        action();
+      };
+      const settleResolve = () => settle(() => resolve3());
+      const settleReject = (err) => settle(() => reject(err));
+      const onDisconnect = () => {
+        logger.debug("[WebSocketLlmBackend] Connection dropped during completion");
+        settleReject(new Error("WebSocket connection lost during completion"));
+      };
+      this.wsManager.onDisconnect(onDisconnect);
+      if (options.abortSignal) {
+        if (options.abortSignal.aborted) {
+          settleResolve();
+          return;
+        }
+        options.abortSignal.addEventListener(
+          "abort",
+          () => {
+            logger.debug("[WebSocketLlmBackend] Abort signal received");
+            settleResolve();
+          },
+          { once: true }
+        );
+      }
+      const updateUsage = (usage) => {
+        if (usage) {
+          lastUsageInfo = { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens };
+        }
+      };
+      this.wsManager.onRequest(requestId, (message) => {
+        if (options.abortSignal?.aborted) return;
+        const action = message.action;
+        if (action === "cli_completion_chunk") {
+          eventCount++;
+          const chunk = message.chunk;
+          streamLogger.onEvent(eventCount, JSON.stringify(chunk));
+          const textChunk = chunk.text || "";
+          if (textChunk) accumulatedText += textChunk;
+          updateUsage(chunk.usage);
+          if (chunk.type === "content") {
+            streamLogger.onContent(eventCount, textChunk, accumulatedText);
+          } else if (chunk.type === "tool_use") {
+            streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${chunk.tools?.length}`);
+            if (chunk.tools && chunk.tools.length > 0) toolsUsed = chunk.tools;
+            if (chunk.thinking && chunk.thinking.length > 0) thinkingBlocks = chunk.thinking;
+          }
+        } else if (action === "cli_completion_done") {
+          streamLogger.streamComplete(accumulatedText);
+          const cleanedText = stripThinkingBlocks2(accumulatedText);
+          if (!cleanedText && toolsUsed.length === 0) {
+            settleResolve();
+            return;
+          }
+          const info = {
+            ...lastUsageInfo,
+            ...toolsUsed.length > 0 && { toolsUsed },
+            ...thinkingBlocks.length > 0 && { thinking: thinkingBlocks }
+          };
+          callback([cleanedText], info).then(() => settleResolve()).catch((err) => settleReject(err));
+        } else if (action === "cli_completion_error") {
+          const errorMsg = message.error || "Server error";
+          streamLogger.onCriticalEvent(eventCount, "ERROR", errorMsg);
+          settleReject(new Error(errorMsg));
+        }
+      });
+      const axiosInstance = this.apiClient.getAxiosInstance();
+      axiosInstance.post(
+        this.wsCompletionUrl,
+        {
+          requestId,
+          model,
+          messages,
+          options: {
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            stream: true,
+            tools: options.tools || []
+          }
+        },
+        { signal: options.abortSignal }
+      ).catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        settleReject(new Error(`HTTP request failed: ${msg}`));
+      });
+    });
+  }
+  /**
+   * Get available models from server (REST call, not streaming).
+   * Delegates to ApiClient -- same as ServerLlmBackend.
+   */
+  async getModelInfo() {
+    try {
+      logger.debug("[WebSocketLlmBackend] Fetching models from /api/models");
+      const response = await this.apiClient.get("/api/models");
+      if (!response || typeof response !== "object" || !Array.isArray(response.models)) {
+        logger.warn("[WebSocketLlmBackend] Invalid API response format, using fallback models");
+        return this.getFallbackModels();
+      }
+      const filteredModels = response.models.filter(
+        (model) => model.type === "text" && model.supportsTools === true
+      );
+      if (filteredModels.length === 0) {
+        logger.warn("[WebSocketLlmBackend] No CLI-compatible models found, using fallback");
+        return this.getFallbackModels();
+      }
+      logger.debug(`[WebSocketLlmBackend] Loaded ${filteredModels.length} models`);
+      return filteredModels;
+    } catch (error) {
+      logger.warn(
+        `[WebSocketLlmBackend] Failed to fetch models: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.getFallbackModels();
+    }
+  }
+  getFallbackModels() {
+    return [
+      { id: "claude-sonnet-4-5-20250929", name: "Claude 4.5 Sonnet" },
+      { id: "claude-3-5-haiku-20241022", name: "Claude 3.5 Haiku" },
+      { id: "gpt-4o", name: "GPT-4o" },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini" }
+    ];
+  }
+};
+
 // src/llm/NotifyingLlmBackend.ts
 var NotifyingLlmBackend = class {
   constructor(inner, backgroundManager) {
@@ -14663,6 +13674,253 @@ Please acknowledge these background agent results and incorporate them into your
   }
 };
 
+// src/ws/WebSocketConnectionManager.ts
+var WebSocketConnectionManager = class {
+  constructor(wsUrl, getToken) {
+    this.ws = null;
+    this.heartbeatInterval = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectDelay = 3e4;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.disconnectHandlers = /* @__PURE__ */ new Set();
+    this.reconnectTimer = null;
+    this.connected = false;
+    this.connecting = false;
+    this.closed = false;
+    this.wsUrl = wsUrl;
+    this.getToken = getToken;
+  }
+  /**
+   * Connect to the WebSocket server.
+   * Resolves when connection is established, rejects on failure.
+   */
+  async connect() {
+    if (this.connected || this.connecting) return;
+    this.connecting = true;
+    const token = await this.getToken();
+    if (!token) {
+      this.connecting = false;
+      throw new Error("No access token available for WebSocket connection");
+    }
+    return new Promise((resolve3, reject) => {
+      logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
+      this.ws = new WebSocket(this.wsUrl, [`access_token.${token}`]);
+      this.ws.onopen = () => {
+        logger.debug("[WS] Connected");
+        this.connected = true;
+        this.connecting = false;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        resolve3();
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = typeof event.data === "string" ? event.data : event.data.toString();
+          const message = JSON.parse(data);
+          const requestId = message.requestId;
+          if (requestId && this.handlers.has(requestId)) {
+            this.handlers.get(requestId)(message);
+          } else {
+            logger.debug(`[WS] Unhandled message: ${message.action || "unknown"}`);
+          }
+        } catch (err) {
+          logger.debug(`[WS] Failed to parse message: ${err}`);
+        }
+      };
+      this.ws.onclose = () => {
+        logger.debug("[WS] Connection closed");
+        this.cleanup();
+        this.notifyDisconnect();
+        if (!this.closed) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = (err) => {
+        logger.debug(`[WS] Error: ${err}`);
+        if (this.connecting) {
+          this.connecting = false;
+          this.connected = false;
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+    });
+  }
+  /** Whether the connection is currently established */
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Send a JSON message over the WebSocket connection.
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const payload = JSON.stringify(data);
+    const sizeKB = (payload.length / 1024).toFixed(1);
+    logger.debug(`[WS] Sending ${sizeKB} KB (action: ${data.action})`);
+    if (payload.length > 32e3) {
+      logger.warn(`[WS] Payload ${sizeKB} KB exceeds API Gateway 32 KB frame limit \u2014 connection will be closed`);
+    }
+    this.ws.send(payload);
+  }
+  /**
+   * Register a handler for messages matching a specific requestId.
+   */
+  onRequest(requestId, handler) {
+    this.handlers.set(requestId, handler);
+  }
+  /**
+   * Remove a handler for a specific requestId.
+   */
+  offRequest(requestId) {
+    this.handlers.delete(requestId);
+  }
+  /**
+   * Register a handler that fires when the connection drops.
+   */
+  onDisconnect(handler) {
+    this.disconnectHandlers.add(handler);
+  }
+  /**
+   * Remove a disconnect handler.
+   */
+  offDisconnect(handler) {
+    this.disconnectHandlers.delete(handler);
+  }
+  /**
+   * Close the connection and stop all heartbeat/reconnect logic.
+   */
+  disconnect() {
+    this.closed = true;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.handlers.clear();
+    this.disconnectHandlers.clear();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(
+      () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify({ action: "heartbeat" }));
+          logger.debug("[WS] Heartbeat sent");
+        }
+      },
+      5 * 60 * 1e3
+    );
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.connecting = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  notifyDisconnect() {
+    for (const handler of this.disconnectHandlers) {
+      try {
+        handler();
+      } catch {
+      }
+    }
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+    logger.debug(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.closed) return;
+      try {
+        await this.connect();
+      } catch {
+        logger.debug("[WS] Reconnection failed");
+      }
+    }, delay);
+  }
+};
+
+// src/ws/WebSocketToolExecutor.ts
+import { v4 as uuidv412 } from "uuid";
+var WebSocketToolExecutor = class {
+  constructor(wsManager, tokenGetter) {
+    this.wsManager = wsManager;
+    this.tokenGetter = tokenGetter;
+  }
+  /**
+   * Execute a server-side tool via WebSocket.
+   * Returns the tool result or throws on error.
+   */
+  async execute(toolName, input, abortSignal) {
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const token = await this.tokenGetter();
+    if (!token) {
+      throw new Error("No access token available");
+    }
+    const requestId = uuidv412();
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      const settle = (action) => {
+        if (settled) return;
+        settled = true;
+        this.wsManager.offRequest(requestId);
+        this.wsManager.offDisconnect(onDisconnect);
+        action();
+      };
+      const settleResolve = (result) => settle(() => resolve3(result));
+      const settleReject = (err) => settle(() => reject(err));
+      const onDisconnect = () => {
+        settleReject(new Error("WebSocket connection lost during tool execution"));
+      };
+      this.wsManager.onDisconnect(onDisconnect);
+      if (abortSignal) {
+        if (abortSignal.aborted) {
+          settleReject(new Error("Tool execution aborted"));
+          return;
+        }
+        abortSignal.addEventListener("abort", () => settleReject(new Error("Tool execution aborted")), {
+          once: true
+        });
+      }
+      this.wsManager.onRequest(requestId, (message) => {
+        if (message.action === "cli_tool_response") {
+          settleResolve({
+            success: message.success,
+            content: message.content,
+            error: message.error
+          });
+        }
+      });
+      try {
+        this.wsManager.send({
+          action: "cli_tool_request",
+          accessToken: token,
+          requestId,
+          toolName,
+          input
+        });
+      } catch (err) {
+        settleReject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+};
+
 // src/auth/ApiClient.ts
 import axios11 from "axios";
 var ApiClient = class {
@@ -14800,7 +14058,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-feat-quantum-optimize-architecture.18875+70392944c",
+  version: "0.2.29-feat-cli-websocket-streaming.18881+1cfcea5f6",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -14910,10 +14168,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-feat-quantum-optimize-architecture.18875+70392944c",
-    "@bike4mind/mcp": "1.29.1-feat-quantum-optimize-architecture.18875+70392944c",
-    "@bike4mind/services": "2.48.1-feat-quantum-optimize-architecture.18875+70392944c",
-    "@bike4mind/utils": "2.5.1-feat-quantum-optimize-architecture.18875+70392944c",
+    "@bike4mind/common": "2.50.1-feat-cli-websocket-streaming.18881+1cfcea5f6",
+    "@bike4mind/mcp": "1.29.1-feat-cli-websocket-streaming.18881+1cfcea5f6",
+    "@bike4mind/services": "2.48.1-feat-cli-websocket-streaming.18881+1cfcea5f6",
+    "@bike4mind/utils": "2.5.1-feat-cli-websocket-streaming.18881+1cfcea5f6",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -14930,7 +14188,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "70392944cc76ee8e8b2a9e9a1a82d42beb183058"
+  gitHead: "1cfcea5f6e4c3d36587681e0d276669b66cdcc4e"
 };
 
 // src/config/constants.ts
@@ -15167,50 +14425,6 @@ ${expandedBody}
   };
 }
 
-// src/core/skillsPrompt.ts
-function getSkillDisplayName(cmd) {
-  return cmd.displayName || cmd.name;
-}
-function formatSkillEntry(cmd) {
-  const displayName = getSkillDisplayName(cmd);
-  const argHint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-  const nameDisplay = cmd.displayName && cmd.displayName !== cmd.name ? `**${displayName}** (\`${cmd.name}\`)` : `**${cmd.name}**`;
-  return `- ${nameDisplay}${argHint}: ${cmd.description}
-`;
-}
-function formatSkillGroup(heading, commands) {
-  if (commands.length === 0) {
-    return "";
-  }
-  return `
-### ${heading}
-${commands.map(formatSkillEntry).join("")}`;
-}
-function filterAIVisibleSkills(commands) {
-  return commands.filter((cmd) => !cmd.disableModelInvocation);
-}
-function filterSkillsByAllowedList(commands, allowedSkills) {
-  if (!allowedSkills || allowedSkills.length === 0) {
-    return commands;
-  }
-  return commands.filter((cmd) => allowedSkills.includes(cmd.name));
-}
-function buildSkillsPromptSection(commands, allowedSkills) {
-  const filteredByAllowed = filterSkillsByAllowedList(commands, allowedSkills);
-  const visibleCommands = filterAIVisibleSkills(filteredByAllowed);
-  if (visibleCommands.length === 0) {
-    return "";
-  }
-  const projectSkills = visibleCommands.filter((c) => c.source === "project");
-  const globalSkills = visibleCommands.filter((c) => c.source === "global");
-  return `
-
-## Available Skills
-
-Use the \`skill\` tool to invoke these. Example: skill({ skill: "commit" })
-` + formatSkillGroup("Project Skills", projectSkills) + formatSkillGroup("Global Skills", globalSkills);
-}
-
 // src/agents/SubagentOrchestrator.ts
 var SubagentOrchestrator = class {
   constructor(deps) {
@@ -15791,6 +15005,21 @@ Describe the expected output format here.
     }
     return { builtin, global, project, total: this.agents.size };
   }
+  /**
+   * Generates a markdown "Phone Book" of available agents and their schemas.
+   * This MUST be injected into the System Prompt of the parent agent.
+   */
+  getDirectoryContext() {
+    if (this.agents.size === 0) {
+      return "No sub-agents are currently available.";
+    }
+    let context = "Use `subagent_delegate` for complex tasks requiring specialized analysis.\n";
+    for (const [name, def] of this.agents) {
+      context += ` - **${name}**: ${def.description}
+`;
+    }
+    return context;
+  }
 };
 
 // src/agents/delegateTool.ts
@@ -16738,7 +15967,8 @@ function CliApp() {
     agentStore: null,
     abortController: null,
     contextContent: "",
-    backgroundManager: null
+    backgroundManager: null,
+    wsManager: null
   });
   const [isInitialized, setIsInitialized] = useState9(false);
   const [initError, setInitError] = useState9(null);
@@ -16766,6 +15996,10 @@ function CliApp() {
         })
       );
     }
+    if (state.wsManager) {
+      state.wsManager.disconnect();
+      setWebSocketToolExecutor(null);
+    }
     if (state.agent) {
       state.agent.removeAllListeners();
     }
@@ -16784,7 +16018,7 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore, state.wsManager]);
   useInput9((input, key) => {
     if (key.escape) {
       if (state.abortController) {
@@ -16854,7 +16088,7 @@ function CliApp() {
       if (!isAuthenticated) {
         console.log("\u2139\uFE0F  AI features disabled. Available commands: /login, /help, /config\n");
         const minimalSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16882,10 +16116,45 @@ function CliApp() {
         console.log(`\u{1F30D} API Environment: ${envName} (${apiBaseURL})`);
       }
       const apiClient = new ApiClient(apiBaseURL, state.configStore);
-      const llm = new ServerLlmBackend({
-        apiClient,
-        model: config.defaultModel
-      });
+      const tokenGetter = async () => {
+        const tokens = await state.configStore.getAuthTokens();
+        return tokens?.accessToken ?? null;
+      };
+      let wsManager = null;
+      let llm;
+      try {
+        const serverConfig = await apiClient.get(
+          "/api/settings/serverConfig"
+        );
+        const wsUrl = serverConfig?.websocketUrl;
+        const wsCompletionUrl = serverConfig?.wsCompletionUrl;
+        if (wsUrl && wsCompletionUrl) {
+          wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
+          await wsManager.connect();
+          const wsToolExecutor2 = new WebSocketToolExecutor(wsManager, tokenGetter);
+          setWebSocketToolExecutor(wsToolExecutor2);
+          llm = new WebSocketLlmBackend({
+            wsManager,
+            apiClient,
+            model: config.defaultModel,
+            tokenGetter,
+            wsCompletionUrl
+          });
+          logger.debug("\u{1F50C} Using WebSocket transport (bypasses CloudFront timeout)");
+        } else {
+          throw new Error("No websocketUrl or wsCompletionUrl in server config");
+        }
+      } catch (wsError) {
+        logger.debug(
+          `[WS] WebSocket unavailable, using SSE fallback: ${wsError instanceof Error ? wsError.message : String(wsError)}`
+        );
+        wsManager = null;
+        setWebSocketToolExecutor(null);
+        llm = new ServerLlmBackend({
+          apiClient,
+          model: config.defaultModel
+        });
+      }
       const models = await llm.getModelInfo();
       if (models.length === 0) {
         throw new Error("No models available from server.");
@@ -16898,7 +16167,7 @@ function CliApp() {
       }
       llm.currentModel = modelInfo.id;
       const newSession = {
-        id: uuidv411(),
+        id: uuidv413(),
         name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17048,18 +16317,12 @@ function CliApp() {
       for (const error of contextResult.errors) {
         startupLog.push(`\u26A0\uFE0F  Context file error: ${error}`);
       }
-      let contextSection = contextResult.mergedContent ? `
-
-## Project Context
-
-Follow these project-specific instructions:
-
-${contextResult.mergedContent}` : "";
-      if (enableSkillTool) {
-        const commands = state.customCommandStore.getAllCommands();
-        contextSection += buildSkillsPromptSection(commands);
-      }
-      const cliSystemPrompt = buildCoreSystemPrompt(contextSection);
+      const cliSystemPrompt = buildCoreSystemPrompt({
+        contextContent: contextResult.mergedContent,
+        agentStore,
+        customCommands: state.customCommandStore.getAllCommands(),
+        enableSkillTool
+      });
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
         userId: config.userId,
@@ -17118,8 +16381,10 @@ ${contextResult.mergedContent}` : "";
         // Store agent store for agent management commands
         contextContent: contextResult.mergedContent,
         // Store raw context for compact instructions
-        backgroundManager
+        backgroundManager,
         // Store for grouped notification turn tracking
+        wsManager
+        // WebSocket connection manager (null if using SSE fallback)
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -17214,13 +16479,13 @@ ${contextResult.mergedContent}` : "";
         messageContent = multimodalMessage.content;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17389,7 +16654,12 @@ ${contextResult.mergedContent}` : "";
       const tokenCounter2 = getTokenCounter();
       const contextWindow = tokenCounter2.getContextWindow(activeSession.model, state.availableModels);
       const threshold = contextWindow * 0.8;
-      const systemPrompt = buildCoreSystemPrompt(state.contextContent || "");
+      const systemPrompt = buildCoreSystemPrompt({
+        contextContent: state.contextContent,
+        agentStore: state.agentStore || void 0,
+        customCommands: state.customCommandStore.getAllCommands(),
+        enableSkillTool: config?.preferences.enableSkillTool !== false
+      });
       const contextUsage = tokenCounter2.countSessionTokens(activeSession, systemPrompt);
       if (contextUsage.totalTokens >= threshold) {
         console.log("\n\u26A0\uFE0F  Context window 80% full. Auto-compacting...\n");
@@ -17426,13 +16696,13 @@ ${contextResult.mergedContent}` : "";
         userMessageContent = message;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17510,7 +16780,7 @@ ${contextResult.mergedContent}` : "";
         const currentSession = useCliStore.getState().session;
         if (currentSession) {
           const cancelMessage = {
-            id: uuidv411(),
+            id: uuidv413(),
             role: "assistant",
             content: "\u26A0\uFE0F Operation cancelled by user",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17555,7 +16825,7 @@ ${contextResult.mergedContent}` : "";
     setState((prev) => ({ ...prev, abortController }));
     try {
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17583,7 +16853,7 @@ ${contextResult.mergedContent}` : "";
       const currentSession = useCliStore.getState().session;
       if (!currentSession) return;
       const continuationMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "---\n\n**Background Agent Results:**\n\n" + result.finalAnswer,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17642,13 +16912,13 @@ ${contextResult.mergedContent}` : "";
         isError = true;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: `$ ${command}`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const assistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: isError ? `\u274C Error:
 ${output}` : output.trim() || "(no output)",
@@ -18117,7 +17387,7 @@ Keyboard Shortcuts:
         console.clear();
         const model = state.session?.model || state.config?.defaultModel || "claude-sonnet";
         const newSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18307,15 +17577,21 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         }
         const tokenCounter2 = getTokenCounter();
         const contextWindow = tokenCounter2.getContextWindow(state.session.model, state.availableModels);
-        const corePromptTokens = tokenCounter2.countTokens(buildCoreSystemPrompt(""));
+        const corePromptTokens = tokenCounter2.countTokens(buildCoreSystemPrompt());
         const projectContextTokens = state.contextContent ? tokenCounter2.countTokens(state.contextContent) : 0;
         const commands = state.customCommandStore.getAllCommands();
         const skillsSection = buildSkillsPromptSection(commands);
         const skillsTokens = skillsSection ? tokenCounter2.countTokens(skillsSection) : 0;
+        const agentDirectoryTokens = state.agentStore ? tokenCounter2.countTokens(state.agentStore.getDirectoryContext()) : 0;
         const mcpTools = state.mcpManager?.getTools() || [];
         const mcpToolsTokens = tokenCounter2.countToolSchemaTokens(mcpTools);
         const mcpToolCount = state.mcpManager?.getToolCount() || [];
-        const systemPrompt = buildCoreSystemPrompt(state.contextContent || "");
+        const systemPrompt = buildCoreSystemPrompt({
+          contextContent: state.contextContent,
+          agentStore: state.agentStore || void 0,
+          customCommands: commands,
+          enableSkillTool: state.config?.preferences.enableSkillTool !== false
+        });
         const usage = tokenCounter2.countSessionTokens(state.session, systemPrompt);
         const totalWithTools = usage.totalTokens + mcpToolsTokens;
         const usagePercent = totalWithTools / contextWindow * 100;
@@ -18334,6 +17610,10 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         if (commands.length > 0) {
           console.log(`  Skills Section:    ${skillsTokens.toLocaleString()} tokens (${commands.length} skills)`);
         }
+        if (agentDirectoryTokens > 0) {
+          const agentCount = state.agentStore?.getAgentCount() || 0;
+          console.log(`  Agent Directory:   ${agentDirectoryTokens.toLocaleString()} tokens (${agentCount} agents)`);
+        }
         if (mcpTools.length > 0) {
           console.log("\nMCP Tools:");
           console.log(`  Total:             ${mcpToolsTokens.toLocaleString()} tokens (${mcpTools.length} tools)`);
@@ -18612,9 +17892,9 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       return { ...prev, config: updatedConfig };
     });
     if (modelChanged && state.agent) {
-      const llm = state.agent.context.llm;
-      if (llm) {
-        llm.currentModel = updatedConfig.defaultModel;
+      const backend = state.agent.context.llm;
+      if (backend) {
+        backend.currentModel = updatedConfig.defaultModel;
       }
     }
   };