nexus-agents 2.162.1 → 2.163.0

package/dist/{chunk-XWAV3UC2.js → chunk-D2NBIVAV.js}

@@ -1,7 +1,7 @@
 import {
   GitHubProvider,
   ScmError
-} from "./chunk-GJSJRJ6Y.js";
+} from "./chunk-K7GAI4WP.js";
 import {
   ROLE_DEFAULT_TRUST,
   ReputationCache,
@@ -11,17 +11,17 @@ import {
   gateWithReputation,
   resolveReputationGatingMode,
   sanitizeInput
-} from "./chunk-GMSYKYFA.js";
+} from "./chunk-PRU452SV.js";
 import {
   emitPolicyEvent
-} from "./chunk-N67NSSQT.js";
+} from "./chunk-NG5ZAI7W.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
   createLogger,
   err,
   getTimeProvider,
   ok
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/security/trust-classifier.ts
 function mapAuthorAssociation(association) {
@@ -1211,4 +1211,4 @@ export {
   IssueTriage,
   createIssueTriage
 };
-//# sourceMappingURL=chunk-XWAV3UC2.js.map
+//# sourceMappingURL=chunk-D2NBIVAV.js.map

package/dist/{chunk-DXEYJAGO.js → chunk-ENKFWBRH.js}

@@ -1,7 +1,7 @@
 import {
   getRandomProvider,
   getTimeProvider
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/utils/id-utils.ts
 import { randomUUID } from "crypto";
@@ -24,4 +24,4 @@ export {
   generateHyphenId,
   generateUUID
 };
-//# sourceMappingURL=chunk-DXEYJAGO.js.map
+//# sourceMappingURL=chunk-ENKFWBRH.js.map

package/dist/{chunk-W3ZTVYZN.js → chunk-HDLWUFKI.js}

@@ -1,6 +1,6 @@
 import {
   getErrorMessage
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/cli/setup-config.ts
 import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
@@ -77,4 +77,4 @@ function ensureBackup(outputPath) {
 export {
   runConfigInitSync
 };
-//# sourceMappingURL=chunk-W3ZTVYZN.js.map
+//# sourceMappingURL=chunk-HDLWUFKI.js.map

package/dist/{chunk-WP6L2PTV.js → chunk-JZ3DVFEW.js}

@@ -5,24 +5,24 @@ import {
   planOptionalParams,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-DBHK6EDT.js";
+} from "./chunk-ARTIFRBA.js";
 import {
   CUSTOM_API_BASE_URL_ENV,
   CUSTOM_API_DEFAULT_MODEL,
   PROVIDER_ENV_KEYS,
   assertCustomApiHostResolvesPublic,
   validateCustomApiBaseUrl
-} from "./chunk-RDYGX6MQ.js";
+} from "./chunk-WRZ7HENW.js";
 import {
   CliCircuitBreaker,
   DEFAULT_CIRCUIT_BREAKER_CONFIG
-} from "./chunk-HJZ3RES7.js";
+} from "./chunk-AOXZ42SD.js";
 import {
   getAvailabilityCache
-} from "./chunk-EZHYOWWO.js";
+} from "./chunk-LJWB4Z7O.js";
 import {
   generateHyphenId
-} from "./chunk-DXEYJAGO.js";
+} from "./chunk-ENKFWBRH.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
   CLI_TIMEOUTS,
@@ -58,7 +58,7 @@ import {
   loadModelsDevSnapshot,
   ok,
   resolveCliAlias
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/cli-adapters/cli-to-model-adapter.ts
 var CliToModelAdapter = class {
@@ -4867,4 +4867,4 @@ export {
   SdkAdapter,
   createAutoAdapter
 };
-//# sourceMappingURL=chunk-WP6L2PTV.js.map
+//# sourceMappingURL=chunk-JZ3DVFEW.js.map

package/dist/{chunk-JYR6SBUB.js → chunk-K5NU57WE.js}

@@ -1,10 +1,10 @@
 import {
   OpenAIAdapter
-} from "./chunk-JIXCOX7D.js";
+} from "./chunk-SKJK44YC.js";
 import {
   computeCostDetail,
   recordUsageEvent
-} from "./chunk-6ILEOLNW.js";
+} from "./chunk-UAK3OVSL.js";
 import {
   ConfigError,
   createLogger,
@@ -12,7 +12,7 @@ import {
   getErrorMessage,
   getTimeProvider,
   ok
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/config/opencode-bridge.ts
 import { readFileSync } from "fs";
@@ -194,4 +194,4 @@ export {
   discoverModels,
   buildOpenAICompatAdapters
 };
-//# sourceMappingURL=chunk-JYR6SBUB.js.map
+//# sourceMappingURL=chunk-K5NU57WE.js.map

package/dist/{chunk-GJSJRJ6Y.js → chunk-K7GAI4WP.js}

@@ -4,7 +4,7 @@ import {
   err,
   getErrorMessage,
   ok
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/scm/types.ts
 var ScmError = class extends Error {
@@ -263,4 +263,4 @@ export {
   ScmError,
   GitHubProvider
 };
-//# sourceMappingURL=chunk-GJSJRJ6Y.js.map
+//# sourceMappingURL=chunk-K7GAI4WP.js.map

package/dist/{chunk-EZHYOWWO.js → chunk-LJWB4Z7O.js}

@@ -3,7 +3,7 @@ import {
   MODEL_IDS,
   getTimeProvider,
   resolveModelIdentitySync
-} from "./chunk-WGDZFYP3.js";
+} from "./chunk-NDV5J3Z5.js";
 
 // src/config/model-availability.ts
 var DEFAULT_TTL_MS = 6e4;
@@ -150,4 +150,4 @@ export {
   resetAvailabilityCache,
   filterAvailableModels
 };
-//# sourceMappingURL=chunk-EZHYOWWO.js.map
+//# sourceMappingURL=chunk-LJWB4Z7O.js.map

package/dist/{chunk-WGDZFYP3.js → chunk-NDV5J3Z5.js}

@@ -1,8 +1,9 @@
 import {
   ensureLearningDir,
   getDecisionCostFile,
+  getModelSelectionShadowFile,
   isPersistenceEnabled
-} from "./chunk-NL7SZQPW.js";
+} from "./chunk-AXTD4TFK.js";
 import {
   nexusDataPath
 } from "./chunk-DHVMSIT5.js";
@@ -2612,7 +2613,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-XEA2GEOZ.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-GAGQ2VSX.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -9018,14 +9019,14 @@ function detectSuccessPatterns(groups, threshold) {
   const patterns = [];
   for (const g of groups) {
     const successCount = g.outcomes.filter((o) => o.success).length;
-    const successRate2 = successCount / g.outcomes.length;
-    if (successRate2 >= threshold) {
+    const successRate3 = successCount / g.outcomes.length;
+    if (successRate3 >= threshold) {
       patterns.push({
         cli: g.cli,
         category: g.category,
         patternType: "success-rate",
         action: "boost",
-        metric: successRate2,
+        metric: successRate3,
         observationCount: g.outcomes.length
       });
     }
@@ -9218,10 +9219,10 @@ var StrategyDistiller = class {
   }
   /** Convert rule metrics into ModelPerformance for RoutingMemory. */
   ruleToPerformance(rule) {
-    const successRate2 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
+    const successRate3 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
     return {
       avgQuality: rule.confidence,
-      successRate: Math.max(0, Math.min(1, successRate2)),
+      successRate: Math.max(0, Math.min(1, successRate3)),
       avgLatencyMs: 0,
       avgTokens: 0,
       observations: rule.observationCount
@@ -12419,9 +12420,9 @@ function getAdaptiveBonus(cli, category, config) {
   const cliName = cli;
   const outcomes = queryWithLookback(store, cliName, category, cfg);
   if (outcomes.length < cfg.coldStartThreshold) return 0;
-  const successRate2 = outcomes.filter((o) => o.success).length / outcomes.length;
+  const successRate3 = outcomes.filter((o) => o.success).length / outcomes.length;
   const FIXED_BASELINE = 0.7;
-  const delta = successRate2 - FIXED_BASELINE;
+  const delta = successRate3 - FIXED_BASELINE;
   const FULL_CONFIDENCE_SAMPLES2 = 50;
   const windowedConfidence = Math.min(1, outcomes.length / FULL_CONFIDENCE_SAMPLES2);
   const maxBonus = Math.min(cfg.maxBonusAdjustment * windowedConfidence, cfg.maxBonusAdjustment);
@@ -12696,17 +12697,17 @@ function buildExpertPerformance() {
     const successes = outcomes.filter((o) => o.success).length;
     const totalDuration = outcomes.reduce((s, o) => s + o.durationMs, 0);
     const dominantErrorPattern = findDominantError(outcomes.filter((o) => !o.success));
-    const successRate2 = successes / outcomes.length;
+    const successRate3 = successes / outcomes.length;
     const consecutiveFailures = countTrailingFailures(outcomes);
     const lastSuccess = [...outcomes].reverse().find((o) => o.success);
     const lastSuccessAt = lastSuccess !== void 0 ? new Date(lastSuccess.timestamp).toISOString() : void 0;
     entries.push({
       role,
       totalTasks: outcomes.length,
-      successRate: successRate2,
+      successRate: successRate3,
       avgDurationMs: Math.round(totalDuration / outcomes.length),
       consecutiveFailures,
-      degraded: successRate2 < 0.5,
+      degraded: successRate3 < 0.5,
       ...dominantErrorPattern !== void 0 ? { dominantErrorPattern } : {},
       ...lastSuccessAt !== void 0 ? { lastSuccessAt } : {}
     });
@@ -13686,6 +13687,169 @@ function resolveModelForTier(cliName, tier, opts = {}) {
   return scored[0]?.id ?? getDefaultModelForCli(cliName);
 }
 
+// src/cli-adapters/model-selection-shadow.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { z as z19 } from "zod";
+function isRouteModelShadowEnabled() {
+  return process.env["NEXUS_ROUTE_MODEL_SHADOW"] === "1" && isPersistenceEnabled();
+}
+var MODEL_SELECTION_SHADOW_SCHEMA_VERSION = 1;
+var READ_LOOKBACK_DAYS = 30;
+var READ_LOOKBACK_MS = READ_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3;
+var ModelTierSchema = z19.enum(["fast", "balanced", "powerful"]);
+var ModelSelectionShadowRecordSchema = z19.object({
+  schema: z19.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
+  /** ISO timestamp of the outcome join. */
+  timestamp: z19.string().min(1),
+  /** Display slot of the routed CLI (api:* arms collapse to their slot). */
+  cli: z19.string().min(1).max(40),
+  /** Difficulty tier the ZeroRouter computed for the task. */
+  tier: ModelTierSchema,
+  /** Model the live decision actually used (or the CLI default when route-time selection is off). */
+  actualModel: z19.string().min(1).max(120),
+  /** Model `resolveModelForTier` WOULD have picked (never executed). */
+  shadowModel: z19.string().min(1).max(120),
+  /** Whether shadow and actual agree. */
+  agree: z19.boolean(),
+  /** Whether the actually-executed decision succeeded. */
+  success: z19.boolean(),
+  /** Measured cost of the actual execution, when available (unmeasured today on the routing path). */
+  costUsd: z19.number().nonnegative().optional()
+});
+function computeModelSelectionShadow(cli, tier, actualModel) {
+  const shadowModel = resolveModelForTier(cli, tier);
+  const actual = actualModel ?? getDefaultModelForCli(cli);
+  return { cli, tier, actualModel: actual, shadowModel, agree: shadowModel === actual };
+}
+var shadowFailureCount = 0;
+function recordModelSelectionShadowFailure() {
+  return ++shadowFailureCount;
+}
+var persistLogger = createLogger({ component: "ModelSelectionShadow" });
+function persistModelSelectionShadowRecord(record) {
+  try {
+    ensureLearningDir();
+    appendFileSync2(getModelSelectionShadowFile(), JSON.stringify(record) + "\n", "utf-8");
+  } catch (err2) {
+    recordModelSelectionShadowFailure();
+    persistLogger.warn("Failed to persist model-selection shadow record (ignored)", {
+      error: getErrorMessage(err2)
+    });
+  }
+}
+function readModelSelectionShadowRecords() {
+  const file = getModelSelectionShadowFile();
+  if (!existsSync7(file)) return [];
+  const records = [];
+  try {
+    const cutoff = Date.now() - READ_LOOKBACK_MS;
+    const lines = readFileSync6(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const result = ModelSelectionShadowRecordSchema.safeParse(parsed);
+      if (!result.success) continue;
+      const ts = Date.parse(result.data.timestamp);
+      if (Number.isNaN(ts) || ts < cutoff) continue;
+      records.push(result.data);
+    }
+  } catch (err2) {
+    persistLogger.warn("Failed to read model-selection shadow records (ignored)", {
+      error: getErrorMessage(err2)
+    });
+  }
+  return records;
+}
+
+// src/cli-adapters/model-selection-readiness.ts
+var DEFAULT_MODEL_SELECTION_READINESS_CONFIG = {
+  minDivergingDecisions: 50,
+  minSuccessDelta: 0.05,
+  minCostSamples: 10
+};
+function successRate2(t) {
+  return t.count === 0 ? 0 : t.successes / t.count;
+}
+function summarizeModelSelectionShadow(records) {
+  const agree = { count: 0, successes: 0 };
+  const diverge = { count: 0, successes: 0 };
+  let costSamples = 0;
+  let costTotal = 0;
+  for (const r of records) {
+    const cohort = r.agree ? agree : diverge;
+    cohort.count++;
+    if (r.success) cohort.successes++;
+    if (r.costUsd !== void 0) {
+      costSamples++;
+      costTotal += r.costUsd;
+    }
+  }
+  const agreeSuccessRate = successRate2(agree);
+  const divergeSuccessRate = successRate2(diverge);
+  const successDelta = agree.count === 0 || diverge.count === 0 ? 0 : agreeSuccessRate - divergeSuccessRate;
+  return {
+    total: records.length,
+    agreeing: agree.count,
+    diverging: diverge.count,
+    agreeSuccessRate,
+    divergeSuccessRate,
+    successDelta,
+    costSamples,
+    meanCostUsd: costSamples === 0 ? 0 : costTotal / costSamples
+  };
+}
+function evaluateModelSelectionReadiness(records, config = DEFAULT_MODEL_SELECTION_READINESS_CONFIG) {
+  const s = summarizeModelSelectionShadow(records);
+  const criteria = [
+    {
+      name: "volume",
+      met: s.diverging >= config.minDivergingDecisions,
+      detail: `${String(s.diverging)} shadow-diverging decisions (need \u2265 ${String(config.minDivergingDecisions)})`
+    },
+    {
+      name: "success-delta",
+      met: s.successDelta >= config.minSuccessDelta,
+      detail: `agree\u2212diverge success delta ${s.successDelta.toFixed(2)} (agree ${s.agreeSuccessRate.toFixed(2)} over ${String(s.agreeing)}, diverge ${s.divergeSuccessRate.toFixed(2)} over ${String(s.diverging)}; need \u2265 ${config.minSuccessDelta.toFixed(2)})`
+    },
+    {
+      name: "cost-measured",
+      met: s.costSamples >= config.minCostSamples,
+      detail: `${String(s.costSamples)} decisions with measured costUsd, mean $${s.meanCostUsd.toFixed(4)} (need \u2265 ${String(config.minCostSamples)})`
+    }
+  ];
+  const blockers = criteria.filter((c) => !c.met).map((c) => c.name);
+  return { ready: blockers.length === 0, criteria, blockers };
+}
+var readinessLogged = false;
+function logModelSelectionReadinessOnce(logger14) {
+  if (readinessLogged) return;
+  readinessLogged = true;
+  try {
+    const records = readModelSelectionShadowRecords();
+    const summary = summarizeModelSelectionShadow(records);
+    const verdict = evaluateModelSelectionReadiness(records);
+    logger14.info("route-model-selection shadow readiness", {
+      ready: verdict.ready,
+      blockers: verdict.blockers,
+      total: summary.total,
+      diverging: summary.diverging,
+      successDelta: summary.successDelta,
+      agreeSuccessRate: summary.agreeSuccessRate,
+      divergeSuccessRate: summary.divergeSuccessRate,
+      costSamples: summary.costSamples,
+      meanCostUsd: summary.meanCostUsd
+    });
+  } catch (err2) {
+    logger14.warn("route-model-selection readiness signal failed (non-fatal)", {
+      error: getErrorMessage(err2)
+    });
+  }
+}
+
 // src/cli-adapters/composite-router-outcome.ts
 var sharedAnalyzer3 = createSharedTaskAnalyzer();
 function recordBanditOutcome(cliName, task, reward, deps) {
@@ -13894,6 +14058,13 @@ var CompositeRouter = class _CompositeRouter {
   lastRoutedTask;
   // Track last traceId for metrics correlation (Issue #559)
   lastTraceId;
+  /**
+   * Pending model-selection shadow comparison awaiting its outcome join
+   * (#4197). Keyed by task content like {@link lastRoutedTask}; persisted with
+   * `success` when `recordDifficultyOutcome` reports the matching outcome.
+   * The task content itself is never persisted.
+   */
+  pendingModelShadow;
   constructor(adapters, config, logger14) {
     const {
       preferenceRouterConfig,
@@ -14078,7 +14249,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-YGPEAEPO.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-W6Z6JNEF.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -14202,12 +14373,16 @@ var CompositeRouter = class _CompositeRouter {
         return pipelineResult;
       }
       this.trackLastRoutedTask(task, pipelineResult.value);
-      return this.buildRoutingDecision({
+      const decisionResult = this.buildRoutingDecision({
         ...pipelineResult.value,
         taskProfile,
         stagesExecuted,
         startTime
       });
+      if (decisionResult.ok) {
+        this.trackModelSelectionShadow(task, decisionResult.value);
+      }
+      return decisionResult;
     } catch (error) {
       return this.handleRoutingError(error, stagesExecuted);
     }
@@ -14293,6 +14468,80 @@ var CompositeRouter = class _CompositeRouter {
       };
     }
   }
+  /**
+   * Compute the model-selection SHADOW comparison for a routed decision
+   * (#4197): what `resolveModelForTier` WOULD have picked vs the model the
+   * decision actually carries (or the CLI default the adapter will resolve).
+   * Held pending until `recordDifficultyOutcome` supplies the outcome, then
+   * persisted to the dedicated shadow log. Gated behind
+   * `NEXUS_ROUTE_MODEL_SHADOW=1` (default OFF). NEVER affects the live
+   * decision — any failure increments the shadow-failure counter and is
+   * logged, not thrown into the routing path.
+   *
+   * Tasks with a PINNED model (`CliTask.model`) are SKIPPED entirely: the
+   * adapter executes the pinned model (base-adapter), not the CLI default the
+   * comparison would otherwise assume, so a pinned run says nothing about the
+   * tier selector — sampling it would mislabel the agree/diverge cohorts and
+   * pad the volume criterion with garbage (#4218 review).
+   */
+  trackModelSelectionShadow(task, decision) {
+    try {
+      if (!isRouteModelShadowEnabled() || decision.difficultyTier === void 0) return;
+      if (task.model !== void 0) return;
+      logModelSelectionReadinessOnce(this.logger);
+      const comparison = computeModelSelectionShadow(
+        routingArmDisplaySlot(decision.cliName),
+        decision.difficultyTier,
+        decision.model
+      );
+      this.pendingModelShadow = { ...comparison, taskContent: task.content };
+      this.logger.debug("Model-selection shadow computed (#4197)", {
+        cli: comparison.cli,
+        tier: comparison.tier,
+        actualModel: comparison.actualModel,
+        shadowModel: comparison.shadowModel,
+        agree: comparison.agree
+      });
+    } catch (error) {
+      const failures = recordModelSelectionShadowFailure();
+      this.logger.warn("Model-selection shadow failed (non-fatal, #4197)", {
+        error: getErrorMessage(error),
+        failures
+      });
+    }
+  }
+  /**
+   * Join a pending model-selection shadow comparison with its task outcome and
+   * persist the completed record (#4197). Matches by task content, mirroring
+   * {@link getDifficultyInfo}'s lastRoutedTask join. `costUsd` is deliberately
+   * absent: the routing outcome path measures no per-decision cost today, and
+   * the readiness gate's cost criterion stays fail-closed until it does.
+   * Exception-guarded — an outcome-join failure never breaks outcome recording.
+   */
+  joinModelSelectionShadowOutcome(task, success) {
+    const pending = this.pendingModelShadow;
+    if (pending === void 0) return;
+    if (pending.taskContent !== task.content) return;
+    this.pendingModelShadow = void 0;
+    try {
+      persistModelSelectionShadowRecord({
+        schema: MODEL_SELECTION_SHADOW_SCHEMA_VERSION,
+        timestamp: new Date(getTimeProvider().now()).toISOString(),
+        cli: pending.cli,
+        tier: pending.tier,
+        actualModel: pending.actualModel,
+        shadowModel: pending.shadowModel,
+        agree: pending.agree,
+        success
+      });
+    } catch (error) {
+      const failures = recordModelSelectionShadowFailure();
+      this.logger.warn("Model-selection shadow outcome join failed (non-fatal, #4197)", {
+        error: getErrorMessage(error),
+        failures
+      });
+    }
+  }
   buildRoutingDecision(params) {
     const selectedAdapter = this.adapters.get(params.selectedCli);
     if (selectedAdapter === void 0) {
@@ -14373,6 +14622,7 @@ var CompositeRouter = class _CompositeRouter {
   }
   recordDifficultyOutcome(task, success, qualityScore) {
     recordZeroRouterOutcome(task, success, qualityScore, this.getOutcomeDependencies());
+    this.joinModelSelectionShadowOutcome(task, success);
   }
   hasMinimumPreferenceData() {
     return hasMinimumPreferenceData(this.getOutcomeDependencies());
@@ -14503,7 +14753,7 @@ import { dirname as dirname5 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 
 // src/context/mobimem-types.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var DEFAULT_MOBIMEM_CONFIG = {
   dbPath: ":memory:",
   maxProfileEntries: 100,
@@ -14515,15 +14765,15 @@ var DEFAULT_MOBIMEM_CONFIG = {
   minExperienceSuccessRate: 0.7,
   autoEviction: true
 };
-var MobiMemConfigSchema = z19.object({
-  dbPath: z19.string(),
-  maxProfileEntries: z19.number().int().positive().default(100),
-  maxExperiencePatterns: z19.number().int().positive().default(500),
-  maxActionCacheEntries: z19.number().int().positive().default(1e3),
-  actionCacheTtlMs: z19.number().int().positive().default(36e5),
-  minProfileConfidence: z19.number().min(0).max(1).default(0.6),
-  minExperienceSuccessRate: z19.number().min(0).max(1).default(0.7),
-  autoEviction: z19.boolean().default(true)
+var MobiMemConfigSchema = z20.object({
+  dbPath: z20.string(),
+  maxProfileEntries: z20.number().int().positive().default(100),
+  maxExperiencePatterns: z20.number().int().positive().default(500),
+  maxActionCacheEntries: z20.number().int().positive().default(1e3),
+  actionCacheTtlMs: z20.number().int().positive().default(36e5),
+  minProfileConfidence: z20.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z20.number().min(0).max(1).default(0.7),
+  autoEviction: z20.boolean().default(true)
 });
 
 // src/context/mobimem-impl.ts
@@ -14543,9 +14793,9 @@ function generatePatternKey(taskType, actionSequence, contextSignature) {
 function hashInput(input) {
   return createHash2("sha256").update(JSON.stringify(input)).digest("hex");
 }
-function calculatePatternScore(successRate2, contextMatches, attemptCount) {
+function calculatePatternScore(successRate3, contextMatches, attemptCount) {
   const contextMatch = contextMatches ? 1 : 0.5;
-  return successRate2 * contextMatch * Math.log10(attemptCount + 1);
+  return successRate3 * contextMatch * Math.log10(attemptCount + 1);
 }
 function computeSuccessRate(successCount, attemptCount) {
   return attemptCount > 0 ? successCount / attemptCount : 0;
@@ -15588,4 +15838,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-WGDZFYP3.js.map
+//# sourceMappingURL=chunk-NDV5J3Z5.js.map