nexus-agents 2.29.0 → 2.29.2

package/dist/{chunk-IMWYKX4H.js → chunk-HSOPD265.js}

@@ -210,7 +210,7 @@ ${COLORS.dim}${entry.error.stack}${COLORS.reset}` : "";
 `;
 }
 var globalFormat = "json";
-var globalDestination = "stdout";
+var globalDestination = "stderr";
 var globalFilePath;
 var fileStream;
 function getOutputStream() {
@@ -270,6 +270,33 @@ function createLogger(baseContext) {
 }
 var logger = createLogger();
 
+// src/context/mobimem-types.ts
+import { z } from "zod";
+var DEFAULT_MOBIMEM_CONFIG = {
+  dbPath: ":memory:",
+  maxProfileEntries: 100,
+  maxExperiencePatterns: 500,
+  maxActionCacheEntries: 1e3,
+  actionCacheTtlMs: 36e5,
+  // 1 hour
+  minProfileConfidence: 0.6,
+  minExperienceSuccessRate: 0.7,
+  autoEviction: true
+};
+var MobiMemConfigSchema = z.object({
+  dbPath: z.string(),
+  maxProfileEntries: z.number().int().positive().default(100),
+  maxExperiencePatterns: z.number().int().positive().default(500),
+  maxActionCacheEntries: z.number().int().positive().default(1e3),
+  actionCacheTtlMs: z.number().int().positive().default(36e5),
+  minProfileConfidence: z.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z.number().min(0).max(1).default(0.7),
+  autoEviction: z.boolean().default(true)
+});
+
+// src/context/mobimem-impl.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
 // src/core/result.ts
 function ok(value) {
   return { ok: true, value };
@@ -471,7 +498,7 @@ function extractObjectMessage(error, fallback) {
 }
 
 // src/config/model-capabilities-types.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var OUTPUT_MODALITIES = [
   "text",
   "image_png",
@@ -508,7 +535,7 @@ var SPECIAL_FEATURES = [
 ];
 var PROVIDERS = ["anthropic", "google", "openai", "custom-openai", "openrouter"];
 var CLI_NAMES = ["claude", "gemini", "codex", "opencode"];
-var CliNameSchema = z.enum(CLI_NAMES);
+var CliNameSchema = z2.enum(CLI_NAMES);
 var DEFAULT_CLI = "claude";
 var MODEL_IDS = [
   "claude-opus",
@@ -527,63 +554,63 @@ var MODEL_IDS = [
   "openrouter-nemotron-super",
   "openrouter-qwen-coder"
 ];
-var QualityScoresSchema = z.object({
-  reasoning: z.number().min(0).max(10),
-  codeGeneration: z.number().min(0).max(10),
-  speed: z.number().min(0).max(10),
-  cost: z.number().min(0).max(10)
+var QualityScoresSchema = z2.object({
+  reasoning: z2.number().min(0).max(10),
+  codeGeneration: z2.number().min(0).max(10),
+  speed: z2.number().min(0).max(10),
+  cost: z2.number().min(0).max(10)
 });
-var PricingSchema = z.object({
-  inputPer1M: z.number().nonnegative(),
-  outputPer1M: z.number().nonnegative()
+var PricingSchema = z2.object({
+  inputPer1M: z2.number().nonnegative(),
+  outputPer1M: z2.number().nonnegative()
 });
-var ModelCapabilitySchema = z.object({
+var ModelCapabilitySchema = z2.object({
   /** Unique model identifier matching delegate_to_model model IDs */
-  id: z.enum(MODEL_IDS),
+  id: z2.enum(MODEL_IDS),
   /** Human-readable display name */
-  displayName: z.string().min(1),
+  displayName: z2.string().min(1),
   /** Provider/vendor */
-  provider: z.enum(PROVIDERS),
+  provider: z2.enum(PROVIDERS),
   /** Maximum context window in tokens */
-  contextWindow: z.number().int().positive(),
+  contextWindow: z2.number().int().positive(),
   /** Output modalities this model can produce */
-  outputModalities: z.array(z.enum(OUTPUT_MODALITIES)).min(1),
+  outputModalities: z2.array(z2.enum(OUTPUT_MODALITIES)).min(1),
   /** Input modalities this model can accept */
-  inputModalities: z.array(z.enum(INPUT_MODALITIES)).min(1),
+  inputModalities: z2.array(z2.enum(INPUT_MODALITIES)).min(1),
   /** Tool/integration capabilities */
-  toolCapabilities: z.array(z.enum(TOOL_CAPABILITIES)),
+  toolCapabilities: z2.array(z2.enum(TOOL_CAPABILITIES)),
   /** Special features beyond standard generation */
-  specialFeatures: z.array(z.enum(SPECIAL_FEATURES)),
+  specialFeatures: z2.array(z2.enum(SPECIAL_FEATURES)),
   /** Known constraints or limitations */
-  constraints: z.array(z.string()).optional(),
+  constraints: z2.array(z2.string()).optional(),
   /** Notes about the model (e.g., beta features, pricing tier) */
-  notes: z.string().optional(),
+  notes: z2.string().optional(),
   /** Pricing per 1M tokens (USD) */
   pricing: PricingSchema.optional(),
   /** Quality scores for routing (0-10 scale) */
   qualityScores: QualityScoresSchema.optional(),
   /** Maximum output tokens */
-  maxOutputTokens: z.number().int().positive().optional(),
+  maxOutputTokens: z2.number().int().positive().optional(),
   /** Which CLI tool this model belongs to */
-  cliName: z.enum(CLI_NAMES).optional(),
+  cliName: z2.enum(CLI_NAMES).optional(),
   /** Short alias used by the CLI (e.g., 'opus' for Claude CLI) */
-  cliAlias: z.string().optional(),
+  cliAlias: z2.string().optional(),
   /** Model name the CLI binary expects (e.g., 'gemini-2.5-pro') */
-  cliModelName: z.string().optional(),
+  cliModelName: z2.string().optional(),
   /** Whether this model is deprecated and should receive a scoring penalty */
-  deprecated: z.boolean().optional(),
+  deprecated: z2.boolean().optional(),
   /** ISO date when the model was deprecated (informational) */
-  deprecatedAt: z.string().optional(),
+  deprecatedAt: z2.string().optional(),
   /** Model ID to migrate to (informational guidance) */
-  replacedBy: z.enum(MODEL_IDS).optional()
+  replacedBy: z2.enum(MODEL_IDS).optional()
 });
-var ModelCapabilitiesMatrixSchema = z.object({
+var ModelCapabilitiesMatrixSchema = z2.object({
   /** Schema version for forward compatibility */
-  version: z.number().int().positive(),
+  version: z2.number().int().positive(),
   /** Last updated date (ISO 8601) */
-  updatedAt: z.string(),
+  updatedAt: z2.string(),
   /** Model capability definitions */
-  models: z.array(ModelCapabilitySchema).min(1)
+  models: z2.array(ModelCapabilitySchema).min(1)
 });
 
 // src/config/model-capabilities.ts
@@ -1437,7 +1464,7 @@ function formatPercentage(value, decimals = 0) {
 
 // src/core/artifact.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var ArtifactType = {
   /** Planning documents and task breakdowns */
   PLAN: "plan",
@@ -1450,30 +1477,30 @@ var ArtifactType = {
   /** Intent declarations for policy authorization */
   INTENT: "intent"
 };
-var ArtifactTypeSchema = z2.enum([
+var ArtifactTypeSchema = z3.enum([
   ArtifactType.PLAN,
   ArtifactType.ANALYSIS,
   ArtifactType.DECISION,
   ArtifactType.RESULT,
   ArtifactType.INTENT
 ]);
-var ArtifactMetadataSchema = z2.object({
-  createdAt: z2.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
-  createdBy: z2.string().min(1, "createdBy is required"),
-  parentId: z2.uuid().optional(),
-  taskId: z2.string().min(1, "taskId is required"),
-  traceId: z2.string().optional()
+var ArtifactMetadataSchema = z3.object({
+  createdAt: z3.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
+  createdBy: z3.string().min(1, "createdBy is required"),
+  parentId: z3.uuid().optional(),
+  taskId: z3.string().min(1, "taskId is required"),
+  traceId: z3.string().optional()
 });
 function createArtifactSchema(dataSchema) {
-  return z2.object({
-    id: z2.uuid(),
+  return z3.object({
+    id: z3.uuid(),
     type: ArtifactTypeSchema,
-    schemaVersion: z2.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
+    schemaVersion: z3.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
     data: dataSchema,
     metadata: ArtifactMetadataSchema
   });
 }
-var BaseArtifactSchema = createArtifactSchema(z2.unknown());
+var BaseArtifactSchema = createArtifactSchema(z3.unknown());
 
 // src/core/metrics.ts
 var MAX_RECENT_ERRORS = 1e3;
@@ -3513,19 +3540,19 @@ var TopsisRouter = class {
 };
 
 // src/cli-adapters/budget-router-types.ts
-import { z as z3 } from "zod";
-var BudgetConstraintSchema = z3.object({
-  maxTokens: z3.number().int().positive().optional(),
-  maxCostUSD: z3.number().positive().optional(),
-  maxLatencyMs: z3.number().positive().optional()
+import { z as z4 } from "zod";
+var BudgetConstraintSchema = z4.object({
+  maxTokens: z4.number().int().positive().optional(),
+  maxCostUSD: z4.number().positive().optional(),
+  maxLatencyMs: z4.number().positive().optional()
 });
-var SessionBudgetSchema = z3.object({
-  totalTokens: z3.number().int().positive(),
-  totalCostUSD: z3.number().positive(),
-  usedTokens: z3.number().int().min(0).default(0),
-  usedCostUSD: z3.number().min(0).default(0),
-  startTime: z3.number().int().positive(),
-  sessionId: z3.string().min(1)
+var SessionBudgetSchema = z4.object({
+  totalTokens: z4.number().int().positive(),
+  totalCostUSD: z4.number().positive(),
+  usedTokens: z4.number().int().min(0).default(0),
+  usedCostUSD: z4.number().min(0).default(0),
+  startTime: z4.number().int().positive(),
+  sessionId: z4.string().min(1)
 });
 var DEFAULT_LINUCB_CONFIG = {
   numArms: 4,
@@ -3533,11 +3560,11 @@ var DEFAULT_LINUCB_CONFIG = {
   alpha: 1,
   lambda: 1
 };
-var LinUCBConfigSchema = z3.object({
-  numArms: z3.number().int().positive().default(4),
-  featureDim: z3.number().int().positive().default(6),
-  alpha: z3.number().positive().default(1),
-  lambda: z3.number().positive().default(1)
+var LinUCBConfigSchema = z4.object({
+  numArms: z4.number().int().positive().default(4),
+  featureDim: z4.number().int().positive().default(6),
+  alpha: z4.number().positive().default(1),
+  lambda: z4.number().positive().default(1)
 });
 
 // src/cli-adapters/linucb-math.ts
@@ -3892,7 +3919,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -3913,24 +3940,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-var PreferenceRouterConfigSchema = z4.object({
-  strongModel: z4.object({
-    tier: z4.literal("strong"),
-    cli: z4.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z4.number().positive(),
-    qualityBaseline: z4.number().min(0).max(1)
+var PreferenceRouterConfigSchema = z5.object({
+  strongModel: z5.object({
+    tier: z5.literal("strong"),
+    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z5.number().positive(),
+    qualityBaseline: z5.number().min(0).max(1)
   }),
-  weakModel: z4.object({
-    tier: z4.literal("weak"),
-    cli: z4.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z4.number().positive(),
-    qualityBaseline: z4.number().min(0).max(1)
+  weakModel: z5.object({
+    tier: z5.literal("weak"),
+    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z5.number().positive(),
+    qualityBaseline: z5.number().min(0).max(1)
   }),
-  routingThreshold: z4.number().min(0).max(1).default(0.5),
-  minDataPoints: z4.number().int().positive().default(10),
-  maxDataPoints: z4.number().int().positive().default(1e4),
-  enableOnlineLearning: z4.boolean().default(true),
-  domainThresholds: z4.record(z4.string(), z4.number().min(0).max(1)).optional()
+  routingThreshold: z5.number().min(0).max(1).default(0.5),
+  minDataPoints: z5.number().int().positive().default(10),
+  maxDataPoints: z5.number().int().positive().default(1e4),
+  enableOnlineLearning: z5.boolean().default(true),
+  domainThresholds: z5.record(z5.string(), z5.number().min(0).max(1)).optional()
 });
 
 // src/cli-adapters/preference-router-store.ts
@@ -4272,8 +4299,8 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z5 } from "zod";
-var DifficultyDimensionSchema = z5.enum([
+import { z as z6 } from "zod";
+var DifficultyDimensionSchema = z6.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -4287,17 +4314,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z5.object({
+var DifficultySpaceSchema = z6.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z5.number().min(0).max(1),
+  reasoning: z6.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z5.number().min(0).max(1),
+  knowledge: z6.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z5.number().min(0).max(1),
+  creativity: z6.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z5.number().min(0).max(1),
+  precision: z6.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z5.number().min(0).max(1)
+  context_length: z6.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -4313,12 +4340,12 @@ var DEFAULT_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DifficultyWeightsSchema = z5.object({
-  reasoning: z5.number().min(0).max(1),
-  knowledge: z5.number().min(0).max(1),
-  creativity: z5.number().min(0).max(1),
-  precision: z5.number().min(0).max(1),
-  context_length: z5.number().min(0).max(1)
+var DifficultyWeightsSchema = z6.object({
+  reasoning: z6.number().min(0).max(1),
+  knowledge: z6.number().min(0).max(1),
+  creativity: z6.number().min(0).max(1),
+  precision: z6.number().min(0).max(1),
+  context_length: z6.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_WEIGHTS = {
   reasoning: 0.3,
@@ -4327,29 +4354,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z5.object({
+var ZeroRouterConfigSchema = z6.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z5.object({
-    easyUpperBound: z5.number().min(0).max(1),
-    hardLowerBound: z5.number().min(0).max(1)
+  thresholds: z6.object({
+    easyUpperBound: z6.number().min(0).max(1),
+    hardLowerBound: z6.number().min(0).max(1)
   }).default(DEFAULT_DIFFICULTY_THRESHOLDS),
   /** Weights for difficulty aggregation */
   weights: DifficultyWeightsSchema.default(DEFAULT_DIFFICULTY_WEIGHTS),
   /** Mapping from difficulty level to model tier */
-  difficultyToTier: z5.record(z5.enum(["easy", "medium", "hard"]), z5.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
+  difficultyToTier: z6.record(z6.enum(["easy", "medium", "hard"]), z6.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z5.record(
-    z5.enum(["fast", "balanced", "powerful"]),
-    z5.array(z5.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z6.record(
+    z6.enum(["fast", "balanced", "powerful"]),
+    z6.array(z6.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z5.boolean().default(true),
+  enableCalibration: z6.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z5.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z6.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z5.number().int().positive().default(50),
+  minCalibrationOutcomes: z6.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z5.boolean().default(false)
+  verbose: z6.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -4873,16 +4900,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z6 } from "zod";
-var LatencyTrackerConfigSchema = z6.object({
+import { z as z7 } from "zod";
+var LatencyTrackerConfigSchema = z7.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z6.number().int().positive().default(100),
+  windowSize: z7.number().int().positive().default(100),
   /** Time-weighted decay factor (0-1, higher = more weight to recent) (default: 0.95) */
-  decayFactor: z6.number().min(0).max(1).default(0.95),
+  decayFactor: z7.number().min(0).max(1).default(0.95),
   /** Maximum age of samples in milliseconds before forced eviction (default: 3600000 = 1 hour) */
-  maxSampleAgeMs: z6.number().int().positive().default(36e5),
+  maxSampleAgeMs: z7.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z6.array(z6.number().min(0).max(100)).default([50, 95, 99])
+  percentiles: z7.array(z7.number().min(0).max(100)).default([50, 95, 99])
 });
 var EMPTY_LATENCY_STATS = {
   count: 0,
@@ -5116,20 +5143,192 @@ var LatencyTracker = class {
   }
 };
 
+// src/context/routing-memory.ts
+var DEFAULT_ROUTING_MEMORY_CONFIG = {
+  minObservations: 5,
+  confidenceThreshold: 0.6,
+  successRateThreshold: 0.7,
+  actionCacheMaxAgeMs: 36e5
+  // 1 hour
+};
+var RoutingMemory = class {
+  mobimem;
+  config;
+  logger;
+  // Statistics
+  cacheHits = 0;
+  cacheMisses = 0;
+  recommendationsMade = 0;
+  constructor(config, mobimem) {
+    this.config = { ...DEFAULT_ROUTING_MEMORY_CONFIG, ...config };
+    this.logger = this.config.logger ?? createLogger({ component: "RoutingMemory" });
+    this.mobimem = mobimem ?? new MobiMem();
+    this.logger.info("RoutingMemory initialized", {
+      minObservations: this.config.minObservations,
+      confidenceThreshold: this.config.confidenceThreshold
+    });
+  }
+  storePreference(model, taskType, performance2) {
+    const preferenceKey = `model_preference:${taskType}`;
+    const entityId = `routing:${model}`;
+    const entry = this.mobimem.profile.observe(entityId, "agent", preferenceKey, {
+      model,
+      performance: performance2,
+      updatedAt: getTimeProvider().nowIso()
+    });
+    this.logger.debug("Stored model preference", {
+      model,
+      taskType,
+      confidence: entry.confidence,
+      observations: entry.observationCount
+    });
+  }
+  getPreferences(taskType) {
+    const preferenceKey = `model_preference:${taskType}`;
+    const preferences = [];
+    for (const model of CLI_NAMES) {
+      const entityId = `routing:${model}`;
+      const entry = this.mobimem.profile.getPreference(entityId, preferenceKey);
+      if (entry !== null && entry.observationCount >= this.config.minObservations) {
+        const value = entry.preferenceValue;
+        preferences.push({
+          model: value.model,
+          strength: this.calculateStrength(value.performance),
+          performance: value.performance,
+          confidence: entry.confidence
+        });
+      }
+    }
+    return preferences.sort((a, b) => b.strength - a.strength);
+  }
+  recordExperience(workflow, models, success, metrics2) {
+    const contextSignature = models.join("->");
+    const actionSequence = models.map((model, index) => ({
+      index,
+      actionType: "model_route",
+      parameters: { model },
+      durationMs: Math.floor(metrics2.durationMs / models.length),
+      success
+    }));
+    const outcome = metrics2.qualityScore !== void 0 ? {
+      success,
+      qualityScore: metrics2.qualityScore,
+      totalDurationMs: metrics2.durationMs,
+      tokensUsed: metrics2.tokensUsed
+    } : {
+      success,
+      totalDurationMs: metrics2.durationMs,
+      tokensUsed: metrics2.tokensUsed
+    };
+    this.mobimem.experience.recordExecution(workflow, actionSequence, outcome, contextSignature);
+    this.logger.debug("Recorded routing experience", {
+      workflow,
+      models: models.join("->"),
+      success,
+      durationMs: metrics2.durationMs
+    });
+  }
+  getExperiencePatterns(workflow) {
+    const experiences = this.mobimem.experience.findPatterns(workflow);
+    return experiences.filter((exp) => exp.successRate >= this.config.successRateThreshold).map((exp) => this.mapExperienceToPattern(exp));
+  }
+  cacheAction(action, model, result, durationMs2) {
+    const input = { actionSignature: action, model };
+    this.mobimem.action.cache(input, result, durationMs2);
+    this.logger.debug("Cached action result", { action: action.slice(0, 50), model, durationMs: durationMs2 });
+  }
+  getCachedAction(action) {
+    for (const model of CLI_NAMES) {
+      const input = { actionSignature: action, model };
+      const entry = this.mobimem.action.get(input);
+      if (entry !== null) {
+        this.cacheHits++;
+        const inputData = entry.input;
+        return {
+          action,
+          result: entry.result,
+          model: inputData.model,
+          cachedAt: entry.cachedAt,
+          timeSavedMs: entry.timeSavedMs
+        };
+      }
+    }
+    this.cacheMisses++;
+    return void 0;
+  }
+  getRecommendation(taskType) {
+    const preferences = this.getPreferences(taskType);
+    const top = preferences[0];
+    if (top !== void 0 && top.confidence >= this.config.confidenceThreshold) {
+      this.recommendationsMade++;
+      this.logger.debug("Generated routing recommendation", {
+        taskType,
+        recommended: top.model,
+        confidence: top.confidence,
+        strength: top.strength
+      });
+      return top.model;
+    }
+    return void 0;
+  }
+  getStats() {
+    const mobiStats = this.mobimem.getStats();
+    return {
+      totalPreferences: mobiStats.profile.totalEntries,
+      totalExperiences: mobiStats.experience.totalPatterns,
+      cacheHits: this.cacheHits,
+      cacheMisses: this.cacheMisses,
+      recommendationsMade: this.recommendationsMade
+    };
+  }
+  // ========================================================================
+  // Private Helpers
+  // ========================================================================
+  /**
+   * Calculate preference strength from performance metrics.
+   */
+  calculateStrength(performance2) {
+    const qualityWeight = 0.4;
+    const successWeight = 0.3;
+    const speedWeight = 0.2;
+    const efficiencyWeight = 0.1;
+    const normalizedLatency = 1 - Math.min(performance2.avgLatencyMs / 1e4, 1);
+    const normalizedTokens = 1 - Math.min(performance2.avgTokens / 1e5, 1);
+    return performance2.avgQuality * qualityWeight + performance2.successRate * successWeight + normalizedLatency * speedWeight + normalizedTokens * efficiencyWeight;
+  }
+  /**
+   * Map MobiMem experience entry to routing pattern.
+   */
+  mapExperienceToPattern(exp) {
+    const models = exp.actionSequence.filter((step) => step.actionType === "model_route").map((step) => step.parameters.model);
+    const avgDuration = exp.outcome.totalDurationMs;
+    return {
+      workflow: exp.taskType,
+      modelSequence: models,
+      successRate: exp.successRate,
+      avgDurationMs: avgDuration,
+      usageCount: exp.attemptCount
+    };
+  }
+};
+function createRoutingMemory(config, mobimem) {
+  return new RoutingMemory(config, mobimem);
+}
+
 // src/cli-adapters/routing/router-stage.ts
-import { z as z7 } from "zod";
-var StageConfigSchema = z7.object({
-  enabled: z7.boolean().default(true),
-  priority: z7.number().int().min(0).max(100).default(50),
-  options: z7.record(z7.string(), z7.unknown()).optional()
+import { z as z8 } from "zod";
+var StageConfigSchema = z8.object({
+  enabled: z8.boolean().default(true),
+  priority: z8.number().int().min(0).max(100).default(50),
+  options: z8.record(z8.string(), z8.unknown()).optional()
 });
-var RoutingOutcomeSchema = z7.object({
+var RoutingOutcomeSchema = z8.object({
   selectedCli: CliNameSchema,
-  task: z7.string(),
-  success: z7.boolean(),
-  qualityScore: z7.number().min(0).max(1).optional(),
-  latencyMs: z7.number().int().positive().optional(),
-  tokensUsed: z7.number().int().positive().optional()
+  task: z8.string(),
+  success: z8.boolean(),
+  qualityScore: z8.number().min(0).max(1).optional(),
+  latencyMs: z8.number().int().positive().optional(),
+  tokensUsed: z8.number().int().positive().optional()
 });
 function createRoutingContext(task, availableClis = ["claude", "gemini", "codex", "opencode"], metadata) {
   return {
@@ -5326,7 +5525,7 @@ var ConfidenceCascadeStage = class {
 };
 
 // src/config/task-specialization-types.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -5339,8 +5538,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z8.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z8.object({
+var TaskCategorySchema = z9.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z9.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -5348,11 +5547,11 @@ var TaskSpecializationSchema = z8.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z8.string(),
+  reasoning: z9.string(),
   /** Keywords that trigger this category detection */
-  keywords: z8.array(z8.string()).min(1),
+  keywords: z9.array(z9.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z8.number().min(0).max(20)
+  bonus: z9.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -5465,7 +5664,7 @@ var TASK_SPECIALIZATION_MATRIX = [
       "dast",
       "zap",
       "semgrep",
-      "trivy",
+      "grype",
       "fork",
       "kind",
       "cluster",
@@ -6575,10 +6774,10 @@ function createPersistentDistillerOrFallback(outcomeStore, logger9) {
 }
 
 // src/orchestration/outcomes/outcome-types.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var logger5 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z9.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z9.enum([
+var OutcomeSourceSchema = z10.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z10.enum([
   "timeout",
   "authentication",
   "rate_limit",
@@ -6591,33 +6790,37 @@ var OutcomeFailureCategorySchema = z9.enum([
   "generic",
   "unknown"
 ]);
-var TaskOutcomeSchema = z9.object({
-  id: z9.string().min(1),
+var TaskOutcomeSchema = z10.object({
+  id: z10.string().min(1),
   cli: CliNameSchema,
   category: TaskCategorySchema,
-  model: z9.string().min(1),
-  success: z9.boolean(),
-  durationMs: z9.number().nonnegative(),
-  timestamp: z9.string().min(1),
-  qualitySignals: z9.array(z9.string()).optional(),
+  model: z10.string().min(1),
+  success: z10.boolean(),
+  durationMs: z10.number().nonnegative(),
+  timestamp: z10.string().min(1),
+  qualitySignals: z10.array(z10.string()).optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  errorMessage: z9.string().max(500).optional(),
+  errorMessage: z10.string().max(500).optional(),
   source: OutcomeSourceSchema,
   /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z9.boolean().optional(),
+  wasRetried: z10.boolean().optional(),
   /** Triage action taken on the failure (#1506). */
-  triageAction: z9.string().max(30).optional()
+  triageAction: z10.string().max(30).optional(),
+  /** Routing stage that selected this CLI (#1785). */
+  routingStage: z10.string().max(50).optional(),
+  /** Number of retry attempts before this outcome (#1785). */
+  retryCount: z10.number().int().nonnegative().optional()
 });
-var OutcomeQuerySchema = z9.object({
+var OutcomeQuerySchema = z10.object({
   cli: CliNameSchema.optional(),
   category: TaskCategorySchema.optional(),
   source: OutcomeSourceSchema.optional(),
-  success: z9.boolean().optional(),
+  success: z10.boolean().optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  since: z9.string().optional(),
-  limit: z9.number().int().positive().optional(),
+  since: z10.string().optional(),
+  limit: z10.number().int().positive().optional(),
   /** Exclude outcomes with any of these quality signals (#1680). */
-  excludeQualitySignals: z9.array(z9.string()).optional()
+  excludeQualitySignals: z10.array(z10.string()).optional()
 });
 var TIMEOUT_PATTERNS = ["timeout", "timed out", "deadline exceeded", "socket hang up", "aborted"];
 var AUTH_PATTERNS = [
@@ -7182,52 +7385,52 @@ function runWarmUp(logger9) {
 }
 
 // src/cli-adapters/composite-router-types.ts
-import { z as z10 } from "zod";
-var CompositeRouterConfigSchema = z10.object({
+import { z as z11 } from "zod";
+var CompositeRouterConfigSchema = z11.object({
   /** Enable confidence cascade stage (default: false) (Issue #755, ADR-0005) */
-  enableConfidenceCascade: z10.boolean().default(false),
+  enableConfidenceCascade: z11.boolean().default(false),
   /** Enable budget filtering stage (default: true) */
-  enableBudgetFilter: z10.boolean().default(true),
+  enableBudgetFilter: z11.boolean().default(true),
   /** Enable capability match stage (default: false) (Issue #755, ADR-0005) */
-  enableCapabilityMatch: z10.boolean().default(false),
+  enableCapabilityMatch: z11.boolean().default(false),
   /** Enable ZeroRouter difficulty-based routing stage (default: true) (Issue #473) */
-  enableZeroRouter: z10.boolean().default(true),
+  enableZeroRouter: z11.boolean().default(true),
   /** Enable preference-trained routing stage (default: false) */
-  enablePreferenceRouting: z10.boolean().default(false),
+  enablePreferenceRouting: z11.boolean().default(false),
   /** Enable TOPSIS ranking stage (default: true) */
-  enableTopsisRanking: z10.boolean().default(true),
+  enableTopsisRanking: z11.boolean().default(true),
   /** Enable LinUCB selection stage (default: true) */
-  enableLinUCBSelection: z10.boolean().default(true),
+  enableLinUCBSelection: z11.boolean().default(true),
   /** Enable quality constraint stage (default: false) (Issue #755, ADR-0005) */
-  enableQualityConstraint: z10.boolean().default(false),
+  enableQualityConstraint: z11.boolean().default(false),
   /** Enable resource strategy stage for budget-aware oscillation (default: true) (Issue #998) */
-  enableResourceStrategy: z10.boolean().default(true),
+  enableResourceStrategy: z11.boolean().default(true),
   /** Enable strategy distillation for learned routing rules (default: false) (Issue #999) */
-  enableStrategyDistillation: z10.boolean().default(false),
+  enableStrategyDistillation: z11.boolean().default(false),
   /** Enable latency tracking for routing decisions (default: true) (Issue #361) */
-  enableLatencyTracking: z10.boolean().default(true),
+  enableLatencyTracking: z11.boolean().default(true),
   /** Enable routing memory for learned routing (default: false) (Issue #463, #461) */
-  enableRoutingMemory: z10.boolean().default(false),
+  enableRoutingMemory: z11.boolean().default(false),
   /** Enable KNN experience-based routing (default: false) (arXiv:2507.05370) */
-  enableKnnRouting: z10.boolean().default(false),
+  enableKnnRouting: z11.boolean().default(false),
   /** Weight for latency score in final routing (0-1, default: 0.2) */
-  latencyScoreWeight: z10.number().min(0).max(1).default(0.2),
+  latencyScoreWeight: z11.number().min(0).max(1).default(0.2),
   /** Budget constraints (optional) */
-  budgetConstraints: z10.object({
-    maxTokens: z10.number().positive(),
-    maxCostUsd: z10.number().positive(),
-    maxLatencyMs: z10.number().positive()
+  budgetConstraints: z11.object({
+    maxTokens: z11.number().positive(),
+    maxCostUsd: z11.number().positive(),
+    maxLatencyMs: z11.number().positive()
   }).partial().optional(),
   /** LinUCB exploration parameter (default: 1.0) */
-  linucbAlpha: z10.number().positive().default(1),
+  linucbAlpha: z11.number().positive().default(1),
   /** Billing mode: 'plan' zeroes cost weight, 'api' preserves current behavior (default: 'plan') */
-  billingMode: z10.enum(["plan", "api"]).default("plan"),
+  billingMode: z11.enum(["plan", "api"]).default("plan"),
   /** Enable capacity-aware load balancing (deprioritize exhausted CLIs) (default: true) (Issue #807) */
-  enableCapacityBalancing: z10.boolean().default(true),
+  enableCapacityBalancing: z11.boolean().default(true),
   /** Maximum routing decision time in ms (default: 50) */
-  maxDecisionTimeMs: z10.number().positive().default(50),
+  maxDecisionTimeMs: z11.number().positive().default(50),
   /** Minimum preference data points before using learned routing (default: 10) */
-  preferenceMinDataPoints: z10.number().int().positive().default(10)
+  preferenceMinDataPoints: z11.number().int().positive().default(10)
 });
 var DEFAULT_COMPOSITE_CONFIG = {
   enableConfidenceCascade: false,
@@ -7511,12 +7714,12 @@ async function fetchCapacityData(adapters) {
 }
 
 // src/mcp/tools/weather-report-types.ts
-import { z as z11 } from "zod";
-var WeatherReportInputSchema = z11.object({
+import { z as z12 } from "zod";
+var WeatherReportInputSchema = z12.object({
   /** Filter by CLI name. */
-  cli: z11.enum(CLI_NAMES).optional().describe("Filter by CLI"),
+  cli: z12.enum(CLI_NAMES).optional().describe("Filter by CLI"),
   /** Filter by task category. */
-  category: z11.enum([
+  category: z12.enum([
     "architecture",
     "code_generation",
     "code_review",
@@ -7529,22 +7732,22 @@ var WeatherReportInputSchema = z11.object({
     "exploration"
   ]).optional().describe("Filter by task category"),
   /** Include adaptive routing bonus data. */
-  includeAdaptive: z11.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
+  includeAdaptive: z12.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
 });
 var DEFAULT_OUTCOME_LOOKBACK_MS = 7 * 24 * 60 * 60 * 1e3;
-var WeatherReportConfigSchema = z11.object({
+var WeatherReportConfigSchema = z12.object({
   /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z11.number().int().min(1).max(1e3).default(3),
+  coldStartThreshold: z12.number().int().min(1).max(1e3).default(3),
   /** Exploration rate: fraction of random routing (0.0-1.0). */
-  explorationRate: z11.number().min(0).max(1).default(0.1),
+  explorationRate: z12.number().min(0).max(1).default(0.1),
   /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z11.number().min(0).max(20).default(10),
+  maxBonusAdjustment: z12.number().min(0).max(20).default(10),
   /**
    * Lookback window for outcome queries (ms). Only outcomes within this
    * window are used for adaptive bonuses. Falls back to all history if
    * the window has fewer samples than coldStartThreshold. Default: 7 days.
    */
-  outcomeLookbackMs: z11.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
+  outcomeLookbackMs: z12.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
 });
 function createDefaultWeatherConfig() {
   return WeatherReportConfigSchema.parse({});
@@ -7929,47 +8132,47 @@ function createMetricsMiddleware() {
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/config/defaults-types.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function isKnownCliName(cli) {
   return cli === "claude" || cli === "gemini" || cli === "codex" || cli === "opencode" || cli === "default";
 }
-var positiveInt = z12.number().int().positive();
-var nonNegativeInt = z12.number().int().nonnegative();
-var durationMs = z12.number().int().positive().describe("Duration in milliseconds");
-var TimeoutProfileSchema = z12.object({
+var positiveInt = z13.number().int().positive();
+var nonNegativeInt = z13.number().int().nonnegative();
+var durationMs = z13.number().int().positive().describe("Duration in milliseconds");
+var TimeoutProfileSchema = z13.object({
   simple: durationMs.describe("Timeout for simple tasks"),
   standard: durationMs.describe("Timeout for standard tasks"),
   complex: durationMs.describe("Timeout for complex tasks")
 });
-var RetryDefaultsSchema = z12.object({
+var RetryDefaultsSchema = z13.object({
   maxRetries: nonNegativeInt.max(10).describe("Maximum retry attempts"),
   baseDelayMs: durationMs.describe("Base delay between retries"),
   maxDelayMs: durationMs.describe("Maximum delay between retries"),
-  jitterFactor: z12.number().min(0).max(1).describe("Jitter factor (0-1)")
+  jitterFactor: z13.number().min(0).max(1).describe("Jitter factor (0-1)")
 });
-var RateLimitDefaultsSchema = z12.object({
+var RateLimitDefaultsSchema = z13.object({
   requestsPerMinute: positiveInt.max(1e3).describe("Max requests per minute"),
-  enabled: z12.boolean().describe("Whether rate limiting is enabled"),
+  enabled: z13.boolean().describe("Whether rate limiting is enabled"),
   maxConcurrent: positiveInt.max(100).describe("Max concurrent requests"),
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var CircuitBreakerDefaultsSchema = z12.object({
-  failureThreshold: z12.number().int().min(1).max(100).describe("Failures before opening"),
+var CircuitBreakerDefaultsSchema = z13.object({
+  failureThreshold: z13.number().int().min(1).max(100).describe("Failures before opening"),
   resetTimeoutMs: durationMs.describe("Time before attempting reset"),
-  halfOpenSuccessThreshold: z12.number().int().min(1).max(10).describe("Successes to close"),
-  countTimeoutsAsFailures: z12.boolean().describe("Count timeouts as failures"),
-  countAuthFailuresAsFailures: z12.boolean().describe("Count auth failures as failures"),
-  countRateLimitsAsFailures: z12.boolean().describe("Count rate limit errors as failures"),
+  halfOpenSuccessThreshold: z13.number().int().min(1).max(10).describe("Successes to close"),
+  countTimeoutsAsFailures: z13.boolean().describe("Count timeouts as failures"),
+  countAuthFailuresAsFailures: z13.boolean().describe("Count auth failures as failures"),
+  countRateLimitsAsFailures: z13.boolean().describe("Count rate limit errors as failures"),
   halfOpenMaxRequests: positiveInt.describe("Max requests in half-open state")
 });
-var ToolRateLimitConfigSchema = z12.object({
+var ToolRateLimitConfigSchema = z13.object({
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var WorkerDefaultsSchema = z12.object({
+var WorkerDefaultsSchema = z13.object({
   maxWorkers: positiveInt.max(32).describe("Maximum worker threads"),
   poolSize: positiveInt.max(32).describe("Worker pool size"),
   idleTimeoutMs: durationMs.describe("Worker idle timeout"),
@@ -7979,7 +8182,7 @@ var WorkerDefaultsSchema = z12.object({
   eventBusMaxHistory: nonNegativeInt.max(1e4).describe("Event bus history limit"),
   swarmObserverMaxEvents: nonNegativeInt.max(1e4).describe("Swarm observer event limit")
 });
-var TimeoutDefaultsSchema = z12.object({
+var TimeoutDefaultsSchema = z13.object({
   cliMs: durationMs.describe("Default CLI timeout"),
   cliSimpleMs: durationMs.describe("Simple CLI task timeout"),
   cliComplexMs: durationMs.describe("Complex CLI task timeout"),
@@ -9224,6 +9427,17 @@ async function applyQualityConstraints(candidates, stagesExecuted, deps) {
   }
   return ok({ candidates: qualityResult.eligible, qualityResult });
 }
+function applyLinUCBFloorOverride(linucbCli, topsisRanking, opts) {
+  if (opts.perfData === void 0) return linucbCli;
+  const cliPerf = opts.perfData.get(linucbCli);
+  if (cliPerf === void 0 || cliPerf.sampleCount < 20 || cliPerf.successRate >= 0.5) {
+    return linucbCli;
+  }
+  const topsisTop = topsisRanking[0];
+  if (topsisTop === void 0 || topsisTop === linucbCli) return linucbCli;
+  opts.stagesExecuted.push("perf-floor-override");
+  return topsisTop;
+}
 async function runPipeline(task, taskProfile, stagesExecuted, cliNames, deps) {
   let candidates = [...cliNames];
   if (candidates.length === 0) {
@@ -9248,12 +9462,17 @@ async function runPipeline(task, taskProfile, stagesExecuted, cliNames, deps) {
   if (linucbResult.selectedCli === void 0) {
     return err(new CompositeRoutingError("No candidates available", "selection"));
   }
-  const latencyResult = runLatencyStage(candidates, stagesExecuted, deps);
-  const selectedCli = selectWithMemoryInfluence(
+  const effectiveSelection = applyLinUCBFloorOverride(
     linucbResult.selectedCli,
-    scoring.memoryResult,
-    deps
+    topsisResult.ranking,
+    {
+      perfData: topsisOpts.performanceData,
+      taskType: taskProfile.taskType,
+      stagesExecuted
+    }
   );
+  const latencyResult = runLatencyStage(candidates, stagesExecuted, deps);
+  const selectedCli = selectWithMemoryInfluence(effectiveSelection, scoring.memoryResult, deps);
   return ok(
     buildPipelineResult({
       ...scoring,
@@ -9985,33 +10204,6 @@ var OrchestratorError = class extends Error {
   }
 };
 
-// src/context/mobimem-types.ts
-import { z as z13 } from "zod";
-var DEFAULT_MOBIMEM_CONFIG = {
-  dbPath: ":memory:",
-  maxProfileEntries: 100,
-  maxExperiencePatterns: 500,
-  maxActionCacheEntries: 1e3,
-  actionCacheTtlMs: 36e5,
-  // 1 hour
-  minProfileConfidence: 0.6,
-  minExperienceSuccessRate: 0.7,
-  autoEviction: true
-};
-var MobiMemConfigSchema = z13.object({
-  dbPath: z13.string(),
-  maxProfileEntries: z13.number().int().positive().default(100),
-  maxExperiencePatterns: z13.number().int().positive().default(500),
-  maxActionCacheEntries: z13.number().int().positive().default(1e3),
-  actionCacheTtlMs: z13.number().int().positive().default(36e5),
-  minProfileConfidence: z13.number().min(0).max(1).default(0.6),
-  minExperienceSuccessRate: z13.number().min(0).max(1).default(0.7),
-  autoEviction: z13.boolean().default(true)
-});
-
-// src/context/mobimem-impl.ts
-import { randomUUID as randomUUID4 } from "crypto";
-
 // src/context/mobimem-impl-helpers.ts
 import { createHash as createHash2 } from "crypto";
 function calculateConfidence2(observationCount) {
@@ -10401,178 +10593,29 @@ var MobiMem = class {
   close() {
     logger8.info("MobiMem closed");
   }
-};
-
-// src/context/routing-memory.ts
-var DEFAULT_ROUTING_MEMORY_CONFIG = {
-  minObservations: 5,
-  confidenceThreshold: 0.6,
-  successRateThreshold: 0.7,
-  actionCacheMaxAgeMs: 36e5
-  // 1 hour
-};
-var RoutingMemory = class {
-  mobimem;
-  config;
-  logger;
-  // Statistics
-  cacheHits = 0;
-  cacheMisses = 0;
-  recommendationsMade = 0;
-  constructor(config, mobimem) {
-    this.config = { ...DEFAULT_ROUTING_MEMORY_CONFIG, ...config };
-    this.logger = this.config.logger ?? createLogger({ component: "RoutingMemory" });
-    this.mobimem = mobimem ?? new MobiMem();
-    this.logger.info("RoutingMemory initialized", {
-      minObservations: this.config.minObservations,
-      confidenceThreshold: this.config.confidenceThreshold
-    });
-  }
-  storePreference(model, taskType, performance2) {
-    const preferenceKey = `model_preference:${taskType}`;
-    const entityId = `routing:${model}`;
-    const entry = this.mobimem.profile.observe(entityId, "agent", preferenceKey, {
-      model,
-      performance: performance2,
-      updatedAt: getTimeProvider().nowIso()
-    });
-    this.logger.debug("Stored model preference", {
-      model,
-      taskType,
-      confidence: entry.confidence,
-      observations: entry.observationCount
-    });
-  }
-  getPreferences(taskType) {
-    const preferenceKey = `model_preference:${taskType}`;
-    const preferences = [];
-    for (const model of CLI_NAMES) {
-      const entityId = `routing:${model}`;
-      const entry = this.mobimem.profile.getPreference(entityId, preferenceKey);
-      if (entry !== null && entry.observationCount >= this.config.minObservations) {
-        const value = entry.preferenceValue;
-        preferences.push({
-          model: value.model,
-          strength: this.calculateStrength(value.performance),
-          performance: value.performance,
-          confidence: entry.confidence
-        });
-      }
-    }
-    return preferences.sort((a, b) => b.strength - a.strength);
-  }
-  recordExperience(workflow, models, success, metrics2) {
-    const contextSignature = models.join("->");
-    const actionSequence = models.map((model, index) => ({
-      index,
-      actionType: "model_route",
-      parameters: { model },
-      durationMs: Math.floor(metrics2.durationMs / models.length),
-      success
-    }));
-    const outcome = metrics2.qualityScore !== void 0 ? {
-      success,
-      qualityScore: metrics2.qualityScore,
-      totalDurationMs: metrics2.durationMs,
-      tokensUsed: metrics2.tokensUsed
-    } : {
-      success,
-      totalDurationMs: metrics2.durationMs,
-      tokensUsed: metrics2.tokensUsed
-    };
-    this.mobimem.experience.recordExecution(workflow, actionSequence, outcome, contextSignature);
-    this.logger.debug("Recorded routing experience", {
-      workflow,
-      models: models.join("->"),
-      success,
-      durationMs: metrics2.durationMs
-    });
-  }
-  getExperiencePatterns(workflow) {
-    const experiences = this.mobimem.experience.findPatterns(workflow);
-    return experiences.filter((exp) => exp.successRate >= this.config.successRateThreshold).map((exp) => this.mapExperienceToPattern(exp));
-  }
-  cacheAction(action, model, result, durationMs2) {
-    const input = { actionSignature: action, model };
-    this.mobimem.action.cache(input, result, durationMs2);
-    this.logger.debug("Cached action result", { action: action.slice(0, 50), model, durationMs: durationMs2 });
-  }
-  getCachedAction(action) {
-    for (const model of CLI_NAMES) {
-      const input = { actionSignature: action, model };
-      const entry = this.mobimem.action.get(input);
-      if (entry !== null) {
-        this.cacheHits++;
-        const inputData = entry.input;
-        return {
-          action,
-          result: entry.result,
-          model: inputData.model,
-          cachedAt: entry.cachedAt,
-          timeSavedMs: entry.timeSavedMs
-        };
-      }
-    }
-    this.cacheMisses++;
-    return void 0;
-  }
-  getRecommendation(taskType) {
-    const preferences = this.getPreferences(taskType);
-    const top = preferences[0];
-    if (top !== void 0 && top.confidence >= this.config.confidenceThreshold) {
-      this.recommendationsMade++;
-      this.logger.debug("Generated routing recommendation", {
-        taskType,
-        recommended: top.model,
-        confidence: top.confidence,
-        strength: top.strength
-      });
-      return top.model;
-    }
-    return void 0;
-  }
-  getStats() {
-    const mobiStats = this.mobimem.getStats();
+  /** Export MobiMem state for disk persistence (#1782). */
+  exportData() {
     return {
-      totalPreferences: mobiStats.profile.totalEntries,
-      totalExperiences: mobiStats.experience.totalPatterns,
-      cacheHits: this.cacheHits,
-      cacheMisses: this.cacheMisses,
-      recommendationsMade: this.recommendationsMade
+      stats: this.getStats(),
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  // ========================================================================
-  // Private Helpers
-  // ========================================================================
-  /**
-   * Calculate preference strength from performance metrics.
-   */
-  calculateStrength(performance2) {
-    const qualityWeight = 0.4;
-    const successWeight = 0.3;
-    const speedWeight = 0.2;
-    const efficiencyWeight = 0.1;
-    const normalizedLatency = 1 - Math.min(performance2.avgLatencyMs / 1e4, 1);
-    const normalizedTokens = 1 - Math.min(performance2.avgTokens / 1e5, 1);
-    return performance2.avgQuality * qualityWeight + performance2.successRate * successWeight + normalizedLatency * speedWeight + normalizedTokens * efficiencyWeight;
-  }
-  /**
-   * Map MobiMem experience entry to routing pattern.
-   */
-  mapExperienceToPattern(exp) {
-    const models = exp.actionSequence.filter((step) => step.actionType === "model_route").map((step) => step.parameters.model);
-    const avgDuration = exp.outcome.totalDurationMs;
-    return {
-      workflow: exp.taskType,
-      modelSequence: models,
-      successRate: exp.successRate,
-      avgDurationMs: avgDuration,
-      usageCount: exp.attemptCount
-    };
+  /** Save MobiMem state to disk (#1782). */
+  async save(filePath) {
+    try {
+      const fs2 = await import("fs/promises");
+      const path2 = await import("path");
+      await fs2.mkdir(path2.dirname(filePath), { recursive: true });
+      const data = JSON.stringify(this.exportData(), null, 2);
+      await fs2.writeFile(filePath, data, "utf-8");
+      logger8.debug("MobiMem state saved", { path: filePath });
+    } catch (error) {
+      logger8.warn("Failed to save MobiMem state", { error: String(error) });
+    }
   }
 };
-function createRoutingMemory(config, mobimem) {
-  return new RoutingMemory(config, mobimem);
+function createMobiMem(config) {
+  return new MobiMem(config);
 }
 
 export {
@@ -10659,7 +10702,9 @@ export {
   PreferenceRouter,
   createPreferenceRouter,
   DEFAULT_ZERO_ROUTER_CONFIG,
+  DEFAULT_MOBIMEM_CONFIG,
   MobiMem,
+  createMobiMem,
   DEFAULT_ROUTING_MEMORY_CONFIG,
   RoutingMemory,
   createRoutingMemory,
@@ -10738,4 +10783,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-IMWYKX4H.js.map
+//# sourceMappingURL=chunk-HSOPD265.js.map