@bike4mind/cli 0.2.31-cli-update-command.19453 → 0.2.31-cli-update-command.19494

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import "./chunk-GQGOWACU.js";
-import "./chunk-DEW32L4X.js";
-import "./chunk-U4HDDXWT.js";
+import "./chunk-J3NGNWDX.js";
+import "./chunk-E6SLQJIU.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-6HWTNX47.js";
+} from "./chunk-PHQTB34R.js";
 import {
   ConfigStore,
   logger
@@ -16,7 +16,7 @@ import {
 import {
   checkForUpdate,
   package_default
-} from "./chunk-Q6YCIGC3.js";
+} from "./chunk-4G6Y7DHE.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
@@ -32,7 +32,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-24JZFYBV.js";
+} from "./chunk-3LGHTME3.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -90,7 +90,7 @@ import {
   getMcpProviderMetadata,
   getViewById,
   resolveNavigationIntents
-} from "./chunk-E77VWEKZ.js";
+} from "./chunk-UVOOKS6R.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -100,7 +100,7 @@ import React21, { useState as useState10, useEffect as useEffect7, useCallback a
 import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
 import { execSync } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
-import { v4 as uuidv411 } from "uuid";
+import { v4 as uuidv413 } from "uuid";
 
 // src/components/App.tsx
 import React15, { useState as useState6, useEffect as useEffect5 } from "react";
@@ -10186,7 +10186,9 @@ var SolverIdSchema = z139.enum([
   "tabu",
   "genetic-algorithm",
   "ant-colony",
-  "highs"
+  "highs",
+  "simulated-qaoa",
+  "ionq-qaoa"
 ]);
 
 // ../../b4m-core/packages/quantum/dist/src/solvers/greedy-solver.js
@@ -10837,6 +10839,396 @@ function constructSolution(allOps, pheromone, heuristic, rng) {
   return result;
 }
 
+// ../../b4m-core/packages/quantum/dist/src/solvers/metadata.js
+var solverMetadata = {
+  naive: {
+    icon: "\u{1F40C}",
+    // 🐌
+    color: "neutral",
+    complexity: "Exponential - O(n!)",
+    requires: "Browser compute",
+    tagline: "Try every possible solution",
+    fullDescription: "The simplest possible approach: systematically enumerate and evaluate every valid permutation of operations. Guaranteed to find the optimal solution, but becomes computationally infeasible for larger problems due to factorial growth.",
+    howItWorks: [
+      "Generate all valid operation orderings (permutations)",
+      "Evaluate each ordering to compute makespan",
+      "Track the best solution found",
+      "Return the globally optimal solution"
+    ],
+    keyParameters: [{ name: "Search Space", value: "n! permutations for n operations (with pruning for precedence)" }],
+    strengths: ["Guarantees optimal solution", "Simple to understand and implement", "No parameter tuning needed"],
+    weaknesses: [
+      "O(n!) time complexity",
+      "Infeasible for problems with >10 operations",
+      "No early termination heuristics"
+    ],
+    bestFor: "Tiny problems (\u226410 ops) where you need a guaranteed optimal baseline",
+    wikipedia: "https://en.wikipedia.org/wiki/Brute-force_search"
+  },
+  greedy: {
+    icon: "\u26A1",
+    // ⚡
+    color: "success",
+    complexity: "O(n\xB2)",
+    requires: "Browser compute",
+    tagline: "Always pick the locally best choice",
+    fullDescription: 'A fast heuristic that builds a solution by always selecting the "best" available operation at each step. Uses the Shortest Processing Time (SPT) rule: schedule the shortest available operation first. Fast but may miss global optimum.',
+    howItWorks: [
+      "Start with an empty schedule",
+      "Find all operations whose predecessors are complete",
+      "Pick the one with shortest duration (SPT rule)",
+      "Schedule it at the earliest possible time",
+      "Repeat until all operations scheduled"
+    ],
+    keyParameters: [{ name: "Priority Rule", value: "SPT (Shortest Processing Time) \u2014 favors quick operations" }],
+    strengths: ["Extremely fast (O(n\xB2))", "Produces valid solutions instantly", "Good baseline for comparison"],
+    weaknesses: ["No backtracking", "Often far from optimal", "Can make locally optimal but globally poor choices"],
+    bestFor: "Quick baseline, real-time scheduling, or as initial solution for metaheuristics",
+    wikipedia: "https://en.wikipedia.org/wiki/Greedy_algorithm"
+  },
+  "random-restart": {
+    icon: "\u{1F3B2}",
+    // 🎲
+    color: "primary",
+    complexity: "~5 seconds",
+    requires: "Browser compute",
+    tagline: "Climb hills, restart when stuck",
+    fullDescription: "Combines local search with random restarts. From each starting point, repeatedly move to better neighboring solutions until no improvement is possible (local optimum). Then restart from a new random solution. The best solution across all restarts is returned.",
+    howItWorks: [
+      "Generate a random valid schedule",
+      "Try swapping pairs of operations",
+      "Accept swaps that improve makespan",
+      "When stuck (no improving swaps), restart from new random solution",
+      "Track best solution across all restarts"
+    ],
+    keyParameters: [
+      { name: "Max Restarts", value: "Number of times to restart from random (100)" },
+      { name: "Stagnation Limit", value: "Iterations without improvement before restart (1000)" }
+    ],
+    strengths: ["Escapes local optima via restarts", "Simple and parallelizable", "Better than pure hill climbing"],
+    weaknesses: [
+      "No information sharing between restarts",
+      "May revisit similar solutions",
+      "Random restarts are uninformed"
+    ],
+    bestFor: "Medium problems where pure hill climbing gets stuck",
+    wikipedia: "https://en.wikipedia.org/wiki/Hill_climbing#Random-restart_hill_climbing"
+  },
+  "simulated-annealing": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "warning",
+    complexity: "~7 seconds",
+    requires: "Browser compute",
+    tagline: "Cool down from chaos to order",
+    fullDescription: 'Inspired by metallurgy: heating metal and slowly cooling it produces stronger crystal structures. SA starts "hot" (accepting bad moves) and "cools" (becoming pickier). This allows escaping local optima early while converging to good solutions later.',
+    howItWorks: [
+      "Start with high temperature (T=100)",
+      "Generate neighbor by swapping two operations",
+      "If better, always accept",
+      "If worse, accept with probability e^(-\u0394/T)",
+      "Gradually reduce temperature (cooling)",
+      "As T\u21920, behaves like pure hill climbing"
+    ],
+    keyParameters: [
+      { name: "Initial Temperature", value: 'Starting "heat" level (100)' },
+      { name: "Cooling Rate", value: "How fast temperature decreases (~0.9999...)" },
+      { name: "Iterations", value: "5 million moves evaluated" }
+    ],
+    strengths: [
+      "Escapes local optima probabilistically",
+      "Well-studied theoretical properties",
+      "Single parameter to tune (cooling schedule)"
+    ],
+    weaknesses: ["Cooling schedule is problem-dependent", "Can be slow to converge", "Single-solution method"],
+    bestFor: "General optimization when you have moderate compute budget",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  "simulated-annealing-medium": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "warning",
+    complexity: "~70 seconds",
+    requires: "Browser compute",
+    tagline: "Extended cooling for deeper exploration",
+    fullDescription: "Same algorithm as SA but with 10\xD7 more iterations (50M). The slower cooling schedule allows more thorough exploration of the solution space before settling into a final basin.",
+    howItWorks: ["Same as SA standard", "But with 50 million iterations", "Slower cooling = more exploration time"],
+    keyParameters: [
+      { name: "Iterations", value: "50 million moves (10\xD7 standard)" },
+      { name: "Timeout", value: "5 minutes max" }
+    ],
+    strengths: ["More thorough than standard SA", "Better for complex landscapes", "Higher chance of global optimum"],
+    weaknesses: [
+      "10\xD7 slower than standard SA",
+      "Diminishing returns on easy problems",
+      "May be overkill for small instances"
+    ],
+    bestFor: "When standard SA finds good but not great solutions",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  "simulated-annealing-large": {
+    icon: "\u{1F525}",
+    // 🔥
+    color: "danger",
+    complexity: "~12 minutes",
+    requires: "Browser compute",
+    tagline: "Maximum exploration budget",
+    fullDescription: "The heavy artillery: 500 million iterations with up to 30 minutes of compute. For when you absolutely need the best possible solution and have time to wait.",
+    howItWorks: [
+      "Same as SA standard/medium",
+      "But with 500 million iterations",
+      "Very slow cooling for maximum exploration"
+    ],
+    keyParameters: [
+      { name: "Iterations", value: "500 million moves (100\xD7 standard)" },
+      { name: "Timeout", value: "30 minutes max" }
+    ],
+    strengths: ["Maximum exploration", "Best chance at global optimum", "Leaves no stone unturned"],
+    weaknesses: ["Very slow (up to 30 min)", "Massive overkill for small problems", "Diminishing returns"],
+    bestFor: "Large problems where quality matters more than time",
+    wikipedia: "https://en.wikipedia.org/wiki/Simulated_annealing"
+  },
+  tabu: {
+    icon: "\u{1F50D}",
+    // 🔍
+    color: "primary",
+    complexity: "~20\u201340 seconds",
+    requires: "Browser compute",
+    tagline: "Remember mistakes to avoid repeating them",
+    fullDescription: 'This is a classical (simple) Tabu Search following Glover (1986) with aspiration by objective. It maintains a short-term recency-based memory of recent swap moves that are temporarily forbidden ("tabu"). The neighborhood is generated by random pairwise swaps of operations in the permutation representation. Unlike reactive or robust variants, this implementation uses a fixed tabu tenure and does not employ long-term memory, intensification, or diversification phases.',
+    howItWorks: [
+      "Start from a random permutation of operations (seed: 42 for reproducibility)",
+      "Generate 20 random neighbor solutions by swapping two operation positions",
+      "Select the best non-tabu neighbor (even if worse than current \u2014 forced exploration)",
+      "Record the swap as tabu for 15 iterations (fixed tenure)",
+      "Aspiration criterion: override tabu if move produces a new global best",
+      "Repeat for 10,000 iterations or until timeout (15s)",
+      "Periodically clean expired entries from the tabu list"
+    ],
+    keyParameters: [
+      { name: "Variant", value: "Simple Tabu Search (Glover 1986) with aspiration by objective" },
+      { name: "Tabu Structure", value: "Swap-based \u2014 records position pairs (i,j) that were swapped" },
+      { name: "Tabu Tenure", value: "Fixed at 15 iterations (no reactive adjustment)" },
+      { name: "Neighborhood Size", value: "20 random swap candidates evaluated per iteration" },
+      { name: "Total Iterations", value: "10,000" },
+      { name: "Aspiration", value: "Accept tabu move if it improves the global best" },
+      { name: "Memory Type", value: "Short-term recency only (no frequency-based long-term memory)" }
+    ],
+    strengths: [
+      "Memory prevents cycling back to recently visited solutions",
+      "Forced acceptance of worse moves enables escaping local optima",
+      "Aspiration criterion preserves exploitation of exceptional solutions",
+      "Deterministic with seed (reproducible results)"
+    ],
+    weaknesses: [
+      "Fixed tenure \u2014 no adaptive/reactive adjustment to search dynamics",
+      "No long-term memory (frequency-based diversification)",
+      "No intensification phase to deep-search promising regions",
+      "Small neighborhood (20) may miss good moves in large search spaces"
+    ],
+    bestFor: "Medium-complexity problems with many local optima and plateau regions",
+    wikipedia: "https://en.wikipedia.org/wiki/Tabu_search",
+    otherResources: [
+      { label: "Glover (1986) \u2014 Original paper", url: "https://doi.org/10.1016/0305-0548(86)90048-1" },
+      {
+        label: "Glover & Laguna \u2014 Tabu Search (book)",
+        url: "https://en.wikipedia.org/wiki/Tabu_search#References"
+      }
+    ]
+  },
+  "genetic-algorithm": {
+    icon: "\u{1F9EC}",
+    // 🧬
+    color: "success",
+    complexity: "~30 seconds",
+    requires: "Browser compute",
+    tagline: "Evolve solutions through natural selection",
+    fullDescription: 'Inspired by biological evolution: maintain a population of solutions that reproduce, mutate, and compete. Better solutions are more likely to survive and pass on their "genes" (good partial solutions). Over generations, the population evolves toward optimality.',
+    howItWorks: [
+      "Initialize population of 100 random schedules",
+      "Evaluate fitness (1/makespan) for each",
+      "Selection: pick parents via tournament (best of 5 random)",
+      "Crossover: combine two parents to create child",
+      "Mutation: randomly swap operations (20% chance)",
+      "Elitism: top 5 solutions survive unchanged",
+      "Repeat for 15,000 generations"
+    ],
+    keyParameters: [
+      { name: "Population Size", value: "Number of solutions maintained (100)" },
+      { name: "Generations", value: "Evolution cycles (15,000)" },
+      { name: "Crossover Rate", value: "Probability of combining parents (80%)" },
+      { name: "Mutation Rate", value: "Probability of random change (20%)" },
+      { name: "Elite Count", value: "Best solutions preserved unchanged (5)" }
+    ],
+    strengths: ["Population maintains diversity", "Crossover combines good building blocks", "Naturally parallel"],
+    weaknesses: ["Many parameters to tune", "Can converge prematurely", "Crossover design is problem-specific"],
+    bestFor: "Complex problems where good solutions share common substructures",
+    wikipedia: "https://en.wikipedia.org/wiki/Genetic_algorithm",
+    otherResources: [
+      {
+        label: "Order Crossover (OX)",
+        url: "https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)#Order_crossover_(OX)"
+      }
+    ]
+  },
+  "ant-colony": {
+    icon: "\u{1F41C}",
+    // 🐜
+    color: "success",
+    complexity: "~30 seconds",
+    requires: "Browser compute",
+    tagline: "Follow the pheromone trails",
+    fullDescription: "Inspired by how ants find shortest paths to food: they deposit pheromones, and other ants preferentially follow stronger trails. Over time, shorter paths accumulate more pheromone (ants traverse them faster), creating positive feedback toward good solutions.",
+    howItWorks: [
+      "Initialize pheromone trails uniformly",
+      "Each ant builds a complete schedule probabilistically",
+      "Operations with more pheromone are more likely to be chosen",
+      "After all ants finish, evaluate their solutions",
+      "Deposit pheromone on edges used by good solutions",
+      "Evaporate some pheromone (forget old information)",
+      "Best ant's solution gets extra pheromone (elitism)"
+    ],
+    keyParameters: [
+      { name: "Number of Ants", value: "Solutions built per iteration (50)" },
+      { name: "Iterations", value: "Pheromone update cycles (100,000)" },
+      { name: "Alpha (\u03B1)", value: "Pheromone importance (1.0)" },
+      { name: "Beta (\u03B2)", value: "Heuristic importance (2.0)" },
+      { name: "Evaporation Rate", value: "Pheromone decay per iteration (10%)" }
+    ],
+    strengths: ["Implicit parallelism", "Positive feedback accelerates convergence", "Robust to problem changes"],
+    weaknesses: ["Many parameters", "Can converge prematurely", "Pheromone model must match problem"],
+    bestFor: 'Routing and sequencing problems with clear "edge" structure',
+    wikipedia: "https://en.wikipedia.org/wiki/Ant_colony_optimization_algorithms",
+    otherResources: [{ label: "Marco Dorigo (inventor)", url: "https://en.wikipedia.org/wiki/Marco_Dorigo" }]
+  },
+  highs: {
+    icon: "\u{1F3AF}",
+    // 🎯
+    color: "success",
+    complexity: "Seconds to minutes",
+    requires: "Browser compute (WASM)",
+    available: false,
+    tagline: "Open-source solver rivaling commercial giants",
+    fullDescription: "HiGHS (High-performance Interior-point, Gradient-descent, Simplex) is an MIT-licensed open-source solver that achieves 90%+ of commercial solver performance. Developed at the University of Edinburgh, it has rapidly become the leading open-source alternative to Gurobi and COPT for linear and mixed-integer programming.",
+    howItWorks: [
+      "Formulate problem as Integer Linear Program (ILP/MIP)",
+      "Presolve: simplify model, tighten bounds, detect infeasibility",
+      "LP relaxation using dual simplex or interior-point method",
+      "Branch-and-bound with sophisticated node selection",
+      "Cutting planes: Gomory cuts, MIR cuts, cover cuts",
+      "Return optimal (or near-optimal) solution with gap certificate"
+    ],
+    keyParameters: [
+      { name: "Time Limit", value: "Maximum solve time before returning best found" },
+      { name: "MIP Gap", value: "Stop when proven within X% of optimal (e.g., 0.01 = 1%)" },
+      { name: "Threads", value: "Number of parallel threads (default: all cores)" }
+    ],
+    strengths: [
+      "MIT licensed \u2014 fully open source, embed anywhere",
+      "90%+ of Gurobi/COPT performance on most problems",
+      "Active development with rapid improvements",
+      "Can deploy in customer infrastructure (no license servers)"
+    ],
+    weaknesses: [
+      "Slightly slower than Gurobi on very large instances",
+      "Fewer specialized cuts than commercial solvers",
+      "Less mature ecosystem (but growing fast)"
+    ],
+    bestFor: "Production scheduling when you need commercial-grade results without commercial licensing",
+    wikipedia: "https://en.wikipedia.org/wiki/HiGHS_optimization_solver",
+    otherResources: [
+      { label: "HiGHS GitHub", url: "https://github.com/ERGO-Code/HiGHS" },
+      { label: "HiGHS Documentation", url: "https://highs.dev/" },
+      { label: "Mittelmann MIP Benchmarks", url: "http://plato.asu.edu/ftp/milp.html" }
+    ]
+  },
+  "simulated-qaoa": {
+    icon: "\u{1F52E}",
+    // 🔮
+    color: "primary",
+    complexity: "~30\u201360 seconds",
+    requires: "Backend compute",
+    available: false,
+    tagline: "Quantum-inspired classical simulation",
+    fullDescription: "A classical simulator of the Quantum Approximate Optimization Algorithm (QAOA). Encodes the job-shop scheduling problem as a QUBO (Quadratic Unconstrained Binary Optimization), then simulates the quantum variational circuit classically. Provides a preview of quantum advantage without requiring real quantum hardware.",
+    howItWorks: [
+      "Encode scheduling problem as QUBO matrix",
+      "Initialize simulated quantum state |+\u27E9\u2297\u207F",
+      "Apply p layers of QAOA circuit (problem + mixer unitaries)",
+      "Classically optimize variational parameters (\u03B3, \u03B2)",
+      "Measure (sample) the final state to extract candidate schedules",
+      "Decode best bitstring back to a valid schedule"
+    ],
+    keyParameters: [
+      { name: "QAOA Depth (p)", value: "Number of alternating layers (default: 3)" },
+      { name: "Optimizer", value: "COBYLA for variational parameter optimization" },
+      { name: "Shots", value: "Number of measurement samples (1024)" },
+      { name: "Qubits", value: "One per possible (job, timeslot) assignment" }
+    ],
+    strengths: [
+      "Preview quantum algorithms without quantum hardware",
+      "Explores solution space via quantum superposition (simulated)",
+      "Useful for benchmarking against real quantum results",
+      "Runs entirely in-browser or on backend \u2014 no API keys needed"
+    ],
+    weaknesses: [
+      "Exponential classical overhead \u2014 limited to ~20 qubits",
+      "Cannot capture true quantum speedup",
+      "QUBO encoding may not be optimal for all problem structures",
+      "Variational optimization can get stuck in local minima"
+    ],
+    bestFor: "Small problems where you want to preview quantum approaches before investing in real hardware",
+    wikipedia: "https://en.wikipedia.org/wiki/Quantum_approximate_optimization_algorithm",
+    otherResources: [
+      { label: "Farhi et al. (2014) \u2014 Original QAOA Paper", url: "https://arxiv.org/abs/1411.4028" },
+      { label: "QUBO Formulation Guide", url: "https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization" }
+    ]
+  },
+  "ionq-qaoa": {
+    icon: "\u269B\uFE0F",
+    // ⚛️
+    color: "danger",
+    complexity: "Minutes (queue + execution)",
+    requires: "IonQ API key + credits",
+    available: false,
+    tagline: "Real quantum hardware optimization",
+    fullDescription: "Runs the Quantum Approximate Optimization Algorithm on IonQ\u2019s trapped-ion quantum computers. This is real quantum computation \u2014 the problem is encoded as a QUBO, compiled to native quantum gates, and executed on physical qubits. Results include genuine quantum effects like superposition and entanglement.",
+    howItWorks: [
+      "Encode scheduling problem as QUBO matrix",
+      "Compile QAOA circuit to IonQ\u2019s native gate set (MS, GPi, GPi2)",
+      "Submit job to IonQ cloud via API",
+      "Queue for hardware execution (trapped-ion processor)",
+      "Execute quantum circuit with real qubits",
+      "Retrieve measurement results and decode to schedule"
+    ],
+    keyParameters: [
+      { name: "QAOA Depth (p)", value: "Number of alternating layers (default: 1\u20132 for NISQ)" },
+      { name: "Backend", value: "IonQ Harmony (11 qubits) or Aria (25 qubits)" },
+      { name: "Shots", value: "Number of circuit executions (1024)" },
+      { name: "Error Mitigation", value: "IonQ debiasing enabled by default" }
+    ],
+    strengths: [
+      "Real quantum computation with genuine quantum effects",
+      "Trapped-ion qubits have high gate fidelity (~99.5%)",
+      "All-to-all connectivity \u2014 no SWAP overhead",
+      "Potential for quantum advantage on certain problem classes"
+    ],
+    weaknesses: [
+      "Requires IonQ API key and credits (not free)",
+      "Queue wait times can be minutes to hours",
+      "Limited to ~25 qubits (current hardware)",
+      "NISQ noise limits circuit depth and solution quality"
+    ],
+    bestFor: "Exploring real quantum optimization on small problem instances when you have IonQ access",
+    wikipedia: "https://en.wikipedia.org/wiki/Trapped-ion_quantum_computer",
+    otherResources: [
+      { label: "IonQ Documentation", url: "https://docs.ionq.com/" },
+      { label: "IonQ Aria Specs", url: "https://ionq.com/quantum-systems/aria" },
+      { label: "QAOA on NISQ Devices", url: "https://arxiv.org/abs/1812.01041" }
+    ]
+  }
+};
+
 // ../../b4m-core/packages/quantum/dist/src/solvers/index.js
 var allSolvers = [
   greedySolver,
@@ -10856,9 +11248,15 @@ function getSolver(id) {
 function getAvailableSolverIds() {
   return Array.from(solverRegistry.keys());
 }
+var displaySolvers = [
+  ...allSolvers.map((s) => ({ id: s.id, name: s.name, description: s.description })),
+  { id: "highs", name: "HiGHS (WASM)", description: solverMetadata.highs.tagline },
+  { id: "simulated-qaoa", name: "Simulated QAOA", description: solverMetadata["simulated-qaoa"].tagline },
+  { id: "ionq-qaoa", name: "IonQ QAOA", description: solverMetadata["ionq-qaoa"].tagline }
+];
 
 // ../../b4m-core/packages/quantum/dist/src/prompts/system-prompt.js
-var QUANTUM_CANVASSER_SYSTEM_PROMPT = `You are 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.
+var QUANTUM_CANVASSER_SYSTEM_PROMPT = `You are OptiHashi, an AI agent specializing in combinatorial optimization and job-shop scheduling. You help users formulate scheduling problems, run solver algorithms, and interpret optimization results. You are solver-agnostic \u2014 you route problems to the best solver whether classical (greedy, simulated annealing, genetic algorithms, HiGHS MIP) or quantum (QAOA), building credibility through honest recommendations.
 
 ## Your Capabilities
 
@@ -13290,9 +13688,7 @@ var QuestStartBodySchema = z140.object({
     fabFileIds: z140.array(z140.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z140.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()
+  timezone: z140.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
@@ -13990,6 +14386,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",
@@ -14012,7 +14412,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)) {
@@ -15974,6 +16382,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) {
@@ -16008,6 +16583,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 {
@@ -17913,7 +18735,8 @@ function CliApp() {
     agentStore: null,
     abortController: null,
     contextContent: "",
-    backgroundManager: null
+    backgroundManager: null,
+    wsManager: null
   });
   const [isInitialized, setIsInitialized] = useState10(false);
   const [initError, setInitError] = useState10(null);
@@ -17941,6 +18764,10 @@ function CliApp() {
         })
       );
     }
+    if (state.wsManager) {
+      state.wsManager.disconnect();
+      setWebSocketToolExecutor(null);
+    }
     if (state.agent) {
       state.agent.removeAllListeners();
     }
@@ -17959,7 +18786,7 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore, state.wsManager]);
   useInput9((input, key) => {
     if (key.escape) {
       const store = useCliStore.getState();
@@ -18034,7 +18861,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(),
@@ -18062,10 +18889,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.");
@@ -18078,7 +18940,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(),
@@ -18292,8 +19154,10 @@ function CliApp() {
         // Store agent store for agent management commands
         contextContent: contextResult.mergedContent,
         // Store raw context for compact instructions
-        backgroundManager
+        backgroundManager,
         // Store for grouped notification turn tracking
+        wsManager
+        // WebSocket connection manager (null if using SSE fallback)
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -18388,13 +19252,13 @@ function CliApp() {
         messageContent = multimodalMessage.content;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18607,13 +19471,13 @@ function CliApp() {
         userMessageContent = message;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18693,7 +19557,7 @@ function CliApp() {
         const currentSession = useCliStore.getState().session;
         if (currentSession) {
           const cancelMessage = {
-            id: uuidv411(),
+            id: uuidv413(),
             role: "assistant",
             content: "\u26A0\uFE0F Operation cancelled by user",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18738,7 +19602,7 @@ function CliApp() {
     setState((prev) => ({ ...prev, abortController }));
     try {
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18766,7 +19630,7 @@ function CliApp() {
       const currentSession = useCliStore.getState().session;
       if (!currentSession) return;
       const continuationMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "---\n\n**Background Agent Results:**\n\n" + result.finalAnswer,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18827,13 +19691,13 @@ function CliApp() {
         isError = true;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: `$ ${command}`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const assistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: isError ? `\u274C Error:
 ${output}` : output.trim() || "(no output)",
@@ -19302,7 +20166,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(),
@@ -19807,9 +20671,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;
       }
     }
   };