nexus-agents 2.77.12 → 2.78.0

package/dist/{chunk-3MRM53T4.js → chunk-WDYCIJWN.js}

@@ -1,9 +1,7 @@
 import {
-  isPersistenceEnabled
-} from "./chunk-I7ORMAO7.js";
-import {
+  isPersistenceEnabled,
   nexusDataPath
-} from "./chunk-GOT7OAL5.js";
+} from "./chunk-7BMOZJYS.js";
 import {
   __require
 } from "./chunk-UP2VWCW5.js";
@@ -280,33 +278,6 @@ 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 };
@@ -1464,10 +1435,10 @@ function buildInTreeEntries() {
 // src/config/manifest-overlay.ts
 import { existsSync, readFileSync, statSync } from "fs";
 import { parse as parseYaml } from "yaml";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // src/config/model-capabilities-types.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 var OUTPUT_MODALITIES = [
   "text",
   "image_png",
@@ -1504,7 +1475,7 @@ var SPECIAL_FEATURES = [
 ];
 var PROVIDERS = ["anthropic", "google", "openai", "custom-openai", "openrouter"];
 var CLI_NAMES = ["claude", "gemini", "codex", "opencode"];
-var CliNameSchema = z2.enum(CLI_NAMES);
+var CliNameSchema = z.enum(CLI_NAMES);
 var DEFAULT_CLI = "claude";
 var MODEL_IDS = [
   "claude-opus",
@@ -1523,49 +1494,49 @@ var MODEL_IDS = [
   "openrouter-nemotron-super",
   "openrouter-qwen-coder"
 ];
-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 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 PricingSchema = z2.object({
-  inputPer1M: z2.number().nonnegative(),
-  outputPer1M: z2.number().nonnegative()
+var PricingSchema = z.object({
+  inputPer1M: z.number().nonnegative(),
+  outputPer1M: z.number().nonnegative()
 });
-var ModelCapabilitySchema = z2.object({
+var ModelCapabilitySchema = z.object({
   /** Unique model identifier matching delegate_to_model model IDs */
-  id: z2.enum(MODEL_IDS),
+  id: z.enum(MODEL_IDS),
   /** Human-readable display name */
-  displayName: z2.string().min(1),
+  displayName: z.string().min(1),
   /** Provider/vendor */
-  provider: z2.enum(PROVIDERS),
+  provider: z.enum(PROVIDERS),
   /** Maximum context window in tokens */
-  contextWindow: z2.number().int().positive(),
+  contextWindow: z.number().int().positive(),
   /** Output modalities this model can produce */
-  outputModalities: z2.array(z2.enum(OUTPUT_MODALITIES)).min(1),
+  outputModalities: z.array(z.enum(OUTPUT_MODALITIES)).min(1),
   /** Input modalities this model can accept */
-  inputModalities: z2.array(z2.enum(INPUT_MODALITIES)).min(1),
+  inputModalities: z.array(z.enum(INPUT_MODALITIES)).min(1),
   /** Tool/integration capabilities */
-  toolCapabilities: z2.array(z2.enum(TOOL_CAPABILITIES)),
+  toolCapabilities: z.array(z.enum(TOOL_CAPABILITIES)),
   /** Special features beyond standard generation */
-  specialFeatures: z2.array(z2.enum(SPECIAL_FEATURES)),
+  specialFeatures: z.array(z.enum(SPECIAL_FEATURES)),
   /** Known constraints or limitations */
-  constraints: z2.array(z2.string()).optional(),
+  constraints: z.array(z.string()).optional(),
   /** Notes about the model (e.g., beta features, pricing tier) */
-  notes: z2.string().optional(),
+  notes: z.string().optional(),
   /** Pricing per 1M tokens (USD) */
   pricing: PricingSchema.optional(),
   /** Quality scores for routing (0-10 scale) */
   qualityScores: QualityScoresSchema.optional(),
   /** Maximum output tokens */
-  maxOutputTokens: z2.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
   /** Which CLI tool this model belongs to */
-  cliName: z2.enum(CLI_NAMES).optional(),
+  cliName: z.enum(CLI_NAMES).optional(),
   /** Short alias used by the CLI (e.g., 'opus' for Claude CLI) */
-  cliAlias: z2.string().optional(),
+  cliAlias: z.string().optional(),
   /** Model name the CLI binary expects (e.g., 'gemini-2.5-pro') */
-  cliModelName: z2.string().optional(),
+  cliModelName: z.string().optional(),
   /**
    * Legacy / version-suffixed names that resolve to this model. Used by
    * adapters and routing to map historical user-facing names (e.g.,
@@ -1576,21 +1547,21 @@ var ModelCapabilitySchema = z2.object({
    * Added for issue #2199 Child 1; populated by the companion migration
    * epic #2200.
    */
-  aliases: z2.array(z2.string().min(1)).optional(),
+  aliases: z.array(z.string().min(1)).optional(),
   /** Whether this model is deprecated and should receive a scoring penalty */
-  deprecated: z2.boolean().optional(),
+  deprecated: z.boolean().optional(),
   /** ISO date when the model was deprecated (informational) */
-  deprecatedAt: z2.string().optional(),
+  deprecatedAt: z.string().optional(),
   /** Model ID to migrate to (informational guidance) */
-  replacedBy: z2.enum(MODEL_IDS).optional()
+  replacedBy: z.enum(MODEL_IDS).optional()
 });
-var ModelCapabilitiesMatrixSchema = z2.object({
+var ModelCapabilitiesMatrixSchema = z.object({
   /** Schema version for forward compatibility */
-  version: z2.number().int().positive(),
+  version: z.number().int().positive(),
   /** Last updated date (ISO 8601) */
-  updatedAt: z2.string(),
+  updatedAt: z.string(),
   /** Model capability definitions */
-  models: z2.array(ModelCapabilitySchema).min(1)
+  models: z.array(ModelCapabilitySchema).min(1)
 });
 
 // src/config/manifest-overlay.ts
@@ -1604,7 +1575,7 @@ function resolveManifestPath(env = process.env) {
   if (override !== void 0 && override !== "") return override;
   return defaultManifestPath();
 }
-var ModelVendorSchema = z3.enum([
+var ModelVendorSchema = z2.enum([
   "anthropic",
   "openai",
   "google",
@@ -1616,49 +1587,49 @@ var ModelVendorSchema = z3.enum([
   "deepseek",
   "unknown"
 ]);
-var ToolDefinitionFormatSchema = z3.enum([
+var ToolDefinitionFormatSchema = z2.enum([
   "openai",
   "anthropic",
   "gemini"
 ]);
-var PromptCachingModeSchema = z3.enum([
+var PromptCachingModeSchema = z2.enum([
   "none",
   "ephemeral",
   "aggressive"
 ]);
-var ManifestEntrySchema = z3.object({
+var ManifestEntrySchema = z2.object({
   // Identity (required)
-  id: z3.string().min(1).max(200),
+  id: z2.string().min(1).max(200),
   vendor: ModelVendorSchema,
-  family: z3.string().min(1).max(80),
+  family: z2.string().min(1).max(80),
   // Identity (optional)
-  aliases: z3.array(z3.string().min(1).max(200)).max(20).optional(),
-  version: z3.string().min(1).max(50).optional(),
-  displayName: z3.string().min(1).max(200).optional(),
+  aliases: z2.array(z2.string().min(1).max(200)).max(20).optional(),
+  version: z2.string().min(1).max(50).optional(),
+  displayName: z2.string().min(1).max(200).optional(),
   // Capabilities (all optional)
-  contextWindow: z3.number().int().positive().max(2e7).optional(),
-  maxOutputTokens: z3.number().int().positive().max(2e7).optional(),
-  inputModalities: z3.array(z3.enum(INPUT_MODALITIES)).optional(),
-  outputModalities: z3.array(z3.enum(OUTPUT_MODALITIES)).optional(),
-  toolCapabilities: z3.array(z3.enum(TOOL_CAPABILITIES)).optional(),
-  specialFeatures: z3.array(z3.enum(SPECIAL_FEATURES)).optional(),
+  contextWindow: z2.number().int().positive().max(2e7).optional(),
+  maxOutputTokens: z2.number().int().positive().max(2e7).optional(),
+  inputModalities: z2.array(z2.enum(INPUT_MODALITIES)).optional(),
+  outputModalities: z2.array(z2.enum(OUTPUT_MODALITIES)).optional(),
+  toolCapabilities: z2.array(z2.enum(TOOL_CAPABILITIES)).optional(),
+  specialFeatures: z2.array(z2.enum(SPECIAL_FEATURES)).optional(),
   pricing: PricingSchema.optional(),
   qualityScores: QualityScoresSchema.optional(),
-  notes: z3.string().max(2e3).optional(),
+  notes: z2.string().max(2e3).optional(),
   // Behaviour (all optional — defaults fill in)
-  parallelToolCalls: z3.boolean().optional(),
+  parallelToolCalls: z2.boolean().optional(),
   promptCaching: PromptCachingModeSchema.optional(),
   toolDefinitionFormat: ToolDefinitionFormatSchema.optional(),
-  maxRecommendedTurnBudget: z3.number().int().positive().max(100).optional(),
-  strictJson: z3.boolean().optional(),
-  quirks: z3.array(z3.string().max(80)).max(20).optional(),
-  profileId: z3.string().min(1).max(80).optional(),
+  maxRecommendedTurnBudget: z2.number().int().positive().max(100).optional(),
+  strictJson: z2.boolean().optional(),
+  quirks: z2.array(z2.string().max(80)).max(20).optional(),
+  profileId: z2.string().min(1).max(80).optional(),
   // Provenance (optional)
-  verifiedAt: z3.string().min(8).max(40).optional()
+  verifiedAt: z2.string().min(8).max(40).optional()
 });
-var ManifestSchema = z3.object({
-  version: z3.literal(1),
-  models: z3.array(z3.unknown())
+var ManifestSchema = z2.object({
+  version: z2.literal(1),
+  models: z2.array(z2.unknown())
 });
 function loadManifestOverlay(options) {
   const logger11 = options?.logger ?? createLogger({ component: "manifest-overlay" });
@@ -2603,7 +2574,7 @@ function formatPercentage(value, decimals = 0) {
 
 // src/core/artifact.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var ArtifactType = {
   /** Planning documents and task breakdowns */
   PLAN: "plan",
@@ -2616,30 +2587,30 @@ var ArtifactType = {
   /** Intent declarations for policy authorization */
   INTENT: "intent"
 };
-var ArtifactTypeSchema = z4.enum([
+var ArtifactTypeSchema = z3.enum([
   ArtifactType.PLAN,
   ArtifactType.ANALYSIS,
   ArtifactType.DECISION,
   ArtifactType.RESULT,
   ArtifactType.INTENT
 ]);
-var ArtifactMetadataSchema = z4.object({
-  createdAt: z4.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
-  createdBy: z4.string().min(1, "createdBy is required"),
-  parentId: z4.uuid().optional(),
-  taskId: z4.string().min(1, "taskId is required"),
-  traceId: z4.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 z4.object({
-    id: z4.uuid(),
+  return z3.object({
+    id: z3.uuid(),
     type: ArtifactTypeSchema,
-    schemaVersion: z4.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(z4.unknown());
+var BaseArtifactSchema = createArtifactSchema(z3.unknown());
 
 // src/core/metrics.ts
 var MAX_RECENT_ERRORS = 1e3;
@@ -4585,19 +4556,19 @@ var TopsisRouter = class {
 };
 
 // src/cli-adapters/budget-router-types.ts
-import { z as z5 } from "zod";
-var BudgetConstraintSchema = z5.object({
-  maxTokens: z5.number().int().positive().optional(),
-  maxCostUSD: z5.number().positive().optional(),
-  maxLatencyMs: z5.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 = z5.object({
-  totalTokens: z5.number().int().positive(),
-  totalCostUSD: z5.number().positive(),
-  usedTokens: z5.number().int().min(0).default(0),
-  usedCostUSD: z5.number().min(0).default(0),
-  startTime: z5.number().int().positive(),
-  sessionId: z5.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,
@@ -4605,11 +4576,11 @@ var DEFAULT_LINUCB_CONFIG = {
   alpha: 1,
   lambda: 1
 };
-var LinUCBConfigSchema = z5.object({
-  numArms: z5.number().int().positive().default(4),
-  featureDim: z5.number().int().positive().default(6),
-  alpha: z5.number().positive().default(1),
-  lambda: z5.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
@@ -4964,7 +4935,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -4985,24 +4956,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-var PreferenceRouterConfigSchema = z6.object({
-  strongModel: z6.object({
-    tier: z6.literal("strong"),
-    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z6.number().positive(),
-    qualityBaseline: z6.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: z6.object({
-    tier: z6.literal("weak"),
-    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z6.number().positive(),
-    qualityBaseline: z6.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: z6.number().min(0).max(1).default(0.5),
-  minDataPoints: z6.number().int().positive().default(10),
-  maxDataPoints: z6.number().int().positive().default(1e4),
-  enableOnlineLearning: z6.boolean().default(true),
-  domainThresholds: z6.record(z6.string(), z6.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
@@ -5344,8 +5315,8 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z7 } from "zod";
-var DifficultyDimensionSchema = z7.enum([
+import { z as z6 } from "zod";
+var DifficultyDimensionSchema = z6.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -5359,17 +5330,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z7.object({
+var DifficultySpaceSchema = z6.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z7.number().min(0).max(1),
+  reasoning: z6.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z7.number().min(0).max(1),
+  knowledge: z6.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z7.number().min(0).max(1),
+  creativity: z6.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z7.number().min(0).max(1),
+  precision: z6.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z7.number().min(0).max(1)
+  context_length: z6.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -5385,12 +5356,12 @@ var DEFAULT_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DifficultyWeightsSchema = z7.object({
-  reasoning: z7.number().min(0).max(1),
-  knowledge: z7.number().min(0).max(1),
-  creativity: z7.number().min(0).max(1),
-  precision: z7.number().min(0).max(1),
-  context_length: z7.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,
@@ -5399,29 +5370,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z7.object({
+var ZeroRouterConfigSchema = z6.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z7.object({
-    easyUpperBound: z7.number().min(0).max(1),
-    hardLowerBound: z7.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: z7.record(z7.enum(["easy", "medium", "hard"]), z7.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: z7.record(
-    z7.enum(["fast", "balanced", "powerful"]),
-    z7.array(z7.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: z7.boolean().default(true),
+  enableCalibration: z6.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z7.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z6.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z7.number().int().positive().default(50),
+  minCalibrationOutcomes: z6.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z7.boolean().default(false)
+  verbose: z6.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -5945,16 +5916,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z8 } from "zod";
-var LatencyTrackerConfigSchema = z8.object({
+import { z as z7 } from "zod";
+var LatencyTrackerConfigSchema = z7.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z8.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: z8.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: z8.number().int().positive().default(36e5),
+  maxSampleAgeMs: z7.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z8.array(z8.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,
@@ -6188,192 +6159,20 @@ 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 z9 } from "zod";
-var StageConfigSchema = z9.object({
-  enabled: z9.boolean().default(true),
-  priority: z9.number().int().min(0).max(100).default(50),
-  options: z9.record(z9.string(), z9.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 = z9.object({
+var RoutingOutcomeSchema = z8.object({
   selectedCli: CliNameSchema,
-  task: z9.string(),
-  success: z9.boolean(),
-  qualityScore: z9.number().min(0).max(1).optional(),
-  latencyMs: z9.number().int().positive().optional(),
-  tokensUsed: z9.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 {
@@ -6570,7 +6369,7 @@ var ConfidenceCascadeStage = class {
 };
 
 // src/config/task-specialization-types.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -6583,8 +6382,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z10.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z10.object({
+var TaskCategorySchema = z9.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z9.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -6592,11 +6391,11 @@ var TaskSpecializationSchema = z10.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z10.string(),
+  reasoning: z9.string(),
   /** Keywords that trigger this category detection */
-  keywords: z10.array(z10.string()).min(1),
+  keywords: z9.array(z9.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z10.number().min(0).max(20)
+  bonus: z9.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -7819,10 +7618,10 @@ function createPersistentDistillerOrFallback(outcomeStore, logger11) {
 }
 
 // src/orchestration/outcomes/outcome-types.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 var logger6 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z11.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z11.enum([
+var OutcomeSourceSchema = z10.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z10.enum([
   "timeout",
   "authentication",
   "rate_limit",
@@ -7835,47 +7634,58 @@ var OutcomeFailureCategorySchema = z11.enum([
   "generic",
   "unknown"
 ]);
-var TaskOutcomeSchema = z11.object({
-  id: z11.string().min(1),
+var TaskOutcomeSchema = z10.object({
+  id: z10.string().min(1),
   cli: CliNameSchema,
   category: TaskCategorySchema,
-  model: z11.string().min(1),
-  success: z11.boolean(),
-  durationMs: z11.number().nonnegative(),
-  timestamp: z11.string().min(1),
-  qualitySignals: z11.array(z11.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: z11.string().max(500).optional(),
+  errorMessage: z10.string().max(500).optional(),
   source: OutcomeSourceSchema,
   /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z11.boolean().optional(),
+  wasRetried: z10.boolean().optional(),
   /** Triage action taken on the failure (#1506). */
-  triageAction: z11.string().max(30).optional(),
+  triageAction: z10.string().max(30).optional(),
   /** Routing stage that selected this CLI (#1785). */
-  routingStage: z11.string().max(50).optional(),
+  routingStage: z10.string().max(50).optional(),
   /** Number of retry attempts before this outcome (#1785). */
-  retryCount: z11.number().int().nonnegative().optional(),
+  retryCount: z10.number().int().nonnegative().optional(),
   /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
-  vendor: z11.string().min(1).max(40).optional(),
+  vendor: z10.string().min(1).max(40).optional(),
   /** Family resolved from `model` via ModelRegistry at write time (#2548). */
-  family: z11.string().min(1).max(80).optional(),
+  family: z10.string().min(1).max(80).optional(),
   /**
    * Voter role for `source: 'consensus'` outcomes (#2662) — `architect`,
    * `security`, etc. Absent on non-consensus outcomes. Lets the
    * stratified outcome report break results down by voter role.
    */
-  voterRole: z11.string().min(1).max(40).optional()
+  voterRole: z10.string().min(1).max(40).optional(),
+  /**
+   * Baseline this outcome forked from (#2697 / Epic F follow-up to #2665).
+   * Set on outcomes recorded inside a fork-then-merge graph branch so
+   * `query({ baselineId: 'B' })` returns every branch outcome forked
+   * from baseline B — letting later analysis compare branches as a
+   * cohort. Free-form string (caller-assigned); typically the parent
+   * node's `executionId` or `taskId`.
+   */
+  baselineId: z10.string().min(1).max(64).optional()
 });
-var OutcomeQuerySchema = z11.object({
+var OutcomeQuerySchema = z10.object({
   cli: CliNameSchema.optional(),
   category: TaskCategorySchema.optional(),
   source: OutcomeSourceSchema.optional(),
-  success: z11.boolean().optional(),
+  success: z10.boolean().optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  since: z11.string().optional(),
-  limit: z11.number().int().positive().optional(),
+  since: z10.string().optional(),
+  limit: z10.number().int().positive().optional(),
   /** Exclude outcomes with any of these quality signals (#1680). */
-  excludeQualitySignals: z11.array(z11.string()).optional()
+  excludeQualitySignals: z10.array(z10.string()).optional(),
+  /** Restrict to outcomes recorded against a specific baseline (#2697). */
+  baselineId: z10.string().min(1).max(64).optional()
 });
 var TIMEOUT_PATTERNS = ["timeout", "timed out", "deadline exceeded", "socket hang up", "aborted"];
 var AUTH_PATTERNS = [
@@ -8245,9 +8055,18 @@ function getOutcomeStore() {
     } else {
       singletonStore = new OutcomeStore();
     }
+    void attachOutcomeStoreToRegistry(singletonStore);
   }
   return singletonStore;
 }
+async function attachOutcomeStoreToRegistry(store) {
+  try {
+    const { getMemoryRegistry } = await import("./dist-NIXVXYIH.js");
+    const { OutcomeStoreAdapter } = await import("./outcome-store-adapter-QRFJJIKB.js");
+    getMemoryRegistry().attach("outcomes", new OutcomeStoreAdapter(store));
+  } catch {
+  }
+}
 function resetOutcomeStore() {
   singletonStore = void 0;
 }
@@ -8297,6 +8116,9 @@ function buildPredicates(filter) {
       return !signals.some((s) => excluded.has(s));
     });
   }
+  if (filter.baselineId !== void 0) {
+    preds.push((o) => o.baselineId === filter.baselineId);
+  }
   return preds;
 }
 function applyFilters(entries, filter) {
@@ -8494,52 +8316,52 @@ function runWarmUp(logger11) {
 }
 
 // src/cli-adapters/composite-router-types.ts
-import { z as z12 } from "zod";
-var CompositeRouterConfigSchema = z12.object({
+import { z as z11 } from "zod";
+var CompositeRouterConfigSchema = z11.object({
   /** Enable confidence cascade stage (default: false) (Issue #755, ADR-0005) */
-  enableConfidenceCascade: z12.boolean().default(false),
+  enableConfidenceCascade: z11.boolean().default(false),
   /** Enable budget filtering stage (default: true) */
-  enableBudgetFilter: z12.boolean().default(true),
+  enableBudgetFilter: z11.boolean().default(true),
   /** Enable capability match stage (default: false) (Issue #755, ADR-0005) */
-  enableCapabilityMatch: z12.boolean().default(false),
+  enableCapabilityMatch: z11.boolean().default(false),
   /** Enable ZeroRouter difficulty-based routing stage (default: true) (Issue #473) */
-  enableZeroRouter: z12.boolean().default(true),
+  enableZeroRouter: z11.boolean().default(true),
   /** Enable preference-trained routing stage (default: false) */
-  enablePreferenceRouting: z12.boolean().default(false),
+  enablePreferenceRouting: z11.boolean().default(false),
   /** Enable TOPSIS ranking stage (default: true) */
-  enableTopsisRanking: z12.boolean().default(true),
+  enableTopsisRanking: z11.boolean().default(true),
   /** Enable LinUCB selection stage (default: true) */
-  enableLinUCBSelection: z12.boolean().default(true),
+  enableLinUCBSelection: z11.boolean().default(true),
   /** Enable quality constraint stage (default: false) (Issue #755, ADR-0005) */
-  enableQualityConstraint: z12.boolean().default(false),
+  enableQualityConstraint: z11.boolean().default(false),
   /** Enable resource strategy stage for budget-aware oscillation (default: true) (Issue #998) */
-  enableResourceStrategy: z12.boolean().default(true),
+  enableResourceStrategy: z11.boolean().default(true),
   /** Enable strategy distillation for learned routing rules (default: false) (Issue #999) */
-  enableStrategyDistillation: z12.boolean().default(false),
+  enableStrategyDistillation: z11.boolean().default(false),
   /** Enable latency tracking for routing decisions (default: true) (Issue #361) */
-  enableLatencyTracking: z12.boolean().default(true),
+  enableLatencyTracking: z11.boolean().default(true),
   /** Enable routing memory for learned routing (default: false) (Issue #463, #461) */
-  enableRoutingMemory: z12.boolean().default(false),
-  /** Enable KNN experience-based routing (default: false) (arXiv:2507.05370) */
-  enableKnnRouting: z12.boolean().default(false),
+  enableRoutingMemory: z11.boolean().default(false),
+  /** Enable KNN experience-based routing (default: false) (arXiv:2505.12601) */
+  enableKnnRouting: z11.boolean().default(false),
   /** Weight for latency score in final routing (0-1, default: 0.2) */
-  latencyScoreWeight: z12.number().min(0).max(1).default(0.2),
+  latencyScoreWeight: z11.number().min(0).max(1).default(0.2),
   /** Budget constraints (optional) */
-  budgetConstraints: z12.object({
-    maxTokens: z12.number().positive(),
-    maxCostUsd: z12.number().positive(),
-    maxLatencyMs: z12.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: z12.number().positive().default(1),
+  linucbAlpha: z11.number().positive().default(1),
   /** Billing mode: 'plan' zeroes cost weight, 'api' preserves current behavior (default: 'plan') */
-  billingMode: z12.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: z12.boolean().default(true),
+  enableCapacityBalancing: z11.boolean().default(true),
   /** Maximum routing decision time in ms (default: 50) */
-  maxDecisionTimeMs: z12.number().positive().default(50),
+  maxDecisionTimeMs: z11.number().positive().default(50),
   /** Minimum preference data points before using learned routing (default: 10) */
-  preferenceMinDataPoints: z12.number().int().positive().default(10)
+  preferenceMinDataPoints: z11.number().int().positive().default(10)
 });
 var DEFAULT_COMPOSITE_CONFIG = {
   enableConfidenceCascade: false,
@@ -8561,7 +8383,7 @@ var DEFAULT_COMPOSITE_CONFIG = {
   enableLatencyTracking: true,
   enableRoutingMemory: false,
   enableKnnRouting: false,
-  // arXiv:2507.05370 - KNN experience-based routing
+  // arXiv:2505.12601 - KNN experience-based routing
   enableCapacityBalancing: true,
   // Issue #807 - Deprioritize exhausted CLIs
   latencyScoreWeight: 0.2,
@@ -8823,12 +8645,12 @@ async function fetchCapacityData(adapters) {
 }
 
 // src/mcp/tools/weather-report-types.ts
-import { z as z13 } from "zod";
-var WeatherReportInputSchema = z13.object({
+import { z as z12 } from "zod";
+var WeatherReportInputSchema = z12.object({
   /** Filter by CLI name. */
-  cli: z13.enum(CLI_NAMES).optional().describe("Filter by CLI"),
+  cli: z12.enum(CLI_NAMES).optional().describe("Filter by CLI"),
   /** Filter by task category. */
-  category: z13.enum([
+  category: z12.enum([
     "architecture",
     "code_generation",
     "code_review",
@@ -8841,22 +8663,22 @@ var WeatherReportInputSchema = z13.object({
     "exploration"
   ]).optional().describe("Filter by task category"),
   /** Include adaptive routing bonus data. */
-  includeAdaptive: z13.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 = z13.object({
+var WeatherReportConfigSchema = z12.object({
   /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z13.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: z13.number().min(0).max(1).default(0.1),
+  explorationRate: z12.number().min(0).max(1).default(0.1),
   /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z13.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: z13.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({});
@@ -9241,47 +9063,47 @@ function createMetricsMiddleware() {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/config/defaults-types.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function isKnownCliName(cli) {
   return cli === "claude" || cli === "gemini" || cli === "codex" || cli === "opencode" || cli === "default";
 }
-var positiveInt = z14.number().int().positive();
-var nonNegativeInt = z14.number().int().nonnegative();
-var durationMs = z14.number().int().positive().describe("Duration in milliseconds");
-var TimeoutProfileSchema = z14.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 = z14.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: z14.number().min(0).max(1).describe("Jitter factor (0-1)")
+  jitterFactor: z13.number().min(0).max(1).describe("Jitter factor (0-1)")
 });
-var RateLimitDefaultsSchema = z14.object({
+var RateLimitDefaultsSchema = z13.object({
   requestsPerMinute: positiveInt.max(1e3).describe("Max requests per minute"),
-  enabled: z14.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 = z14.object({
-  failureThreshold: z14.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: z14.number().int().min(1).max(10).describe("Successes to close"),
-  countTimeoutsAsFailures: z14.boolean().describe("Count timeouts as failures"),
-  countAuthFailuresAsFailures: z14.boolean().describe("Count auth failures as failures"),
-  countRateLimitsAsFailures: z14.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 = z14.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 = z14.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"),
@@ -9291,7 +9113,7 @@ var WorkerDefaultsSchema = z14.object({
   eventBusMaxHistory: nonNegativeInt.max(1e4).describe("Event bus history limit"),
   swarmObserverMaxEvents: nonNegativeInt.max(1e4).describe("Swarm observer event limit")
 });
-var TimeoutDefaultsSchema = z14.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"),
@@ -10232,9 +10054,9 @@ function convertBonusesToScoreMap(bonuses, taskCategory) {
 }
 
 // src/cli-adapters/fallback-chains.ts
-import { z as z15 } from "zod";
-var FallbackChainSchema = z15.array(z15.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
-var FallbackChainRegistrySchema = z15.object({
+import { z as z14 } from "zod";
+var FallbackChainSchema = z14.array(z14.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
+var FallbackChainRegistrySchema = z14.object({
   code: FallbackChainSchema,
   research: FallbackChainSchema,
   documentation: FallbackChainSchema,
@@ -10933,6 +10755,15 @@ var CompositeRouter = class _CompositeRouter {
   linucbBandit;
   latencyTracker;
   routingMemory;
+  /**
+   * Most recently consulted unified memory context (Phase 3 of #2792).
+   * Set on every {@link route} call so tests + telemetry can inspect what
+   * the router saw at decision time. Typed as `unknown` here to avoid
+   * pulling the typed surface into this module's circular-dep zone — the
+   * field is for observability; callers that need typed reads should call
+   * `getContextForTask` directly.
+   */
+  lastUnifiedContext;
   /** Metrics collector for routing observability (Issue #559) */
   metricsCollector;
   /** Orchestration observer for routing decision tracking (Issue #587) */
@@ -10947,7 +10778,7 @@ var CompositeRouter = class _CompositeRouter {
   resourceStrategyStage;
   /** Distilled rule stage instance (Issue #999) */
   distilledRuleStage;
-  /** KNN routing stage instance (arXiv:2507.05370) */
+  /** KNN routing stage instance (arXiv:2505.12601) */
   knnRoutingStage;
   /** Strategy distiller instance (Issue #999) */
   strategyDistiller;
@@ -11134,12 +10965,40 @@ var CompositeRouter = class _CompositeRouter {
     });
   }
   async route(task) {
+    void this.consultUnifiedContext(task);
     const result = await this.executeRouting(task, getTimeProvider().now());
     if (result.ok) {
       this.emitRoutingDecision(result.value, task.content);
     }
     return result;
   }
+  /**
+   * Read the unified memory context for this task. Best-effort, never
+   * throws. Sets `this.lastUnifiedContext` so external observers (tests,
+   * telemetry) can inspect what the router consulted at decision time.
+   */
+  async consultUnifiedContext(task) {
+    try {
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-MB3D7KS6.js");
+      const ctx = await getContextForTask({
+        task: task.content,
+        category: inferTaskCategory(task.content),
+        logger: this.logger
+      });
+      this.lastUnifiedContext = ctx;
+      this.logger.debug("CompositeRouter: unified memory context", {
+        beliefs: ctx.beliefs.length,
+        similarMemories: ctx.similarMemories.length,
+        recentLearnings: ctx.recentLearnings.length,
+        experiencePatterns: ctx.experiencePatterns.length,
+        outcomesTotal: ctx.outcomes?.totalTasks ?? 0
+      });
+    } catch (error) {
+      this.logger.debug("CompositeRouter: context retrieval failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   /**
    * Unified method that routes, executes, and auto-records feedback.
    * Use this for most cases; use route() when you need decision details without execution.
@@ -11303,7 +11162,7 @@ var CompositeRouter = class _CompositeRouter {
       resourceStrategyStage: this.resourceStrategyStage,
       // Issue #999 distilled rule stage
       distilledRuleStage: this.distilledRuleStage,
-      // arXiv:2507.05370 KNN routing
+      // arXiv:2505.12601 KNN routing
       knnRoutingStage: this.knnRoutingStage
     };
   }
@@ -11506,6 +11365,38 @@ var OrchestratorError = class extends Error {
   }
 };
 
+// src/context/mobimem.ts
+import Database from "better-sqlite3";
+import { dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// src/context/mobimem-types.ts
+import { z as z15 } 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 = z15.object({
+  dbPath: z15.string(),
+  maxProfileEntries: z15.number().int().positive().default(100),
+  maxExperiencePatterns: z15.number().int().positive().default(500),
+  maxActionCacheEntries: z15.number().int().positive().default(1e3),
+  actionCacheTtlMs: z15.number().int().positive().default(36e5),
+  minProfileConfidence: z15.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z15.number().min(0).max(1).default(0.7),
+  autoEviction: z15.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) {
@@ -11553,12 +11444,89 @@ function computeAverage(values, valueFn) {
   return count > 0 ? total / count : 0;
 }
 
+// src/context/mobimem-persistence.ts
+var MobiMemPersistence = class {
+  active;
+  db;
+  domain;
+  stmts;
+  constructor(options) {
+    this.db = options.db;
+    this.domain = options.domain;
+    this.active = options.db !== null;
+    if (!/^[a-z][a-z0-9_]{0,63}$/i.test(options.domain)) {
+      throw new Error(
+        `mobimem-persistence: invalid domain "${options.domain}" \u2014 must match [a-zA-Z][a-zA-Z0-9_]{0,63}`
+      );
+    }
+    if (this.active && this.db !== null) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS ${options.domain} (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          timestamp INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS ${options.domain}_timestamp ON ${options.domain}(timestamp);
+      `);
+      this.stmts = {
+        upsert: this.db.prepare(
+          `INSERT INTO ${options.domain} (key, value, timestamp) VALUES (@key, @value, @timestamp)
+           ON CONFLICT(key) DO UPDATE SET value = excluded.value, timestamp = excluded.timestamp`
+        ),
+        delete: this.db.prepare(`DELETE FROM ${options.domain} WHERE key = ?`),
+        clear: this.db.prepare(`DELETE FROM ${options.domain}`),
+        selectAll: this.db.prepare(`SELECT key, value FROM ${options.domain}`)
+      };
+    } else {
+      this.stmts = null;
+    }
+  }
+  /** Hydrate the impl's Map cache from SQLite. No-op when inactive. */
+  load() {
+    if (this.stmts === null) return [];
+    const rows = this.stmts.selectAll.all();
+    return rows.map((r) => [r.key, JSON.parse(r.value)]);
+  }
+  /** Upsert a single row. No-op when inactive. */
+  upsert(key, value) {
+    if (this.stmts === null) return;
+    this.stmts.upsert.run({
+      key,
+      value: JSON.stringify(value),
+      timestamp: Date.now()
+    });
+  }
+  /** Delete a single row. No-op when inactive. */
+  delete(key) {
+    if (this.stmts === null) return;
+    this.stmts.delete.run(key);
+  }
+  /** Wipe the table. No-op when inactive. */
+  clear() {
+    if (this.stmts === null) return;
+    this.stmts.clear.run();
+  }
+};
+
 // src/context/mobimem-impl.ts
+function hydrateDates(value, dateKeys) {
+  const out = value;
+  for (const key of dateKeys) {
+    const v = out[key];
+    if (typeof v === "string") out[key] = new Date(v);
+  }
+  return value;
+}
 var ProfileMemoryImpl = class {
   entries = /* @__PURE__ */ new Map();
   config;
-  constructor(config) {
+  persist;
+  constructor(config, db = null) {
     this.config = config;
+    this.persist = new MobiMemPersistence({ db, domain: "mobimem_profile" });
+    for (const [k, v] of this.persist.load()) {
+      this.entries.set(k, hydrateDates(v, ["createdAt", "updatedAt"]));
+    }
   }
   observe(entityId, entityType, preferenceKey, preferenceValue) {
     const key = `${entityId}:${preferenceKey}`;
@@ -11574,6 +11542,7 @@ var ProfileMemoryImpl = class {
         updatedAt: now
       };
       this.entries.set(key, updated);
+      this.persist.upsert(key, updated);
       return updated;
     }
     const entry = {
@@ -11589,6 +11558,7 @@ var ProfileMemoryImpl = class {
     };
     this.enforceLimit(entityId);
     this.entries.set(key, entry);
+    this.persist.upsert(key, entry);
     return entry;
   }
   getPreferences(entityId) {
@@ -11614,6 +11584,7 @@ var ProfileMemoryImpl = class {
     for (const [key, entry] of this.entries) {
       if (entry.entityId === entityId) {
         this.entries.delete(key);
+        this.persist.delete(key);
         count++;
       }
     }
@@ -11635,6 +11606,7 @@ var ProfileMemoryImpl = class {
       if (toRemove !== void 0) {
         const key = `${entityId}:${toRemove.preferenceKey}`;
         this.entries.delete(key);
+        this.persist.delete(key);
       }
     }
   }
@@ -11642,8 +11614,13 @@ var ProfileMemoryImpl = class {
 var ExperienceMemoryImpl = class {
   patterns = /* @__PURE__ */ new Map();
   config;
-  constructor(config) {
+  persist;
+  constructor(config, db = null) {
     this.config = config;
+    this.persist = new MobiMemPersistence({ db, domain: "mobimem_experience" });
+    for (const [k, v] of this.persist.load()) {
+      this.patterns.set(k, hydrateDates(v, ["createdAt", "lastUsedAt"]));
+    }
   }
   recordExecution(taskType, actionSequence, outcome, contextSignature) {
     const patternKey = generatePatternKey(taskType, actionSequence, contextSignature);
@@ -11662,6 +11639,7 @@ var ExperienceMemoryImpl = class {
         lastUsedAt: now
       };
       this.patterns.set(patternKey, updated);
+      this.persist.upsert(patternKey, updated);
       return updated;
     }
     const entry = {
@@ -11678,6 +11656,7 @@ var ExperienceMemoryImpl = class {
     };
     this.enforceLimit(taskType);
     this.patterns.set(patternKey, entry);
+    this.persist.upsert(patternKey, entry);
     return entry;
   }
   findPatterns(taskType, limit = 10) {
@@ -11712,11 +11691,13 @@ var ExperienceMemoryImpl = class {
     for (const [key, entry] of this.patterns) {
       if (entry.id === patternId) {
         const metrics2 = computeUpdatedMetrics(entry.successCount, entry.attemptCount, success);
-        this.patterns.set(key, {
+        const updated = {
           ...entry,
           ...metrics2,
           lastUsedAt: new Date(getTimeProvider().now())
-        });
+        };
+        this.patterns.set(key, updated);
+        this.persist.upsert(key, updated);
         return;
       }
     }
@@ -11738,6 +11719,7 @@ var ExperienceMemoryImpl = class {
         for (const [key, entry] of this.patterns) {
           if (entry.id === toRemove.id) {
             this.patterns.delete(key);
+            this.persist.delete(key);
             break;
           }
         }
@@ -11748,10 +11730,18 @@ var ExperienceMemoryImpl = class {
 var ActionCacheImpl = class {
   entries = /* @__PURE__ */ new Map();
   config;
+  persist;
   totalHits = 0;
   totalRequests = 0;
-  constructor(config) {
+  constructor(config, db = null) {
     this.config = config;
+    this.persist = new MobiMemPersistence({ db, domain: "mobimem_action" });
+    for (const [k, v] of this.persist.load()) {
+      this.entries.set(
+        k,
+        hydrateDates(v, ["cachedAt", "lastAccessedAt", "expiresAt"])
+      );
+    }
   }
   cache(input, result, durationMs2) {
     const inputHash = hashInput(input);
@@ -11770,6 +11760,7 @@ var ActionCacheImpl = class {
     };
     this.enforceLimit();
     this.entries.set(inputHash, entry);
+    this.persist.upsert(inputHash, entry);
     return entry;
   }
   get(input) {
@@ -11779,6 +11770,7 @@ var ActionCacheImpl = class {
     if (entry === void 0) return null;
     if (entry.expiresAt < new Date(getTimeProvider().now())) {
       this.entries.delete(inputHash);
+      this.persist.delete(inputHash);
       return null;
     }
     this.totalHits++;
@@ -11794,6 +11786,7 @@ var ActionCacheImpl = class {
           lastAccessedAt: new Date(getTimeProvider().now())
         };
         this.entries.set(hash, updated);
+        this.persist.upsert(hash, updated);
         return;
       }
     }
@@ -11804,6 +11797,7 @@ var ActionCacheImpl = class {
     for (const [hash, entry] of this.entries) {
       if (entry.expiresAt < now) {
         this.entries.delete(hash);
+        this.persist.delete(hash);
         evicted++;
       }
     }
@@ -11812,6 +11806,7 @@ var ActionCacheImpl = class {
   clear() {
     const count = this.entries.size;
     this.entries.clear();
+    this.persist.clear();
     this.totalHits = 0;
     this.totalRequests = 0;
     return count;
@@ -11828,6 +11823,7 @@ var ActionCacheImpl = class {
       timeSavedMs: totalTimeSaved
     };
   }
+  /** Drop one entry to stay under the cache limit. SQLite mirror updated. */
   enforceLimit() {
     if (this.entries.size >= this.config.maxActionCacheEntries) {
       this.evictExpired();
@@ -11838,6 +11834,7 @@ var ActionCacheImpl = class {
         const toRemove = sorted[0];
         if (toRemove !== void 0) {
           this.entries.delete(toRemove[0]);
+          this.persist.delete(toRemove[0]);
         }
       }
     }
@@ -11851,13 +11848,24 @@ var MobiMem = class {
   experience;
   action;
   config;
+  db;
   constructor(config = {}) {
     const validated = MobiMemConfigSchema.parse({ ...DEFAULT_MOBIMEM_CONFIG, ...config });
     this.config = validated;
-    this.profile = new ProfileMemoryImpl(this.config);
-    this.experience = new ExperienceMemoryImpl(this.config);
-    this.action = new ActionCacheImpl(this.config);
+    if (validated.dbPath === ":memory:" || validated.dbPath === "") {
+      this.db = null;
+    } else {
+      mkdirSync2(dirname3(validated.dbPath), { recursive: true });
+      const db = new Database(validated.dbPath);
+      db.pragma("journal_mode = WAL");
+      this.db = db;
+    }
+    this.profile = new ProfileMemoryImpl(this.config, this.db);
+    this.experience = new ExperienceMemoryImpl(this.config, this.db);
+    this.action = new ActionCacheImpl(this.config, this.db);
     logger10.info("MobiMem initialized", {
+      dbPath: validated.dbPath,
+      persisted: this.db !== null,
       maxProfileEntries: this.config.maxProfileEntries,
       maxExperiencePatterns: this.config.maxExperiencePatterns,
       maxActionCacheEntries: this.config.maxActionCacheEntries
@@ -11893,31 +11901,194 @@ var MobiMem = class {
     }
   }
   close() {
+    if (this.db !== null) this.db.close();
     logger10.info("MobiMem closed");
   }
-  /** Export MobiMem state for disk persistence (#1782). */
-  exportData() {
-    return {
-      stats: this.getStats(),
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+};
+var sharedInstance = null;
+var resolveSharedDbPath = defaultSharedDbPath;
+function getSharedMobiMem() {
+  sharedInstance ??= new MobiMem({ dbPath: resolveSharedDbPath() });
+  return sharedInstance;
+}
+function setSharedMobiMemDbPathResolver(resolver) {
+  resolveSharedDbPath = resolver;
+}
+function defaultSharedDbPath() {
+  const root = process.env["NEXUS_DATA_DIR"] ?? `${process.env["HOME"] ?? "/tmp"}/.nexus-agents`;
+  return `${root}/memory/mobimem.db`;
+}
+
+// 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 ?? getSharedMobiMem();
+    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
+    });
   }
-  /** 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");
-      logger10.debug("MobiMem state saved", { path: filePath });
-    } catch (error) {
-      logger10.warn("Failed to save MobiMem state", { error: String(error) });
+  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 createMobiMem(config) {
-  return new MobiMem(config);
+function createRoutingMemory(config, mobimem) {
+  return new RoutingMemory(config, mobimem);
 }
 
 export {
@@ -12022,9 +12193,8 @@ export {
   PreferenceRouter,
   createPreferenceRouter,
   DEFAULT_ZERO_ROUTER_CONFIG,
-  DEFAULT_MOBIMEM_CONFIG,
-  MobiMem,
-  createMobiMem,
+  getSharedMobiMem,
+  setSharedMobiMemDbPathResolver,
   DEFAULT_ROUTING_MEMORY_CONFIG,
   RoutingMemory,
   createRoutingMemory,
@@ -12106,4 +12276,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-3MRM53T4.js.map
+//# sourceMappingURL=chunk-WDYCIJWN.js.map