@yugenlab/vaayu 0.1.0 → 0.1.2

package/gateway.js

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
-import {
-  SqliteStorage
-} from "./chunks/chunk-SMVJRPAH.js";
-import "./chunks/chunk-MINFB5LT.js";
-import "./chunks/chunk-IIET2K6D.js";
-import "./chunks/chunk-H76V36OF.js";
-import "./chunks/chunk-HAPVUJ6A.js";
-import "./chunks/chunk-URGEODS5.js";
-import "./chunks/chunk-YSU3BWV6.js";
-import "./chunks/chunk-IEKAYVA3.js";
 import {
   buildAgentTree,
   buildKaalaHealthNode
 } from "./chunks/chunk-G5VYCA6O.js";
+import {
+  SqliteStorage
+} from "./chunks/chunk-PRXQW76U.js";
+import "./chunks/chunk-C76USAC5.js";
+import "./chunks/chunk-5Z2BKSFF.js";
+import "./chunks/chunk-F4T7POKM.js";
+import "./chunks/chunk-FPNQLJLD.js";
+import "./chunks/chunk-XRHUKKBC.js";
+import "./chunks/chunk-DQMAQ2VL.js";
+import "./chunks/chunk-OWBBY5XP.js";
+import "./chunks/chunk-IEKAYVA3.js";
 import {
   IMessageAdapter,
   TelegramAdapter,
@@ -22,13 +23,13 @@ import {
   require_lib,
   validateMantra
 } from "./chunks/chunk-MJ74G5RB.js";
-import "./chunks/chunk-S4TBVCL2.js";
-import "./chunks/chunk-JZU37VQ5.js";
+import "./chunks/chunk-SLA2OIMG.js";
+import "./chunks/chunk-F35MWELH.js";
 import "./chunks/chunk-JAWZ7ANC.js";
-import "./chunks/chunk-KDRROLVN.js";
+import "./chunks/chunk-NBXCXQ3H.js";
 import {
   searchSessions
-} from "./chunks/chunk-ITIVYGUG.js";
+} from "./chunks/chunk-UW6E7IC4.js";
 import "./chunks/chunk-E5A3SCDJ.js";
 import {
   addTurn,
@@ -39,8 +40,9 @@ import {
   listTurnsWithTimestamps,
   loadSession,
   updateSessionMeta
-} from "./chunks/chunk-L7JICQBW.js";
-import "./chunks/chunk-U6OLJ36B.js";
+} from "./chunks/chunk-2ARPXEDC.js";
+import "./chunks/chunk-YJRXLRTE.js";
+import "./chunks/chunk-UQLPHNGH.js";
 import "./chunks/chunk-KC6NRZ7U.js";
 import {
   __commonJS,
@@ -11313,7 +11315,7 @@ var require_websocket_server = __commonJS({
 });
 
 // apps/gateway/dist/agent/loop.js
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 
 // packages/guardian/src/guardian.js
 import * as crypto3 from "node:crypto";
@@ -12953,7 +12955,7 @@ async function appendAssistantEvent(storage, sessionId, content, metadata, sourc
   return event;
 }
 function buildEarlyResult(session, model, content, routingDecision, routingResult) {
-  const includeRouting = Boolean(routingDecision || routingResult.budget?.applied || routingResult.deterministicTrace || routingResult.retrievalGate);
+  const includeRouting = Boolean(routingDecision || routingResult.budget?.applied || routingResult.deterministicTrace || routingResult.retrievalGate || routingResult.scoring || routingResult.providerResolution || routingResult.smalltalkFastLane || routingResult.escalation || routingResult.policyClassifier || routingResult.semanticCache || routingResult.activeToolDiscovery);
   const normalized = normalizeAgentReply(content);
   return {
     session,
@@ -13098,7 +13100,7 @@ async function resolveSessionRoute(params) {
 }
 
 // apps/gateway/dist/agent/loop-execute.js
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 
 // apps/gateway/dist/model-catalog.js
 var FREE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
@@ -15853,8 +15855,8 @@ function createRegistry(config) {
     defaultId: config.default,
     policy: config.policy
   });
-  const entries = config.entries ?? {};
-  for (const [id, providerConfig] of Object.entries(entries)) {
+  const entries2 = config.entries ?? {};
+  for (const [id, providerConfig] of Object.entries(entries2)) {
     const provider = createProvider(id, providerConfig);
     registry.register(provider, {
       mode: providerModeFor(providerConfig.type)
@@ -19720,8 +19722,8 @@ function slugifySkillName(name) {
 function copyDir(src, dest) {
   if (!fs8.existsSync(src)) return;
   fs8.mkdirSync(dest, { recursive: true });
-  const entries = fs8.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
+  const entries2 = fs8.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries2) {
     const from = path8.join(src, entry.name);
     const to = path8.join(dest, entry.name);
     if (entry.isDirectory()) {
@@ -23152,9 +23154,9 @@ function buildSkillUpdateTools(dataDir) {
             error: { code: "invalid_registry", message: error instanceof Error ? error.message : String(error) }
           };
         }
-        const entries = Array.isArray(registry.skills) ? registry.skills : [];
+        const entries2 = Array.isArray(registry.skills) ? registry.skills : [];
         const targetId = payload?.id?.trim();
-        const selected = targetId ? entries.filter((e) => e.id === targetId) : entries;
+        const selected = targetId ? entries2.filter((e) => e.id === targetId) : entries2;
         if (!selected.length) {
           return { ok: false, error: { code: "missing_skill", message: "No registry entry found." } };
         }
@@ -23440,13 +23442,13 @@ function collectSkillScanFiles(rootDir) {
   while (queue.length) {
     const dir = queue.shift();
     if (!dir) continue;
-    let entries;
+    let entries2;
     try {
-      entries = fs15.readdirSync(dir, { withFileTypes: true });
+      entries2 = fs15.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
-    for (const entry of entries) {
+    for (const entry of entries2) {
       if (entry.name.startsWith(".")) continue;
       const full = path15.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -25675,6 +25677,9 @@ Use /onboard to see your full setup status.`;
   return null;
 }
 
+// apps/gateway/dist/agent/quick-responses.js
+import { randomUUID as randomUUID6 } from "node:crypto";
+
 // apps/gateway/dist/runtime/continuity-prompt.js
 var DEFAULT_LOOKBACK_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_PROMPT_TTL_MS = 30 * 60 * 1e3;
@@ -26122,12 +26127,64 @@ async function handleQuickResponses(params) {
     }, message);
     return buildEarlyResult(session, model, reply, routingDecision, routingResult);
   };
-  const emitSmalltalk = async (kind) => emitLocal(kind === "greeting" ? "smalltalk.greeting" : "smalltalk.ack", buildSmalltalkReply2(profile, kind, message.channel, locale));
-  const emitIdentity = async () => emitLocal("smalltalk.identity", buildIdentityReply({
-    assistantName: profile.assistantName?.trim() || "Vaayu",
-    locale
-  }));
+  const emitSmalltalkFastLane = async (params2) => {
+    routingResult.smalltalkFastLane = {
+      matched: params2.matched,
+      mode: params2.mode,
+      intent: params2.intent,
+      confidence: params2.confidence,
+      threshold: params2.threshold,
+      metric: params2.matched ? "smalltalk.fast_lane.hit" : "smalltalk.fast_lane.miss"
+    };
+    try {
+      await storage.appendAudit?.({
+        id: randomUUID6(),
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        type: routingResult.smalltalkFastLane.metric,
+        payload: {
+          sessionId: session.id,
+          locale,
+          mode: params2.mode,
+          intent: params2.intent,
+          confidence: params2.confidence,
+          threshold: params2.threshold,
+          matched: params2.matched
+        }
+      });
+    } catch {
+    }
+  };
+  const emitSmalltalk = async (kind) => {
+    await emitSmalltalkFastLane({
+      matched: true,
+      mode: kind === "greeting" ? "greeting_rule" : "ack_rule",
+      intent: kind === "greeting" ? "smalltalk.greeting" : "smalltalk.ack",
+      confidence: 1,
+      threshold: 1
+    });
+    return emitLocal(kind === "greeting" ? "smalltalk.greeting" : "smalltalk.ack", buildSmalltalkReply2(profile, kind, message.channel, locale));
+  };
+  const emitIdentity = async () => {
+    await emitSmalltalkFastLane({
+      matched: true,
+      mode: "identity_rule",
+      intent: "smalltalk.identity",
+      confidence: 1,
+      threshold: 1
+    });
+    return emitLocal("smalltalk.identity", buildIdentityReply({
+      assistantName: profile.assistantName?.trim() || "Vaayu",
+      locale
+    }));
+  };
   if (SMALLTALK_CHECKIN_RE.test(trimmed)) {
+    await emitSmalltalkFastLane({
+      matched: true,
+      mode: "checkin_rule",
+      intent: "smalltalk.checkin",
+      confidence: 1,
+      threshold: 1
+    });
     return emitLocal("smalltalk.checkin", buildCheckinReply({
       assistantName: profile.assistantName?.trim() || "Vaayu",
       locale
@@ -26140,6 +26197,13 @@ async function handleQuickResponses(params) {
     return emitSmalltalk("ack");
   }
   if (SMALLTALK_JOKE_RE.test(trimmed)) {
+    await emitSmalltalkFastLane({
+      matched: true,
+      mode: "joke_rule",
+      intent: "smalltalk.joke",
+      confidence: 1,
+      threshold: 1
+    });
     return emitLocal("smalltalk.joke", buildJokeReply(locale));
   }
   if (SMALLTALK_IDENTITY_RE.test(trimmed)) {
@@ -26168,10 +26232,33 @@ async function handleQuickResponses(params) {
       });
       const confidence = normalizeConfidence(interpreted?.confidence);
       if (interpreted?.intent === "smalltalk.greeting" && confidence >= SEMANTIC_SMALLTALK_CONFIDENCE) {
-        return emitSmalltalk("greeting");
+        await emitSmalltalkFastLane({
+          matched: true,
+          mode: "semantic_greeting",
+          intent: interpreted.intent,
+          confidence,
+          threshold: SEMANTIC_SMALLTALK_CONFIDENCE
+        });
+        return emitLocal("smalltalk.greeting", buildSmalltalkReply2(profile, "greeting", message.channel, locale));
       }
       if (interpreted?.intent === "smalltalk.ack" && confidence >= SEMANTIC_SMALLTALK_CONFIDENCE) {
-        return emitSmalltalk("ack");
+        await emitSmalltalkFastLane({
+          matched: true,
+          mode: "semantic_ack",
+          intent: interpreted.intent,
+          confidence,
+          threshold: SEMANTIC_SMALLTALK_CONFIDENCE
+        });
+        return emitLocal("smalltalk.ack", buildSmalltalkReply2(profile, "ack", message.channel, locale));
+      }
+      if (interpreted?.intent === "smalltalk.greeting" || interpreted?.intent === "smalltalk.ack") {
+        await emitSmalltalkFastLane({
+          matched: false,
+          mode: interpreted.intent === "smalltalk.greeting" ? "semantic_greeting" : "semantic_ack",
+          intent: interpreted.intent,
+          confidence,
+          threshold: SEMANTIC_SMALLTALK_CONFIDENCE
+        });
       }
     } catch {
     }
@@ -26272,7 +26359,7 @@ ${cross.summary}` : `Here\u2019s what we were discussing${deviceLabel}: ${cross.
 }
 
 // apps/gateway/dist/agent/intents/free-text.js
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 // apps/gateway/dist/runtime/text-smalltalk.js
 var WEATHER_TERMS = [
@@ -27670,7 +27757,7 @@ async function handleFreeTextIntents(params) {
         await storage.clearSessionPrefs(session.id);
         const updated = await storage.setSessionPrefs(session.id, { autoRouting: true });
         await storage.appendAudit({
-          id: randomUUID6(),
+          id: randomUUID7(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: {
@@ -27698,7 +27785,7 @@ async function handleFreeTextIntents(params) {
           autoRouting: false
         });
         await storage.appendAudit({
-          id: randomUUID6(),
+          id: randomUUID7(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: {
@@ -27734,7 +27821,7 @@ async function handleFreeTextIntents(params) {
           autoRouting: false
         });
         await storage.appendAudit({
-          id: randomUUID6(),
+          id: randomUUID7(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: {
@@ -27773,7 +27860,7 @@ async function handleFreeTextIntents(params) {
           autoRouting: false
         });
         await storage.appendAudit({
-          id: randomUUID6(),
+          id: randomUUID7(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: {
@@ -27892,7 +27979,7 @@ var LOG_LEVELS = ["debug", "info", "warn", "error"];
 var REDACTED2 = "[REDACTED]";
 var MAX_DEPTH = 6;
 var SENSITIVE_KEY_RE = /(token|api[_-]?key|authorization|x-api-key|secret|password|cookie|set-cookie|bearer)/i;
-var TOKEN_LIKE_RE = /(sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/g;
+var TOKEN_LIKE_RE = /(sk-[A-Za-z0-9]{20,}|sk-ant-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|GOCSPX-[A-Za-z0-9_-]{20,}|AIza[0-9A-Za-z_-]{30,}|AKIA[0-9A-Z]{16}|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/g;
 var BEARER_RE = /Bearer\s+[A-Za-z0-9._-]+/g;
 var PRETTY_ALLOWED = /* @__PURE__ */ new Set(["json", "pretty"]);
 var PRETTY_LEVEL_COLOR = {
@@ -28190,13 +28277,13 @@ function detectMissingCapability(toolName, error) {
 }
 
 // apps/gateway/dist/agent/tool-runner.js
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // apps/gateway/dist/agent/tool-executor.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 
 // apps/gateway/dist/agent/tool-scribe.js
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // apps/gateway/dist/agent/scribe.js
 function shouldScribeToolReply(toolName) {
@@ -28302,7 +28389,7 @@ ${scribeUserPayload}`));
     if (response.usage && params.storage?.appendTokenUsage && params.sessionId) {
       try {
         await params.storage.appendTokenUsage({
-          id: randomUUID7(),
+          id: randomUUID8(),
           sessionId: params.sessionId,
           providerId: provider.id,
           model: response.model ?? finalModel,
@@ -28355,7 +28442,7 @@ async function emitAnrivaRecord(storage, params) {
   const endTime = Date.now();
   const outputStr = params.output != null ? JSON.stringify(params.output).slice(0, 200) : void 0;
   const record = {
-    id: randomUUID8(),
+    id: randomUUID9(),
     tool: params.toolName,
     anrivaUri: `anriva://${params.provider}/${params.service}/${params.action}`,
     user: params.userId,
@@ -28414,7 +28501,7 @@ async function executeTool(params) {
       }
     });
     await storage.appendAudit({
-      id: randomUUID8(),
+      id: randomUUID9(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "guardian.block",
       payload: {
@@ -28501,7 +28588,7 @@ async function executeTool(params) {
       reason: synthesized ? "tool.synth" : "tool"
     });
     await storage.appendAudit({
-      id: randomUUID8(),
+      id: randomUUID9(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "agent.run.tool",
       payload: {
@@ -28581,7 +28668,7 @@ async function executeTool(params) {
     }
     const content = renderToolFailure2(toolName, result, message.channel, toolInput);
     await storage.appendAudit({
-      id: randomUUID8(),
+      id: randomUUID9(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "agent.run.tool",
       payload: {
@@ -29380,6 +29467,115 @@ function prepareToolInput(params) {
   return { toolInput };
 }
 
+// apps/gateway/dist/router-backlog/active-tool-discovery.js
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "for",
+  "to",
+  "in",
+  "on",
+  "of",
+  "and",
+  "or",
+  "my",
+  "please",
+  "show",
+  "get",
+  "run",
+  "use",
+  "tool"
+]);
+function clamp01(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function normalizeText2(input) {
+  return input.toLowerCase().replace(/[^a-z0-9.\s_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize2(input) {
+  return normalizeText2(input).split(/[\s._-]+/).map((token) => token.trim()).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+function overlapScore(queryTokens, candidateTokens) {
+  if (!queryTokens.length || !candidateTokens.length)
+    return 0;
+  const candidateSet = new Set(candidateTokens);
+  let hits = 0;
+  for (const token of queryTokens) {
+    if (candidateSet.has(token))
+      hits += 1;
+  }
+  return hits / queryTokens.length;
+}
+function buildCandidateTokens(tool) {
+  return [tool.name, tool.description ?? "", ...tool.aliases ?? [], ...tool.tags ?? []].flatMap((part) => tokenize2(part)).filter(Boolean);
+}
+function recommendedBoost(recommended, toolName) {
+  const index = recommended.findIndex((name) => name === toolName);
+  if (index < 0)
+    return 0;
+  if (index === 0)
+    return 0.25;
+  if (index === 1)
+    return 0.18;
+  if (index === 2)
+    return 0.12;
+  return 0.08;
+}
+function buildActiveToolDiscoveryPlan(params) {
+  const query = normalizeText2(params.query ?? "");
+  const queryTokens = tokenize2(query);
+  const recommended = (params.recommendedTools ?? []).map((name) => normalizeText2(name));
+  const minScore = Number.isFinite(params.minScore) ? Number(params.minScore) : 0.2;
+  const maxCandidates = Number.isFinite(params.maxCandidates) ? Math.max(1, Math.floor(Number(params.maxCandidates))) : 5;
+  const candidates = [];
+  for (const tool of params.tools) {
+    const reasons = [];
+    const normalizedName = normalizeText2(tool.name);
+    const aliases = (tool.aliases ?? []).map((alias) => normalizeText2(alias));
+    let score = 0;
+    if (normalizedName === query || aliases.includes(query)) {
+      score = 1;
+      reasons.push(normalizedName === query ? "exact_name" : "exact_alias");
+    } else if (query && (normalizedName.includes(query) || aliases.some((alias) => alias.includes(query)))) {
+      score = Math.max(score, 0.86);
+      reasons.push("substring_match");
+    }
+    const tokenScore = overlapScore(queryTokens, buildCandidateTokens(tool));
+    if (tokenScore > 0) {
+      score = Math.max(score, 0.35 + tokenScore * 0.45);
+      reasons.push("token_overlap");
+    }
+    const boost = recommendedBoost(recommended, normalizedName);
+    if (boost > 0) {
+      score += boost;
+      reasons.push("recommended_boost");
+    }
+    const finalScore = clamp01(score);
+    if (finalScore >= minScore) {
+      candidates.push({
+        name: tool.name,
+        score: finalScore,
+        reasons
+      });
+    }
+  }
+  candidates.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return a.name.localeCompare(b.name);
+  });
+  const limited = candidates.slice(0, maxCandidates);
+  const mode = limited.length === 0 ? "capability_gap" : (limited[0]?.score ?? 0) >= 0.95 ? "deterministic_match" : "active_discovery";
+  return {
+    query,
+    mode,
+    candidates: limited
+  };
+}
+
 // apps/gateway/dist/agent/tool-runner.js
 function isWeatherIntent(intent) {
   return typeof intent === "string" && intent.startsWith("weather.");
@@ -29676,6 +29872,43 @@ async function handleToolPlanning(params) {
     "memory.consolidate",
     "memory.link"
   ].includes(tool2.name));
+  const maybeRecordActiveToolDiscovery = async () => {
+    if (routingResult.actionability?.kind !== "tool")
+      return;
+    let recommendedTools;
+    try {
+      recommendedTools = chitraguptaBridge?.recommend(normalized.norm);
+    } catch {
+      recommendedTools = void 0;
+    }
+    const discoveryPlan = buildActiveToolDiscoveryPlan({
+      query: normalized.norm,
+      tools: allowedTools.map((tool2) => ({
+        name: tool2.name,
+        description: tool2.description,
+        aliases: tool2.aliases,
+        tags: tool2.tags
+      })),
+      recommendedTools
+    });
+    if (discoveryPlan.mode === "deterministic_match")
+      return;
+    routingResult.activeToolDiscovery = discoveryPlan;
+    try {
+      await storage.appendAudit?.({
+        id: randomUUID10(),
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "agent.run.tool.discovery",
+        payload: {
+          sessionId: session.id,
+          query: discoveryPlan.query,
+          mode: discoveryPlan.mode,
+          candidates: discoveryPlan.candidates
+        }
+      });
+    } catch {
+    }
+  };
   let plan = forcedIntentPlan ?? explicitToolNamePlan ?? deterministicNluPlan ?? deterministicIntentFallbackPlan ?? failoverNluHintPlan;
   let plannerProviderId = null;
   let plannerModel = null;
@@ -29695,8 +29928,10 @@ async function handleToolPlanning(params) {
       if (!plan) {
         plan = deterministicIntentFallbackPlan;
       }
-      if (!plan)
+      if (!plan) {
+        await maybeRecordActiveToolDiscovery();
         return null;
+      }
     }
     if (!plan) {
       const plannerAttempts = [];
@@ -29788,7 +30023,7 @@ async function handleToolPlanning(params) {
           if (plannerResult.usage && storage.appendTokenUsage) {
             try {
               await storage.appendTokenUsage({
-                id: randomUUID9(),
+                id: randomUUID10(),
                 sessionId: session.id,
                 providerId: attemptProvider.id,
                 model: plannerResult.model ?? attempt.model,
@@ -29835,6 +30070,7 @@ async function handleToolPlanning(params) {
     plan = forcedIntentPlan ?? explicitToolNamePlan ?? deterministicNluPlan ?? deterministicIntentFallbackPlan ?? failoverNluHintPlan;
   }
   if (plan?.action !== "tool" || !plan.tool) {
+    await maybeRecordActiveToolDiscovery();
     return null;
   }
   applyDeterministicTrace({
@@ -29850,7 +30086,7 @@ async function handleToolPlanning(params) {
   if (routingResult.deterministicTrace) {
     try {
       await storage.appendAudit?.({
-        id: randomUUID9(),
+        id: randomUUID10(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "agent.run.route",
         payload: {
@@ -29918,7 +30154,7 @@ ${t(locale, "approval.pending", {
       }
     });
     await storage.appendAudit({
-      id: randomUUID9(),
+      id: randomUUID10(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.policy_ephemeral_allow",
       payload: {
@@ -30476,6 +30712,16 @@ var MIN_CHAT_MAX_ATTEMPTS = 1;
 var MAX_CHAT_MAX_ATTEMPTS = 10;
 var LOCAL_PROVIDER_TYPES2 = /* @__PURE__ */ new Set(["ollama", "mock"]);
 var CLI_PROVIDER_TYPES2 = /* @__PURE__ */ new Set(["codex-cli", "claude-code", "copilot"]);
+function isAbortLikeError(error) {
+  if (!error)
+    return false;
+  if (error instanceof DOMException && error.name === "AbortError")
+    return true;
+  if (error instanceof Error) {
+    return /abort/i.test(error.name) || /abort|aborted/i.test(error.message);
+  }
+  return false;
+}
 function resolveChatAttemptTimeoutMs(config, providerId) {
   const routingTimeoutRaw = config.routing?.chatTimeoutMs;
   const routingTimeoutMs = typeof routingTimeoutRaw === "number" && Number.isFinite(routingTimeoutRaw) ? routingTimeoutRaw : DEFAULT_CHAT_ATTEMPT_TIMEOUT_MS;
@@ -30583,13 +30829,24 @@ async function runChatWithFallback(params) {
     });
   }
   if (attempts.length === 0) {
-    return { ok: false, error: new Error("Provider not found") };
+    return {
+      ok: false,
+      error: new Error("Provider not found"),
+      escalation: {
+        policy: "provider_error",
+        reason: "no_healthy_provider",
+        retryable: true,
+        responseModel: "provider.failure"
+      }
+    };
   }
   let response;
   let lastError;
   let providerUsed;
   let modelUsed;
   let fallbackUsed = false;
+  let skippedCooldownCount = 0;
+  let attemptedProviderCount = 0;
   const lastAnthropicCall = lastAnthropicCallAt.get(sessionId);
   for (const attempt of attempts) {
     const provider = getProvider(attempt.providerId);
@@ -30616,6 +30873,7 @@ async function runChatWithFallback(params) {
           until: new Date(cooldown.until).toISOString(),
           failures: cooldown.failures
         });
+        skippedCooldownCount += 1;
         lastError = new Error(`Provider ${attempt.providerId} cooling down (${cooldown.reason})`);
         continue;
       }
@@ -30631,6 +30889,7 @@ async function runChatWithFallback(params) {
       lastError = new Error(`Provider ${attempt.providerId} unavailable (${health.status ?? "unknown"})`);
       continue;
     }
+    attemptedProviderCount += 1;
     try {
       if (!pruningApplied && shouldPruneContext({
         config: pruningConfig,
@@ -30717,6 +30976,10 @@ async function runChatWithFallback(params) {
       }
       break;
     } catch (error) {
+      if (signal?.aborted) {
+        lastError = error;
+        break;
+      }
       const cooldown2 = registerProviderFailure(attempt.providerId, error, provider.type);
       logger.warn("provider_cooldown_set", {
         providerId: attempt.providerId,
@@ -30729,19 +30992,58 @@ async function runChatWithFallback(params) {
     }
   }
   if (!response || !providerUsed || !modelUsed) {
-    const allCooldowns = attempts.length > 0 && attempts.every((a) => {
-      const cd = getProviderCooldown(a.providerId);
-      return cd !== null;
-    });
-    if (allCooldowns) {
+    const now = Date.now();
+    const activeCooldowns = attempts.map((attempt) => getProviderCooldown(attempt.providerId)).filter((entry) => Boolean(entry));
+    const allCandidatesCooling = attempts.length > 0 && skippedCooldownCount === attempts.length;
+    if (allCandidatesCooling) {
+      const retryAfterMs = activeCooldowns.length > 0 ? Math.max(0, Math.min(...activeCooldowns.map((entry) => entry.until - now))) : void 0;
       return {
         ok: false,
         error: lastError ?? new Error("All providers on cooldown"),
-        degraded: true,
+        escalation: {
+          policy: "degraded_tools_only",
+          reason: "all_candidates_cooling_down",
+          retryable: true,
+          retryAfterMs,
+          responseModel: "provider.degraded"
+        },
         friendlyMessage: "I'm having trouble reaching my language models right now. I can still handle quick tasks like weather, reminders, and notes. Try again in a moment!"
       };
     }
-    return { ok: false, error: lastError ?? new Error("Provider failed") };
+    if (signal?.aborted || isAbortLikeError(lastError)) {
+      return {
+        ok: false,
+        error: lastError ?? new Error("Request aborted"),
+        escalation: {
+          policy: "provider_error",
+          reason: "request_aborted",
+          retryable: false,
+          responseModel: "provider.failure"
+        }
+      };
+    }
+    if (attemptedProviderCount === 0) {
+      return {
+        ok: false,
+        error: lastError ?? new Error("No healthy provider available"),
+        escalation: {
+          policy: "provider_error",
+          reason: "no_healthy_provider",
+          retryable: true,
+          responseModel: "provider.failure"
+        }
+      };
+    }
+    return {
+      ok: false,
+      error: lastError ?? new Error("Provider failed"),
+      escalation: {
+        policy: "provider_error",
+        reason: "attempts_exhausted",
+        retryable: true,
+        responseModel: "provider.failure"
+      }
+    };
   }
   return {
     ok: true,
@@ -30753,11 +31055,11 @@ async function runChatWithFallback(params) {
 }
 
 // apps/gateway/dist/agent/loop-user-event.js
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 async function persistUserEvent(params) {
   const { storage, sessionId, message, providerId, model, memoryManager, allowMemory, logger } = params;
   const userEvent = {
-    id: randomUUID10(),
+    id: randomUUID11(),
     sessionId,
     role: "user",
     content: message.text,
@@ -30789,10 +31091,10 @@ async function persistUserEvent(params) {
 }
 
 // apps/gateway/dist/agent/loop-post-chat.js
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 
 // apps/gateway/dist/agent/memory-compaction.js
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 async function maybeCompactSession(params) {
   const { sessionId, providerId, model, memory, memoryAllowed, budgetFallbackTarget, storage, config, logger, getProvider } = params;
   if (!memoryAllowed || !memory.summaryEnabled) {
@@ -30861,7 +31163,7 @@ ${transcript}`
     await storage.setSessionSummary(sessionId, response.content, count);
     if (response.usage && storage.appendTokenUsage) {
       storage.appendTokenUsage({
-        id: randomUUID11(),
+        id: randomUUID12(),
         sessionId,
         providerId: provider.id,
         model: response.model ?? summaryModel,
@@ -30885,7 +31187,7 @@ ${transcript}`
 async function finalizeChatRun(params) {
   const { storage, session, payload, config, provider, model, response, fallbackUsed, routingDecision, routingResult, budgetFallbackTarget, maybeAppendSmritiMemory, proactiveManager, memoryManager, allowMemory, memoryAllowed, getProvider, logger, stripModelThinking: stripModelThinking2 } = params;
   await storage.appendAudit({
-    id: randomUUID12(),
+    id: randomUUID13(),
     time: (/* @__PURE__ */ new Date()).toISOString(),
     type: "agent.run.output",
     payload: {
@@ -30894,11 +31196,26 @@ async function finalizeChatRun(params) {
       model,
       fallbackUsed,
       routing: {
+        auto: routingResult.auto,
+        language: routingResult.language,
+        languageSource: routingResult.languageSource,
+        decisionLatencyMs: routingResult.decisionLatencyMs,
+        tier: routingResult.tier,
+        reason: routingResult.reason,
         requested: routingResult.requested,
         selected: routingResult.selected,
         fallbackUsed: routingResult.fallbackUsed,
+        scoring: routingResult.scoring,
+        providerResolution: routingResult.providerResolution,
         deterministicTrace: routingResult.deterministicTrace,
-        retrievalGate: routingResult.retrievalGate
+        actionability: routingResult.actionability,
+        retrievalGate: routingResult.retrievalGate,
+        smalltalkFastLane: routingResult.smalltalkFastLane,
+        escalation: routingResult.escalation,
+        policyClassifier: routingResult.policyClassifier,
+        semanticCache: routingResult.semanticCache,
+        activeToolDiscovery: routingResult.activeToolDiscovery,
+        budget: routingResult.budget
       },
       normalization: payload.message.normalization?.audit,
       // Backward-compatible key for older dashboards.
@@ -30911,7 +31228,7 @@ async function finalizeChatRun(params) {
       const outputTokens = response.usage.outputTokens ?? 0;
       const costMicro = estimateCostMicro(provider.id, model, inputTokens, outputTokens);
       await storage.appendTokenUsage({
-        id: randomUUID12(),
+        id: randomUUID13(),
         sessionId: session.id,
         providerId: provider.id,
         model,
@@ -31019,7 +31336,7 @@ async function finalizeChatRun(params) {
   }, 0);
   routingResult.selected = { providerId: provider.id, model };
   routingResult.fallbackUsed = fallbackUsed;
-  const includeRouting = Boolean(routingDecision || routingResult.budget?.applied || routingResult.deterministicTrace || routingResult.retrievalGate);
+  const includeRouting = Boolean(routingDecision || routingResult.budget?.applied || routingResult.deterministicTrace || routingResult.retrievalGate || routingResult.scoring || routingResult.providerResolution || routingResult.smalltalkFastLane || routingResult.escalation || routingResult.policyClassifier || routingResult.semanticCache || routingResult.activeToolDiscovery);
   return {
     session,
     response: {
@@ -31278,7 +31595,7 @@ function getFallbackPriority(providerType) {
   return 2;
 }
 async function resolveProviderAndModel(params) {
-  const { payload, profile, prefs, autoRouting, routingDecision, budgetState, reasoning, config, providers, providerHealth, listProviderModels, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, inferProviderFromModel: inferProviderFromModel2, logger, sessionId } = params;
+  const { payload, profile, prefs, autoRouting, routingDecision, budgetState, reasoning, config, providers, providerHealth, listProviderModels, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, inferProviderFromModel: inferProviderFromModel2, logger, sessionId, sessionPin, toolPresence } = params;
   let manualProviderId;
   let manualModel;
   if (autoRouting) {
@@ -31326,11 +31643,56 @@ async function resolveProviderAndModel(params) {
   if (!resolvedProviderId) {
     throw new Error("Missing provider");
   }
+  const resolutionSource = routingDecision?.target.providerId ? "routing" : manualProviderId || manualModel ? "manual" : "default";
+  const overrides = [];
+  const pushOverride = (params2) => {
+    overrides.push(params2);
+  };
+  const currentTarget = () => ({ providerId: resolvedProviderId, ...resolvedModel ? { model: resolvedModel } : {} });
+  const initialTarget = currentTarget();
+  if (sessionPin?.providerId) {
+    if (providers.get(sessionPin.providerId)) {
+      const from = currentTarget();
+      const changedProvider = sessionPin.providerId !== resolvedProviderId;
+      const changedModel = Boolean(sessionPin.model) && sessionPin.model !== resolvedModel;
+      if (changedProvider || changedModel) {
+        resolvedProviderId = sessionPin.providerId;
+        resolvedModel = sessionPin.model ?? resolvedModel;
+        pushOverride({
+          type: "session_pin_override",
+          from,
+          to: currentTarget(),
+          reason: sessionPin.reason ?? "session_route_pin"
+        });
+        logger.info("provider_session_pin_override", {
+          sessionId,
+          fromProviderId: from.providerId,
+          fromModel: from.model,
+          toProviderId: resolvedProviderId,
+          toModel: resolvedModel,
+          pinReason: sessionPin.reason,
+          pinUntil: sessionPin.until
+        });
+      }
+    } else {
+      logger.warn("provider_session_pin_missing_provider", {
+        sessionId,
+        providerId: sessionPin.providerId
+      });
+    }
+  }
   if (budgetState?.overDaily && budgetState.fallbackTarget) {
     const fallbackTarget = budgetState.fallbackTarget;
     if (providers.get(fallbackTarget.providerId)) {
+      const from = currentTarget();
       resolvedProviderId = fallbackTarget.providerId;
       resolvedModel = fallbackTarget.model;
+      pushOverride({
+        type: "budget_fallback",
+        from,
+        to: currentTarget(),
+        reason: "budget.over_daily"
+      });
       budgetState.applied = true;
       logger.info("routing_budget_override", {
         sessionId,
@@ -31346,6 +31708,48 @@ async function resolveProviderAndModel(params) {
       });
     }
   }
+  const shouldPreferToolCapableProvider = Boolean(toolPresence?.hasTools) && toolPresence?.actionability === "tool";
+  if (shouldPreferToolCapableProvider) {
+    const currentProviderType = providers.get(resolvedProviderId)?.type;
+    const currentPriority = getFallbackPriority(currentProviderType);
+    if (currentPriority > 1) {
+      const preferred = providers.list().slice().sort((a, b) => {
+        const priorityDelta = getFallbackPriority(a.type) - getFallbackPriority(b.type);
+        if (priorityDelta !== 0)
+          return priorityDelta;
+        return a.id.localeCompare(b.id);
+      }).find((provider) => {
+        if (!provider?.id || provider.id === resolvedProviderId)
+          return false;
+        const priority = getFallbackPriority(provider.type);
+        if (priority > 1)
+          return false;
+        if (getProviderCooldown(provider.id))
+          return false;
+        const health = providerHealth?.[provider.id];
+        if (health && health.status !== "ok")
+          return false;
+        return true;
+      });
+      if (preferred) {
+        const from = currentTarget();
+        resolvedProviderId = preferred.id;
+        resolvedModel = void 0;
+        pushOverride({
+          type: "tool_presence_override",
+          from,
+          to: currentTarget(),
+          reason: "local_or_cli_tool_capable_provider"
+        });
+        logger.info("provider_tool_presence_override", {
+          sessionId,
+          fromProviderId: from.providerId,
+          toProviderId: preferred.id,
+          actionability: toolPresence?.actionability
+        });
+      }
+    }
+  }
   const chooseFallbackProvider = (currentProviderId) => {
     const orderedFallbacks = [];
     for (const fallback of config.routing.fallback ?? []) {
@@ -31389,6 +31793,7 @@ async function resolveProviderAndModel(params) {
   if (!resolvedProviderId || !providers.get(resolvedProviderId)) {
     const fallbackTarget = chooseFallbackProvider(resolvedProviderId ?? null);
     if (fallbackTarget && providers.get(fallbackTarget.providerId)) {
+      const from = resolvedProviderId ? currentTarget() : void 0;
       logger.warn("provider_missing_fallback", {
         missingProviderId: resolvedProviderId,
         fallbackProviderId: fallbackTarget.providerId,
@@ -31396,6 +31801,12 @@ async function resolveProviderAndModel(params) {
       });
       resolvedProviderId = fallbackTarget.providerId;
       resolvedModel = fallbackTarget.model;
+      pushOverride({
+        type: "provider_missing_fallback",
+        from,
+        to: currentTarget(),
+        reason: "provider_missing"
+      });
     } else {
       throw new Error("Provider not found");
     }
@@ -31405,6 +31816,7 @@ async function resolveProviderAndModel(params) {
     if (health && health.status !== "ok") {
       const fallbackTarget = chooseFallbackProvider(resolvedProviderId);
       if (fallbackTarget && providers.get(fallbackTarget.providerId)) {
+        const from = currentTarget();
         logger.warn("provider_health_fallback", {
           providerId: resolvedProviderId,
           status: health.status,
@@ -31415,6 +31827,12 @@ async function resolveProviderAndModel(params) {
         });
         resolvedProviderId = fallbackTarget.providerId;
         resolvedModel = fallbackTarget.model;
+        pushOverride({
+          type: "provider_health_fallback",
+          from,
+          to: currentTarget(),
+          reason: health.status
+        });
       }
     }
   }
@@ -31422,6 +31840,7 @@ async function resolveProviderAndModel(params) {
   if (cooldown) {
     const fallbackTarget = chooseFallbackProvider(resolvedProviderId);
     if (fallbackTarget && providers.get(fallbackTarget.providerId)) {
+      const from = currentTarget();
       logger.warn("provider_cooldown_fallback", {
         providerId: resolvedProviderId,
         reason: cooldown.reason,
@@ -31431,6 +31850,12 @@ async function resolveProviderAndModel(params) {
       });
       resolvedProviderId = fallbackTarget.providerId;
       resolvedModel = fallbackTarget.model;
+      pushOverride({
+        type: "provider_cooldown_fallback",
+        from,
+        to: currentTarget(),
+        reason: cooldown.reason
+      });
     }
   }
   let modelsInfo = await listProviderModels(resolvedProviderId, false);
@@ -31439,6 +31864,7 @@ async function resolveProviderAndModel(params) {
   if (supportsRemoteFetchFallback && modelsInfo.error) {
     const fallbackTarget = chooseFallbackProvider(resolvedProviderId);
     if (fallbackTarget && providers.get(fallbackTarget.providerId)) {
+      const from = currentTarget();
       logger.warn("provider_models_fetch_fallback", {
         providerId: resolvedProviderId,
         model: resolvedModel,
@@ -31448,6 +31874,12 @@ async function resolveProviderAndModel(params) {
       });
       resolvedProviderId = fallbackTarget.providerId;
       resolvedModel = fallbackTarget.model;
+      pushOverride({
+        type: "models_fetch_fallback",
+        from,
+        to: currentTarget(),
+        reason: modelsInfo.error
+      });
       modelsInfo = await listProviderModels(resolvedProviderId, false);
     }
   }
@@ -31469,7 +31901,14 @@ async function resolveProviderAndModel(params) {
         fallbackModel: fallback ?? "none"
       });
       if (fallback) {
+        const from = currentTarget();
         resolvedModel = fallback;
+        pushOverride({
+          type: "model_not_found_fallback",
+          from,
+          to: currentTarget(),
+          reason: "model_not_in_provider_catalog"
+        });
       }
     }
   }
@@ -31481,8 +31920,15 @@ async function resolveProviderAndModel(params) {
       if (modelsInfo.models.length) {
         const overrideKnown = modelsInfo.models.some((model) => normalizeModelId2(model) === normalizeModelId2(resolvedOverride));
         if (overrideKnown) {
+          const from = currentTarget();
           resolvedModel = resolvedOverride;
           reasoningApplied = true;
+          pushOverride({
+            type: "reasoning_model_override",
+            from,
+            to: currentTarget(),
+            reason: "reasoning.mode"
+          });
         } else {
           logger.warn("reasoning_override_model_not_found", {
             providerId: resolvedProviderId,
@@ -31490,12 +31936,25 @@ async function resolveProviderAndModel(params) {
           });
         }
       } else {
+        const from = currentTarget();
         resolvedModel = resolvedOverride;
         reasoningApplied = true;
+        pushOverride({
+          type: "reasoning_model_override",
+          from,
+          to: currentTarget(),
+          reason: "reasoning.mode"
+        });
       }
     }
   }
-  return { providerId: resolvedProviderId, model: resolvedModel, reasoningApplied };
+  const trace = {
+    source: resolutionSource,
+    initial: initialTarget,
+    resolved: currentTarget(),
+    overrides
+  };
+  return { providerId: resolvedProviderId, model: resolvedModel, reasoningApplied, trace };
 }
 
 // apps/gateway/dist/agent/saved-models.js
@@ -31762,6 +32221,463 @@ function classifyMessage(text, hasTools) {
   }
 }
 
+// apps/gateway/dist/agent/router-scoring.js
+var LOCAL_PROVIDER_TYPES4 = /* @__PURE__ */ new Set(["ollama", "mock"]);
+var CLI_PROVIDER_TYPES4 = /* @__PURE__ */ new Set(["codex-cli", "claude-code", "copilot"]);
+function providerSupportsToolAwareRouting(providers, providerId) {
+  const provider = providers.get(providerId);
+  if (!provider)
+    return false;
+  return LOCAL_PROVIDER_TYPES4.has(provider.type) || CLI_PROVIDER_TYPES4.has(provider.type);
+}
+function sumSignals(signals) {
+  let total = 0;
+  for (const signal of signals) {
+    total += signal.contribution;
+  }
+  return total;
+}
+function buildCandidate(params) {
+  const { candidate, providers, complexitySignal, actionabilityKind, policyLabel, hasTools } = params;
+  const signals = [];
+  const pushSignal = (name, weight, value, note) => {
+    signals.push({
+      name,
+      weight,
+      value,
+      contribution: weight * value,
+      note
+    });
+  };
+  pushSignal("base", 1, candidate.source === "marga" ? 0.5 : 0.4);
+  if (candidate.source === "marga") {
+    const confidence = Math.max(0, Math.min(1, candidate.margaConfidence ?? 0));
+    pushSignal("marga_confidence", 0.35, confidence);
+  }
+  if (complexitySignal) {
+    const aligned = candidate.decision.tier === complexitySignal.tier ? 1 : -0.5;
+    pushSignal("complexity_alignment", 0.2, aligned, `signal:${complexitySignal.tier}:${complexitySignal.reason}`);
+  }
+  if (actionabilityKind === "smalltalk" || actionabilityKind === "command") {
+    const fastAligned = candidate.decision.tier === "fast" ? 1 : -1;
+    pushSignal("actionability_alignment", 0.22, fastAligned, `action:${actionabilityKind}`);
+  } else if (actionabilityKind === "tool" && hasTools) {
+    const toolAligned = providerSupportsToolAwareRouting(providers, candidate.decision.target.providerId) ? 1 : -0.35;
+    pushSignal("tool_presence_alignment", 0.24, toolAligned, "action:tool");
+  }
+  if (policyLabel === "safe_fast_lane") {
+    const fastAligned = candidate.decision.tier === "fast" ? 1 : -0.8;
+    pushSignal("policy_alignment", 0.18, fastAligned, "policy:safe_fast_lane");
+  } else if (policyLabel === "cautious" || policyLabel === "deny") {
+    const deepAligned = candidate.decision.tier === "deep" ? 1 : -0.65;
+    pushSignal("policy_alignment", 0.18, deepAligned, `policy:${policyLabel}`);
+  }
+  if (!providers.get(candidate.decision.target.providerId)) {
+    pushSignal("provider_missing_penalty", 0.6, -1);
+  }
+  return {
+    source: candidate.source,
+    target: candidate.decision.target,
+    tier: candidate.decision.tier,
+    reason: candidate.decision.reason,
+    score: Number(sumSignals(signals).toFixed(4)),
+    signals
+  };
+}
+function scoreRoutingDecision(params) {
+  const candidatesInput = [];
+  if (params.margaDecision) {
+    candidatesInput.push({
+      source: "marga",
+      decision: params.margaDecision,
+      margaConfidence: params.margaConfidence
+    });
+  }
+  if (params.heuristicDecision) {
+    candidatesInput.push({
+      source: "heuristic",
+      decision: params.heuristicDecision
+    });
+  }
+  if (candidatesInput.length === 0) {
+    return { decision: null, trace: null };
+  }
+  const scored = candidatesInput.map((candidate) => buildCandidate({
+    candidate,
+    providers: params.providers,
+    complexitySignal: params.complexitySignal,
+    actionabilityKind: params.actionabilityKind,
+    policyLabel: params.policyLabel,
+    hasTools: params.hasTools
+  }));
+  scored.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    if (a.source !== b.source)
+      return a.source === "marga" ? -1 : 1;
+    const aLabel = `${a.target.providerId}:${a.target.model ?? ""}`;
+    const bLabel = `${b.target.providerId}:${b.target.model ?? ""}`;
+    return aLabel.localeCompare(bLabel);
+  });
+  const winner = scored[0];
+  const decision = {
+    target: winner.target,
+    tier: winner.tier,
+    reason: `score:${winner.source}:${winner.reason}`
+  };
+  const trace = {
+    strategy: "multi_signal_v1",
+    selectedSource: winner.source,
+    selectedScore: winner.score,
+    candidates: scored
+  };
+  return { decision, trace };
+}
+
+// apps/gateway/dist/router-backlog/policy-classifier-contract.js
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function isPolicyLabel(value) {
+  return value === "safe_fast_lane" || value === "standard" || value === "cautious" || value === "deny";
+}
+function clamp012(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function parsePolicyClassifierResponse(payload) {
+  if (!isRecord(payload))
+    return null;
+  if (payload.ok !== true)
+    return null;
+  if (!isPolicyLabel(payload.policy))
+    return null;
+  const confidenceRaw = Number(payload.confidence);
+  const reasons = Array.isArray(payload.reasons) ? payload.reasons.filter((item) => typeof item === "string") : [];
+  const ttlSecRaw = Number(payload.ttlSec);
+  return {
+    ok: true,
+    policy: payload.policy,
+    confidence: clamp012(confidenceRaw),
+    reasons,
+    ttlSec: Number.isFinite(ttlSecRaw) ? Math.max(1, Math.floor(ttlSecRaw)) : 30,
+    classifier: typeof payload.classifier === "string" ? payload.classifier : void 0,
+    time: typeof payload.time === "string" ? payload.time : void 0
+  };
+}
+async function classifyPolicyWithSidecar(params) {
+  const timeoutMs = Number.isFinite(params.timeoutMs) ? Math.max(50, Math.floor(params.timeoutMs ?? 250)) : 250;
+  const fetchImpl = params.fetchImpl ?? globalThis.fetch;
+  const fallback = {
+    ok: true,
+    policy: "standard",
+    confidence: 0.45,
+    reasons: ["fallback_standard_policy"],
+    ttlSec: 20,
+    classifier: "fallback-v0",
+    time: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (typeof fetchImpl !== "function") {
+    return {
+      ok: false,
+      source: "fallback",
+      response: fallback,
+      error: "fetch_unavailable"
+    };
+  }
+  const baseUrl = params.baseUrl.replace(/\/+$/, "");
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(`${baseUrl}/v1/classify`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(params.request),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return {
+        ok: false,
+        source: "fallback",
+        response: fallback,
+        error: `http_${response.status}`
+      };
+    }
+    const data2 = await response.json();
+    const parsed = parsePolicyClassifierResponse(data2);
+    if (!parsed) {
+      return {
+        ok: false,
+        source: "fallback",
+        response: fallback,
+        error: "invalid_payload"
+      };
+    }
+    return {
+      ok: true,
+      source: "sidecar",
+      response: parsed
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      source: "fallback",
+      response: fallback,
+      error: message
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// apps/gateway/dist/router-backlog/semantic-cache-policy.js
+var DEFAULT_SEMANTIC_CACHE_POLICY = {
+  smalltalk: {
+    similarityThreshold: 0.82,
+    ttlMs: 30 * 6e4,
+    asyncVerify: false,
+    maxVerifyWaitMs: 0
+  },
+  general: {
+    similarityThreshold: 0.92,
+    ttlMs: 5 * 6e4,
+    asyncVerify: true,
+    maxVerifyWaitMs: 250
+  },
+  memory: {
+    similarityThreshold: 0.95,
+    ttlMs: 2 * 6e4,
+    asyncVerify: true,
+    maxVerifyWaitMs: 300
+  },
+  tool: {
+    similarityThreshold: 0.98,
+    ttlMs: 45e3,
+    asyncVerify: true,
+    maxVerifyWaitMs: 350
+  },
+  safety: {
+    similarityThreshold: 0.995,
+    ttlMs: 2e4,
+    asyncVerify: true,
+    maxVerifyWaitMs: 500
+  },
+  factual: {
+    similarityThreshold: 0.94,
+    ttlMs: 3 * 6e4,
+    asyncVerify: true,
+    maxVerifyWaitMs: 280
+  }
+};
+function clamp013(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function mergePolicy(overrides) {
+  if (!overrides)
+    return DEFAULT_SEMANTIC_CACHE_POLICY;
+  const next = { ...DEFAULT_SEMANTIC_CACHE_POLICY };
+  for (const category of Object.keys(DEFAULT_SEMANTIC_CACHE_POLICY)) {
+    if (overrides[category]) {
+      const merged = {
+        ...DEFAULT_SEMANTIC_CACHE_POLICY[category],
+        ...overrides[category]
+      };
+      next[category] = {
+        similarityThreshold: clamp013(merged.similarityThreshold),
+        ttlMs: Math.max(1e3, Math.floor(merged.ttlMs)),
+        asyncVerify: Boolean(merged.asyncVerify),
+        maxVerifyWaitMs: Math.max(0, Math.floor(merged.maxVerifyWaitMs))
+      };
+    }
+  }
+  return next;
+}
+function inferSemanticCacheCategory(signals) {
+  if (signals.sensitiveTopic)
+    return "safety";
+  if (signals.deterministicTool || signals.actionabilityKind === "tool")
+    return "tool";
+  if (signals.actionabilityKind === "smalltalk")
+    return "smalltalk";
+  if (signals.actionabilityKind === "memory" || signals.actionabilityKind === "recap")
+    return "memory";
+  const text = (signals.text ?? "").toLowerCase();
+  if (/\b(who|what|when|where|why|how\s+many|fact|stats?|number|latest|today)\b/.test(text)) {
+    return "factual";
+  }
+  if (signals.retrievalAllow) {
+    return "memory";
+  }
+  return "general";
+}
+function resolveSemanticCacheRule(params) {
+  const policy = mergePolicy(params.overrides);
+  return policy[params.category];
+}
+
+// apps/gateway/dist/router-backlog/semantic-response-cache.js
+var MAX_ENTRIES = 400;
+var CACHEABLE_CATEGORIES = /* @__PURE__ */ new Set([
+  "smalltalk",
+  "general",
+  "factual"
+]);
+var entries = [];
+function clamp014(value) {
+  if (!Number.isFinite(value))
+    return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function normalizeText3(input) {
+  return input.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+function toTokenSet(text) {
+  if (!text)
+    return /* @__PURE__ */ new Set();
+  return new Set(text.split(" ").filter(Boolean));
+}
+function tokenJaccard(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 1;
+  if (a.size === 0 || b.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token))
+      intersection += 1;
+  }
+  const union = a.size + b.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function bigramSet(text) {
+  const compact = text.replace(/\s+/g, " ");
+  if (compact.length < 2)
+    return /* @__PURE__ */ new Set([compact]);
+  const out = /* @__PURE__ */ new Set();
+  for (let index = 0; index < compact.length - 1; index += 1) {
+    out.add(compact.slice(index, index + 2));
+  }
+  return out;
+}
+function similarityScore(aRaw, bRaw) {
+  const a = normalizeText3(aRaw);
+  const b = normalizeText3(bRaw);
+  if (!a || !b)
+    return 0;
+  if (a === b)
+    return 1;
+  const tokenScore = tokenJaccard(toTokenSet(a), toTokenSet(b));
+  const bigramScore = tokenJaccard(bigramSet(a), bigramSet(b));
+  return clamp014(0.7 * tokenScore + 0.3 * bigramScore);
+}
+function pruneExpired(nowMs) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry && entry.expiresAtMs <= nowMs) {
+      entries.splice(index, 1);
+    }
+  }
+}
+function isSemanticResponseCacheCategoryEnabled(category) {
+  return CACHEABLE_CATEGORIES.has(category);
+}
+function lookupSemanticResponseCache(params) {
+  const nowMs = params.nowMs ?? Date.now();
+  pruneExpired(nowMs);
+  if (!isSemanticResponseCacheCategoryEnabled(params.category)) {
+    return {
+      attempted: true,
+      hit: false,
+      reason: "category_disabled"
+    };
+  }
+  const queryNorm = normalizeText3(params.query);
+  if (!queryNorm) {
+    return {
+      attempted: true,
+      hit: false,
+      reason: "empty_query"
+    };
+  }
+  let best;
+  for (const entry of entries) {
+    if (entry.sessionId !== params.sessionId)
+      continue;
+    if (entry.category !== params.category)
+      continue;
+    const similarity = similarityScore(queryNorm, entry.queryNorm);
+    if (!best || similarity > best.similarity) {
+      best = { entry, similarity };
+    }
+  }
+  if (!best) {
+    return {
+      attempted: true,
+      hit: false,
+      reason: "no_candidate"
+    };
+  }
+  if (best.similarity < clamp014(params.threshold)) {
+    return {
+      attempted: true,
+      hit: false,
+      reason: "threshold_not_met",
+      similarity: best.similarity,
+      ageMs: Math.max(0, nowMs - best.entry.createdAtMs)
+    };
+  }
+  return {
+    attempted: true,
+    hit: true,
+    reason: "hit",
+    similarity: best.similarity,
+    ageMs: Math.max(0, nowMs - best.entry.createdAtMs),
+    entry: {
+      responseContent: best.entry.responseContent,
+      selected: best.entry.selected
+    }
+  };
+}
+function storeSemanticResponseCache(params) {
+  const nowMs = params.nowMs ?? Date.now();
+  pruneExpired(nowMs);
+  if (!isSemanticResponseCacheCategoryEnabled(params.category)) {
+    return false;
+  }
+  const queryNorm = normalizeText3(params.query);
+  const responseContent = params.responseContent.trim();
+  if (!queryNorm || !responseContent) {
+    return false;
+  }
+  const ttlMs = Math.max(1e3, Math.floor(params.ttlMs));
+  const next = {
+    sessionId: params.sessionId,
+    category: params.category,
+    queryNorm,
+    responseContent,
+    selected: params.selected,
+    createdAtMs: nowMs,
+    expiresAtMs: nowMs + ttlMs
+  };
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (!entry)
+      continue;
+    if (entry.sessionId === next.sessionId && entry.category === next.category && entry.queryNorm === next.queryNorm) {
+      entries.splice(index, 1);
+    }
+  }
+  entries.unshift(next);
+  if (entries.length > MAX_ENTRIES) {
+    entries.length = MAX_ENTRIES;
+  }
+  return true;
+}
+
 // apps/gateway/dist/agent/loop-execute.js
 function mapMargaComplexityToTier(complexity) {
   if (!complexity)
@@ -31812,31 +32728,114 @@ async function executeAgentRun(params) {
   const hasSessionOverride = Boolean(prefs?.providerId) || Boolean(prefs?.model);
   const autoRoutingPreference = typeof prefs?.autoRouting === "boolean" ? prefs.autoRouting : void 0;
   const autoRouting = hasPayloadOverride ? false : autoRoutingPreference ?? (hasSessionOverride ? false : profile.autoRoutingDefault ?? config.routing.enabled ?? false);
+  const routingDecisionStartedAt = Date.now();
+  const pinUntilMs = sessionRoute.pinUntil ? Date.parse(sessionRoute.pinUntil) : Number.NaN;
+  const sessionPinExpired = Boolean(sessionRoute.pinProviderId) && Number.isFinite(pinUntilMs) && pinUntilMs <= Date.now();
+  if (sessionPinExpired && storage.setSessionRoute) {
+    void storage.setSessionRoute(session.id, {
+      agentId: sessionRoute.agentId,
+      laneId: sessionRoute.laneId,
+      queueMode: sessionRoute.queueMode,
+      announceMode: sessionRoute.announceMode
+    }).catch((error) => {
+      logger.warn("session_route_pin_clear_failed", {
+        sessionId: session.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  const activeSessionPin = !hasPayloadOverride && !sessionPinExpired && sessionRoute.pinProviderId ? {
+    providerId: sessionRoute.pinProviderId,
+    model: sessionRoute.pinModel,
+    reason: sessionRoute.pinReason,
+    until: sessionRoute.pinUntil
+  } : void 0;
+  const policySidecarBaseUrl = (process.env.VAAYU_POLICY_CLASSIFIER_URL ?? process.env.VAAYU_POLICY_SIDECAR_URL ?? "").trim();
+  const fallbackPolicyReasons = !policySidecarBaseUrl ? ["policy_sidecar_not_configured"] : ["policy_sidecar_fallback"];
+  let policyClassifier = {
+    source: "fallback",
+    policy: "standard",
+    confidence: 0.45,
+    reasons: fallbackPolicyReasons,
+    ttlSec: 20
+  };
+  if (policySidecarBaseUrl) {
+    const policyResult = await classifyPolicyWithSidecar({
+      baseUrl: policySidecarBaseUrl,
+      timeoutMs: 250,
+      request: {
+        text: routingText,
+        channel: payload.message.channel,
+        hasTools: runtime.toolRegistry.list().length > 0,
+        metadata: {
+          sessionId: session.id,
+          language: locale
+        }
+      }
+    });
+    if (policyResult.ok) {
+      policyClassifier = {
+        source: "sidecar",
+        policy: policyResult.response.policy,
+        confidence: policyResult.response.confidence,
+        reasons: policyResult.response.reasons,
+        ttlSec: policyResult.response.ttlSec
+      };
+    } else {
+      policyClassifier = {
+        source: "fallback",
+        policy: policyResult.response.policy,
+        confidence: policyResult.response.confidence,
+        reasons: [...policyResult.response.reasons, policyResult.error].filter(Boolean),
+        ttlSec: policyResult.response.ttlSec
+      };
+    }
+  }
+  const naturalCommand = detectNaturalLanguageCommand(routingText, locale);
+  const commandText = naturalCommand ?? payload.message.text;
+  const command = parseCommand(commandText);
+  const actionability = classifyActionability({
+    text: routingText,
+    hasStructuredCommand: Boolean(command),
+    languageHint: prefs?.language ?? profile.language,
+    assistantName: profile.assistantName,
+    isPureGreeting: deps.isPureGreeting,
+    isPureAck: deps.isPureAck,
+    looksLikeWeatherAsk: deps.looksLikeWeatherAsk,
+    looksLikeRecentRecap: deps.looksLikeRecentRecap
+  });
   const hasTools = runtime.toolRegistry.list().length > 0;
   const margaDecision = autoRouting ? await runtime.chitraguptaBridge?.decideRoute({
     message: routingText,
     hasTools,
     bindingStrategy: "hybrid"
   }) ?? classifyMessage(routingText, hasTools) : null;
-  const routingDecision = autoRouting ? (() => {
-    if (margaDecision?.providerId && providers.get(margaDecision.providerId)) {
-      return {
-        target: {
-          providerId: margaDecision.providerId,
-          model: margaDecision.modelId
-        },
-        tier: mapMargaComplexityToTier(margaDecision.complexity),
-        reason: `marga:${margaDecision.taskType}/${margaDecision.complexity}`
-      };
-    }
-    return buildRoutingDecision(routingText, session.id, config.routing);
-  })() : null;
+  const margaRoutingDecision = autoRouting && margaDecision?.providerId && providers.get(margaDecision.providerId) ? {
+    target: {
+      providerId: margaDecision.providerId,
+      model: margaDecision.modelId
+    },
+    tier: mapMargaComplexityToTier(margaDecision.complexity),
+    reason: `marga:${margaDecision.taskType}/${margaDecision.complexity}`
+  } : null;
+  const heuristicRoutingDecision = autoRouting ? buildRoutingDecision(routingText, session.id, config.routing) : null;
   const reasoningConfig = config.routing.reasoning;
   const reasoningMode = reasoningConfig?.mode ?? "off";
   const complexitySignal = reasoningMode === "auto" ? margaDecision ? {
     tier: mapMargaComplexityToTier(margaDecision.complexity),
     reason: `marga:${margaDecision.taskType}/${margaDecision.complexity}`
   } : evaluateComplexitySignal(routingText, config.routing) : null;
+  const scoringResult = autoRouting ? scoreRoutingDecision({
+    providers,
+    margaDecision: margaRoutingDecision,
+    margaConfidence: margaDecision?.confidence,
+    heuristicDecision: heuristicRoutingDecision,
+    complexitySignal,
+    actionabilityKind: actionability.kind,
+    policyLabel: policyClassifier.policy,
+    hasTools
+  }) : { decision: null, trace: null };
+  const routingDecision = autoRouting ? scoringResult.decision ?? margaRoutingDecision ?? heuristicRoutingDecision : null;
   const manualModelOverride = Boolean(payload.model) || !autoRouting && Boolean(prefs?.model);
   const reasoningEnabled = !manualModelOverride && (reasoningMode === "on" || reasoningMode === "auto" && complexitySignal?.tier === "deep");
   const budgetState = await evaluateBudgetState({ storage, config, logger });
@@ -31861,7 +32860,7 @@ async function executeAgentRun(params) {
     logger.warn("kaala_auto_delegate_failed", { err: error });
   }
   const resolvedSystem = payload.system ?? prefs?.system ?? profile.defaultSystem ?? payload.defaults?.system;
-  const { providerId: resolvedProviderId, model: resolvedModel } = await resolveProviderAndModel({
+  const { providerId: resolvedProviderId, model: resolvedModel, trace: providerResolutionTrace } = await resolveProviderAndModel({
     payload,
     profile,
     prefs,
@@ -31880,8 +32879,14 @@ async function executeAgentRun(params) {
     normalizeModelId: normalizeModelId2,
     inferProviderFromModel: inferProviderFromModel2,
     logger,
-    sessionId: session.id
+    sessionId: session.id,
+    sessionPin: activeSessionPin,
+    toolPresence: {
+      hasTools,
+      actionability: actionability.kind
+    }
   });
+  const routingDecisionLatencyMs = Math.max(0, Date.now() - routingDecisionStartedAt);
   const profileSystem = buildProfileSystemPrompt2(profile);
   const combinedSystem = buildCombinedSystemPrompt({
     soulPrompt,
@@ -31899,13 +32904,22 @@ async function executeAgentRun(params) {
   const routingResult = {
     auto: autoRouting,
     language: locale,
-    languageSource: languageDecision.source
+    languageSource: languageDecision.source,
+    decisionLatencyMs: routingDecisionLatencyMs,
+    actionability,
+    policyClassifier
   };
   if (routingDecision) {
     routingResult.tier = routingDecision.tier;
     routingResult.reason = routingDecision.reason;
     routingResult.requested = routingDecision.target;
   }
+  if (scoringResult.trace) {
+    routingResult.scoring = scoringResult.trace;
+  }
+  if (providerResolutionTrace) {
+    routingResult.providerResolution = providerResolutionTrace;
+  }
   if (budgetState) {
     routingResult.budget = {
       available: budgetState.available,
@@ -31919,20 +32933,6 @@ async function executeAgentRun(params) {
       fallback: budgetState.fallbackTarget
     };
   }
-  const naturalCommand = detectNaturalLanguageCommand(routingText, locale);
-  const commandText = naturalCommand ?? payload.message.text;
-  const command = parseCommand(commandText);
-  const actionability = classifyActionability({
-    text: routingText,
-    hasStructuredCommand: Boolean(command),
-    languageHint: prefs?.language ?? profile.language,
-    assistantName: profile.assistantName,
-    isPureGreeting: deps.isPureGreeting,
-    isPureAck: deps.isPureAck,
-    looksLikeWeatherAsk: deps.looksLikeWeatherAsk,
-    looksLikeRecentRecap: deps.looksLikeRecentRecap
-  });
-  routingResult.actionability = actionability;
   const retrievalDecision = shouldRetrieveContext({
     text: routingText,
     allowMemory,
@@ -31946,8 +32946,24 @@ async function executeAgentRun(params) {
     reason: retrievalDecision.reason,
     query: retrievalQueryText
   };
+  const semanticCacheCategory = inferSemanticCacheCategory({
+    text: routingText,
+    actionabilityKind: actionability.kind,
+    retrievalAllow: retrievalDecision.allow,
+    deterministicTool: Boolean(routingResult.deterministicTrace?.tool)
+  });
+  const semanticCacheRule = resolveSemanticCacheRule({
+    category: semanticCacheCategory
+  });
+  routingResult.semanticCache = {
+    category: semanticCacheCategory,
+    similarityThreshold: semanticCacheRule.similarityThreshold,
+    ttlMs: semanticCacheRule.ttlMs,
+    asyncVerify: semanticCacheRule.asyncVerify,
+    maxVerifyWaitMs: semanticCacheRule.maxVerifyWaitMs
+  };
   await storage.appendAudit({
-    id: randomUUID13(),
+    id: randomUUID14(),
     time: (/* @__PURE__ */ new Date()).toISOString(),
     type: "agent.run.input",
     payload: {
@@ -31955,7 +32971,21 @@ async function executeAgentRun(params) {
       channel: payload.message.channel,
       providerId: resolvedProviderId,
       model: resolvedModel,
-      routing: routingResult.requested,
+      routing: {
+        auto: routingResult.auto,
+        language: routingResult.language,
+        languageSource: routingResult.languageSource,
+        decisionLatencyMs: routingResult.decisionLatencyMs,
+        tier: routingResult.tier,
+        reason: routingResult.reason,
+        requested: routingResult.requested,
+        scoring: routingResult.scoring,
+        providerResolution: routingResult.providerResolution,
+        policyClassifier: routingResult.policyClassifier,
+        semanticCache: routingResult.semanticCache
+      },
+      // Backward-compatible key for older dashboards.
+      routingTarget: routingResult.requested,
       normalization: normalizedAuditContext,
       // Backward-compatible key for older dashboards.
       normalized: normalizedAuditContext,
@@ -32087,6 +33117,50 @@ async function executeAgentRun(params) {
     routingResult.fallbackUsed = false;
     return buildEarlyResult(session, skipModel, skipContent, routingDecision, routingResult);
   }
+  const semanticCacheLookup = lookupSemanticResponseCache({
+    sessionId: session.id,
+    category: semanticCacheCategory,
+    query: routingText,
+    threshold: semanticCacheRule.similarityThreshold
+  });
+  if (routingResult.semanticCache) {
+    routingResult.semanticCache.lookupAttempted = semanticCacheLookup.attempted;
+    routingResult.semanticCache.lookupHit = semanticCacheLookup.hit;
+    routingResult.semanticCache.lookupSimilarity = semanticCacheLookup.similarity;
+    routingResult.semanticCache.lookupReason = semanticCacheLookup.reason;
+    routingResult.semanticCache.lookupAgeMs = semanticCacheLookup.ageMs;
+  }
+  await storage.appendAudit({
+    id: randomUUID14(),
+    time: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "semantic.cache.lookup",
+    payload: {
+      sessionId: session.id,
+      category: semanticCacheCategory,
+      threshold: semanticCacheRule.similarityThreshold,
+      hit: semanticCacheLookup.hit,
+      similarity: semanticCacheLookup.similarity,
+      reason: semanticCacheLookup.reason,
+      ageMs: semanticCacheLookup.ageMs,
+      queryPreview: routingText.slice(0, 120)
+    }
+  });
+  if (semanticCacheLookup.hit && semanticCacheLookup.entry) {
+    const cached2 = semanticCacheLookup.entry;
+    const cacheModel = cached2.selected.model ?? "semantic.cache.hit";
+    await appendAssistantEvent(storage, session.id, cached2.responseContent, {
+      providerId: cached2.selected.providerId,
+      model: cacheModel,
+      semanticCache: {
+        hit: true,
+        reason: semanticCacheLookup.reason,
+        similarity: semanticCacheLookup.similarity
+      }
+    }, payload.message);
+    routingResult.selected = cached2.selected;
+    routingResult.fallbackUsed = false;
+    return buildEarlyResult(session, cacheModel, cached2.responseContent, routingDecision, routingResult);
+  }
   const chatResult = await runChatWithFallback({
     sessionId: session.id,
     messageText: payload.message.text,
@@ -32126,8 +33200,10 @@ async function executeAgentRun(params) {
     signal: runSignal
   });
   if (!chatResult.ok) {
-    const content = chatResult.degraded && chatResult.friendlyMessage ? chatResult.friendlyMessage : formatProviderError2(chatResult.error ?? new Error("Provider failed"));
-    const errorModel = chatResult.degraded ? "provider.degraded" : "provider.failure";
+    const escalation = chatResult.escalation;
+    const content = escalation.policy === "degraded_tools_only" && chatResult.friendlyMessage ? chatResult.friendlyMessage : formatProviderError2(chatResult.error ?? new Error("Provider failed"));
+    const errorModel = escalation.responseModel;
+    routingResult.escalation = escalation;
     await appendAssistantEvent(storage, session.id, content, {
       providerId: "error",
       model: errorModel
@@ -32150,6 +33226,28 @@ async function executeAgentRun(params) {
   if (runSignal.aborted) {
     throw new Error("Request aborted");
   }
+  const cacheStored = storeSemanticResponseCache({
+    sessionId: session.id,
+    category: semanticCacheCategory,
+    query: routingText,
+    responseContent: response.content,
+    selected: { providerId: provider.id, model },
+    ttlMs: semanticCacheRule.ttlMs
+  });
+  if (cacheStored) {
+    await storage.appendAudit({
+      id: randomUUID14(),
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "semantic.cache.write",
+      payload: {
+        sessionId: session.id,
+        category: semanticCacheCategory,
+        ttlMs: semanticCacheRule.ttlMs,
+        providerId: provider.id,
+        model
+      }
+    });
+  }
   return finalizeChatRun({
     storage,
     session,
@@ -32174,7 +33272,7 @@ async function executeAgentRun(params) {
 }
 
 // apps/gateway/dist/routing-trace.js
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 var MAX_TRACE_ENTRIES = 300;
 var traces = [];
 function compactText(input) {
@@ -32214,7 +33312,7 @@ function buildNluDecision(routing) {
 }
 function recordRoutingTrace(params) {
   const entry = {
-    id: randomUUID14(),
+    id: randomUUID15(),
     time: (/* @__PURE__ */ new Date()).toISOString(),
     runId: params.runId,
     sessionId: params.sessionId,
@@ -32223,7 +33321,11 @@ function recordRoutingTrace(params) {
     userId: params.userId,
     textPreview: compactText(params.text),
     responseModel: params.responseModel,
+    auto: params.routing?.auto,
+    language: params.routing?.language,
+    languageSource: params.routing?.languageSource,
     nluDecision: buildNluDecision(params.routing),
+    decisionLatencyMs: params.routing?.decisionLatencyMs,
     tier: params.routing?.tier,
     reason: params.routing?.reason,
     requested: params.routing?.requested,
@@ -32232,6 +33334,14 @@ function recordRoutingTrace(params) {
     fallbackPath: buildFallbackPath(params.routing),
     deterministicTrace: params.routing?.deterministicTrace,
     actionability: params.routing?.actionability,
+    retrievalGate: params.routing?.retrievalGate,
+    scoring: params.routing?.scoring,
+    providerResolution: params.routing?.providerResolution,
+    smalltalkFastLane: params.routing?.smalltalkFastLane,
+    escalation: params.routing?.escalation,
+    policyClassifier: params.routing?.policyClassifier,
+    semanticCache: params.routing?.semanticCache,
+    activeToolDiscovery: params.routing?.activeToolDiscovery,
     budgetFallback: params.routing?.budget?.fallback
   };
   traces.unshift(entry);
@@ -32272,7 +33382,7 @@ function createAgentLoop(deps) {
     if (payload.signal?.aborted) {
       throw new Error("Request aborted");
     }
-    const runId = randomUUID15();
+    const runId = randomUUID16();
     const sanitizeResult = sanitizeInput(payload.message.text, {
       maxLength: 5e4,
       allowInjection: false
@@ -32314,7 +33424,7 @@ function createAgentLoop(deps) {
     const inboxId = payload.inboxId ?? await (async () => {
       if (payload.skipInbox || !storage.enqueueSessionInbox)
         return void 0;
-      const recordId = randomUUID15();
+      const recordId = randomUUID16();
       const record = {
         id: recordId,
         sessionId: session.id,
@@ -32561,7 +33671,7 @@ function createAgentLoop(deps) {
         routing: result.routing
       });
       await storage.appendAudit({
-        id: randomUUID15(),
+        id: randomUUID16(),
         time: trace.time,
         type: "routing.trace",
         payload: trace
@@ -32649,7 +33759,7 @@ function requireAdmin(connectionAuth, connectionId, params, gatewayConfig, remot
 }
 
 // apps/gateway/dist/self-heal/index.js
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 var resolveTargets = (target) => {
   if (!target || target === "all")
     return ["kaala", "smriti", "qdrant"];
@@ -32752,7 +33862,7 @@ async function runSelfHeal(params) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   if (runtime.storage.appendAudit) {
     await runtime.storage.appendAudit({
-      id: randomUUID16(),
+      id: randomUUID17(),
       time: timestamp,
       type: "self_heal.run",
       payload: { target, mode, status, actions }
@@ -32918,7 +34028,7 @@ function createCoreMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/sessions.js
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import path18 from "node:path";
 
 // ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
@@ -37944,9 +39054,9 @@ function isReasoningMode(value) {
   return value === "off" || value === "auto" || value === "on";
 }
 function parseReasoningOverrides(value) {
-  const entries = value.split(",").map((segment) => segment.trim()).filter(Boolean);
+  const entries2 = value.split(",").map((segment) => segment.trim()).filter(Boolean);
   const overrides = {};
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const separator = entry.includes("=") ? "=" : entry.includes(":") ? ":" : null;
     if (!separator) continue;
     const index = entry.indexOf(separator);
@@ -38563,7 +39673,7 @@ function createSessionMethods(ctx) {
         }
         const record = await storage.createSession(payload.key);
         await storage.appendAudit({
-          id: randomUUID17(),
+          id: randomUUID18(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.create",
           payload: { sessionId: record.id, key: payload.key }
@@ -38659,7 +39769,7 @@ function createSessionMethods(ctx) {
         const sessionConfig = payload.scope && payload.scope.trim() ? { ...config.session, scope: payload.scope.trim() } : config.session;
         const record = await resolveSessionWithPolicy(storage, payload, sessionConfig, sessionIdentityMap);
         await storage.appendAudit({
-          id: randomUUID17(),
+          id: randomUUID18(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.resolve",
           payload: { sessionId: record.id, key: record.key }
@@ -38693,10 +39803,14 @@ function createSessionMethods(ctx) {
           agentId: payload.agentId,
           laneId: payload.laneId,
           queueMode: payload.queueMode,
-          announceMode: payload.announceMode
+          announceMode: payload.announceMode,
+          pinProviderId: payload.pinProviderId,
+          pinModel: payload.pinModel,
+          pinReason: payload.pinReason,
+          pinUntil: payload.pinUntil
         });
         await storage.appendAudit({
-          id: randomUUID17(),
+          id: randomUUID18(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.route.set",
           payload: {
@@ -38704,7 +39818,11 @@ function createSessionMethods(ctx) {
             agentId: record.agentId,
             laneId: record.laneId,
             queueMode: record.queueMode,
-            announceMode: record.announceMode
+            announceMode: record.announceMode,
+            pinProviderId: record.pinProviderId,
+            pinModel: record.pinModel,
+            pinReason: record.pinReason,
+            pinUntil: record.pinUntil
           }
         });
         return record;
@@ -38766,7 +39884,7 @@ function createSessionMethods(ctx) {
         });
         writeConfigFile(configPath, merged);
         await storage.appendAudit({
-          id: randomUUID17(),
+          id: randomUUID18(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.continuity.set",
           payload: { continuity: parsed }
@@ -38778,7 +39896,7 @@ function createSessionMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/session-prefs.js
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function createSessionPrefsMethods(ctx) {
   const { runtime, requireAdmin: requireAdmin2 } = ctx;
   const { storage } = runtime;
@@ -38816,7 +39934,7 @@ function createSessionPrefsMethods(ctx) {
           proactiveCooldownMs: payload.proactiveCooldownMs
         });
         await storage.appendAudit({
-          id: randomUUID18(),
+          id: randomUUID19(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: {
@@ -38844,7 +39962,7 @@ function createSessionPrefsMethods(ctx) {
         }
         await storage.clearSessionPrefs(payload.sessionId);
         await storage.appendAudit({
-          id: randomUUID18(),
+          id: randomUUID19(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.clear",
           payload: { sessionId: payload.sessionId }
@@ -38878,7 +39996,7 @@ function createSessionPrefsMethods(ctx) {
           cleared.push({ sessionId: session.id, channel });
         }
         await storage.appendAudit({
-          id: randomUUID18(),
+          id: randomUUID19(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "sessions.routing.clear",
           payload: {
@@ -38894,7 +40012,7 @@ function createSessionPrefsMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/devices.js
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 function createDeviceMethods(ctx) {
   const { runtime, deps, requireAdmin: requireAdmin2 } = ctx;
   const { storage, connectionAuth, pendingChallenges, broadcastEvent } = runtime;
@@ -38932,7 +40050,7 @@ function createDeviceMethods(ctx) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const tokenData = issueDeviceToken();
         const record = {
-          id: randomUUID19(),
+          id: randomUUID20(),
           name: payload?.name,
           type: payload?.type,
           role: payload?.role,
@@ -38948,7 +40066,7 @@ function createDeviceMethods(ctx) {
         };
         await storage.createDevice(record);
         await storage.appendAudit({
-          id: randomUUID19(),
+          id: randomUUID20(),
           time: now,
           type: "device.create",
           payload: { deviceId: record.id, name: record.name, type: record.type }
@@ -38983,7 +40101,7 @@ function createDeviceMethods(ctx) {
           throw new Error("Device not found");
         }
         await storage.appendAudit({
-          id: randomUUID19(),
+          id: randomUUID20(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "device.update",
           payload: { deviceId: payload.id }
@@ -39004,7 +40122,7 @@ function createDeviceMethods(ctx) {
           throw new Error("Device not found");
         }
         await storage.appendAudit({
-          id: randomUUID19(),
+          id: randomUUID20(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "device.revoke",
           payload: { deviceId: payload.id }
@@ -39069,7 +40187,7 @@ function createDeviceMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/pairings.js
-import { randomBytes as randomBytes4, randomUUID as randomUUID20 } from "node:crypto";
+import { randomBytes as randomBytes4, randomUUID as randomUUID21 } from "node:crypto";
 
 // apps/gateway/dist/auth/pairing.js
 import { createHmac as createHmac2, randomBytes as randomBytes3 } from "node:crypto";
@@ -39175,7 +40293,7 @@ function createPairingMethods(ctx) {
         const now = /* @__PURE__ */ new Date();
         const seed = randomBytes4(32).toString("hex");
         const record = {
-          id: randomUUID20(),
+          id: randomUUID21(),
           seed,
           name: payload?.name,
           type: payload?.type,
@@ -39228,7 +40346,7 @@ function createPairingMethods(ctx) {
         if (record.claimed?.deviceId) {
           throw new Error("Pairing already claimed");
         }
-        const deviceId = payload.deviceId ?? randomUUID20();
+        const deviceId = payload.deviceId ?? randomUUID21();
         const publicKeyAlgorithm = payload.publicKeyAlgorithm === "p256" ? "p256" : "ed25519";
         record.claimed = {
           deviceId,
@@ -39275,7 +40393,7 @@ function createPairingMethods(ctx) {
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const device = {
-          id: record.claimed.deviceId ?? randomUUID20(),
+          id: record.claimed.deviceId ?? randomUUID21(),
           name: record.claimed.name ?? record.name,
           type: record.claimed.type ?? record.type,
           role: record.claimed.role ?? record.role,
@@ -39291,7 +40409,7 @@ function createPairingMethods(ctx) {
         };
         await storage.createDevice(device);
         await storage.appendAudit({
-          id: randomUUID20(),
+          id: randomUUID21(),
           time: now,
           type: "pairing.approve",
           payload: { pairingId: record.id, deviceId: device.id }
@@ -39314,7 +40432,7 @@ function createPairingMethods(ctx) {
         }
         pairingStore.delete(payload.id);
         await storage.appendAudit({
-          id: randomUUID20(),
+          id: randomUUID21(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "pairing.reject",
           payload: { pairingId: payload.id }
@@ -39326,7 +40444,7 @@ function createPairingMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/channel-pairings.js
-import { randomBytes as randomBytes5, randomUUID as randomUUID21 } from "node:crypto";
+import { randomBytes as randomBytes5, randomUUID as randomUUID22 } from "node:crypto";
 function createChannelPairingMethods(ctx) {
   const { runtime, deps, requireAdmin: requireAdmin2 } = ctx;
   const { storage, sendChannelMessage } = runtime;
@@ -39355,7 +40473,7 @@ function createChannelPairingMethods(ctx) {
         const now = Date.now();
         const seed = randomBytes5(32).toString("hex");
         const record = {
-          id: randomUUID21(),
+          id: randomUUID22(),
           channel,
           seed,
           note: payload?.note,
@@ -39391,7 +40509,7 @@ function createChannelPairingMethods(ctx) {
           note: record.note
         });
         await storage.appendAudit({
-          id: randomUUID21(),
+          id: randomUUID22(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "channel.pairing.approve",
           payload: {
@@ -39420,7 +40538,7 @@ function createChannelPairingMethods(ctx) {
         }
         channelPairingStore.delete(payload.id);
         await storage.appendAudit({
-          id: randomUUID21(),
+          id: randomUUID22(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "channel.pairing.reject",
           payload: { pairingId: payload.id, channel: record.channel }
@@ -39435,7 +40553,7 @@ function createChannelPairingMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/channel-allowlists.js
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 function createChannelAllowlistMethods(ctx) {
   const { runtime, requireAdmin: requireAdmin2 } = ctx;
   const { storage, sendChannelMessage } = runtime;
@@ -39461,7 +40579,7 @@ function createChannelAllowlistMethods(ctx) {
           throw new Error("Allow record not found");
         }
         await storage.appendAudit({
-          id: randomUUID22(),
+          id: randomUUID23(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "channel.allow.revoke",
           payload: {
@@ -39479,7 +40597,7 @@ function createChannelAllowlistMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/approvals.js
-import { randomUUID as randomUUID23 } from "node:crypto";
+import { randomUUID as randomUUID24 } from "node:crypto";
 function createApprovalMethods(ctx) {
   const { runtime, deps, requireAdmin: requireAdmin2 } = ctx;
   const { storage, connectionAuth, broadcastEvent, sendChannelMessage, maybeAppendSmritiMemory } = runtime;
@@ -39545,7 +40663,7 @@ function createApprovalMethods(ctx) {
           });
           if (rejected) {
             await storage.appendAudit({
-              id: randomUUID23(),
+              id: randomUUID24(),
               time: now.toISOString(),
               type: "approval.reject",
               payload: {
@@ -39568,7 +40686,7 @@ function createApprovalMethods(ctx) {
         });
         if (approved) {
           await storage.appendAudit({
-            id: randomUUID23(),
+            id: randomUUID24(),
             time: now.toISOString(),
             type: "approval.approve",
             payload: {
@@ -39618,7 +40736,7 @@ function createApprovalMethods(ctx) {
         });
         if (updated) {
           await storage.appendAudit({
-            id: randomUUID23(),
+            id: randomUUID24(),
             time: (/* @__PURE__ */ new Date()).toISOString(),
             type: execution.ok ? "approval.fulfilled" : "approval.failed",
             payload: {
@@ -39638,7 +40756,7 @@ function createApprovalMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/providers.js
-import { randomUUID as randomUUID24 } from "node:crypto";
+import { randomUUID as randomUUID25 } from "node:crypto";
 import path20 from "node:path";
 
 // apps/gateway/dist/utils/errors.js
@@ -40004,10 +41122,10 @@ async function fetchOllamaModels(entry, providerId, logger) {
   return fetchModelList(providerId, entryWithBase, logger);
 }
 async function checkLocalProviders(params) {
-  const { entries, logger, update } = params;
+  const { entries: entries2, logger, update } = params;
   const reports = {};
   const now = () => (/* @__PURE__ */ new Date()).toISOString();
-  for (const [providerId, entry] of Object.entries(entries)) {
+  for (const [providerId, entry] of Object.entries(entries2)) {
     if (entry.type !== "ollama")
       continue;
     const required = resolveRequiredModels(entry);
@@ -40281,7 +41399,7 @@ function createProviderMethods(ctx) {
           });
         }
         await storage.appendAudit({
-          id: randomUUID24(),
+          id: randomUUID25(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "provider.ollama.autostart.set",
           payload: { enabled: payload.enabled }
@@ -40330,7 +41448,7 @@ function createProviderMethods(ctx) {
           meta: requestMeta
         });
         await storage.appendAudit({
-          id: randomUUID24(),
+          id: randomUUID25(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "provider.chat",
           payload: {
@@ -40908,7 +42026,7 @@ function createUsageMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/channels.js
-import { randomUUID as randomUUID25 } from "node:crypto";
+import { randomUUID as randomUUID26 } from "node:crypto";
 function createChannelMethods(ctx) {
   const { runtime } = ctx;
   const { config, providers, profile, updateProfile, broadcastEvent, storage, logger } = runtime;
@@ -40960,7 +42078,7 @@ function createChannelMethods(ctx) {
           });
           broadcastEvent("profile.updated", updated);
           await storage.appendAudit({
-            id: randomUUID25(),
+            id: randomUUID26(),
             time: (/* @__PURE__ */ new Date()).toISOString(),
             type: "channel.setModel",
             payload: {
@@ -40995,7 +42113,7 @@ function createChannelMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/models.js
-import { randomUUID as randomUUID26 } from "node:crypto";
+import { randomUUID as randomUUID27 } from "node:crypto";
 function createModelMethods(ctx) {
   const { runtime } = ctx;
   const { providers, updateProfile, broadcastEvent, storage } = runtime;
@@ -41019,7 +42137,7 @@ function createModelMethods(ctx) {
         });
         broadcastEvent("profile.updated", updated);
         await storage.appendAudit({
-          id: randomUUID26(),
+          id: randomUUID27(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "model.set",
           payload: {
@@ -41402,7 +42520,7 @@ import path21 from "node:path";
 
 // packages/storage/src/file/io.ts
 import fs18 from "node:fs";
-import { randomUUID as randomUUID27 } from "node:crypto";
+import { randomUUID as randomUUID28 } from "node:crypto";
 
 // packages/storage/src/file/types.ts
 var DEFAULT_STORE = {
@@ -41459,7 +42577,7 @@ var readJson2 = (path50, fallback) => {
   }
 };
 var writeJson = (path50, data2) => {
-  const tmp = `${path50}.${randomUUID27()}.tmp`;
+  const tmp = `${path50}.${randomUUID28()}.tmp`;
   fs18.writeFileSync(tmp, JSON.stringify(data2, null, 2), "utf8");
   fs18.renameSync(tmp, path50);
 };
@@ -41595,7 +42713,7 @@ var writeAgentQueueStore = (paths, store) => {
 
 // packages/storage/src/file/sessions.ts
 import fs19 from "node:fs";
-import { randomUUID as randomUUID28 } from "node:crypto";
+import { randomUUID as randomUUID29 } from "node:crypto";
 var createFileSessionStore = (paths) => {
   return {
     async getSessionByKey(key) {
@@ -41619,7 +42737,7 @@ var createFileSessionStore = (paths) => {
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const record = {
-        id: randomUUID28(),
+        id: randomUUID29(),
         key,
         createdAt: now,
         updatedAt: now,
@@ -41918,7 +43036,7 @@ var createFileDeviceStore = (paths) => {
 };
 
 // packages/storage/src/file/channels.ts
-import { randomUUID as randomUUID29 } from "node:crypto";
+import { randomUUID as randomUUID30 } from "node:crypto";
 var buildChannelKey = (channel, chatId, userId) => `${channel}:${chatId}:${userId ?? ""}`;
 var createFileChannelStore = (paths) => {
   return {
@@ -41959,7 +43077,7 @@ var createFileChannelStore = (paths) => {
         writeChannelStore(paths, store);
         return updated;
       }
-      const id = randomUUID29();
+      const id = randomUUID30();
       const entry = {
         id,
         channel: record.channel,
@@ -41994,13 +43112,13 @@ var createFileChannelStore = (paths) => {
 };
 
 // packages/storage/src/file/approvals.ts
-import { randomUUID as randomUUID30 } from "node:crypto";
+import { randomUUID as randomUUID31 } from "node:crypto";
 var createFileApprovalStore = (paths) => {
   return {
     async createApprovalRequest(request) {
       const store = readApprovalStore(paths);
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const id = request.id ?? randomUUID30();
+      const id = request.id ?? randomUUID31();
       const existing = store.requests[id];
       if (existing) {
         return existing;
@@ -42062,7 +43180,7 @@ var createFileApprovalStore = (paths) => {
 
 // packages/storage/src/file/tool-policy.ts
 import fs20 from "node:fs";
-import { randomUUID as randomUUID31 } from "node:crypto";
+import { randomUUID as randomUUID32 } from "node:crypto";
 var createFileToolPolicyStore = (paths) => {
   return {
     async getToolPolicy() {
@@ -42083,7 +43201,7 @@ var createFileToolPolicyStore = (paths) => {
         deny: policy.deny ?? [],
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      const tmp = `${paths.toolPolicyPath}.${randomUUID31()}.tmp`;
+      const tmp = `${paths.toolPolicyPath}.${randomUUID32()}.tmp`;
       fs20.writeFileSync(tmp, JSON.stringify(record, null, 2), "utf8");
       fs20.renameSync(tmp, paths.toolPolicyPath);
       return record;
@@ -42486,7 +43604,7 @@ var FileStorage = class {
 import path22 from "node:path";
 async function createStorage(options) {
   if (options.driver === "sqlite") {
-    const module = await import("./chunks/sqlite-JPF5TICX.js");
+    const module = await import("./chunks/sqlite-DHUQGPR5.js");
     const sqlitePath = options.sqlitePath ?? path22.join(options.dataDir, "vaayu.db");
     return new module.SqliteStorage({ sqlitePath });
   }
@@ -42494,7 +43612,7 @@ async function createStorage(options) {
     if (!options.postgresUrl) {
       throw new Error("Postgres driver requires postgresUrl");
     }
-    const module = await import("./chunks/postgres-3ZXBYTPC.js");
+    const module = await import("./chunks/postgres-WLH3D5HG.js");
     return module.PostgresStorage.create({ url: options.postgresUrl });
   }
   return new FileStorage({ dataDir: options.dataDir });
@@ -43130,14 +44248,14 @@ function createDualWriteStorage(opts) {
 }
 
 // apps/gateway/dist/rpc/methods/memories.js
-import { randomUUID as randomUUID32 } from "node:crypto";
+import { randomUUID as randomUUID33 } from "node:crypto";
 function createMemoryMethods(ctx) {
   const { runtime, deps, requireAdmin: requireAdmin2 } = ctx;
   const { storage, logger } = runtime;
   const pendingDeletes = /* @__PURE__ */ new Map();
   const pendingPurges = /* @__PURE__ */ new Map();
   const issuePurgeToken = (connectionId, payload) => {
-    const token = randomUUID32();
+    const token = randomUUID33();
     pendingPurges.set(token, {
       token,
       expiresAt: Date.now() + 5 * 60 * 1e3,
@@ -43379,7 +44497,7 @@ function createMemoryMethods(ctx) {
 
 // apps/gateway/dist/rpc/methods/proactives.js
 import path25 from "node:path";
-import { randomUUID as randomUUID33 } from "node:crypto";
+import { randomUUID as randomUUID34 } from "node:crypto";
 function createProactiveMethods(ctx) {
   const { runtime, deps, requireAdmin: requireAdmin2 } = ctx;
   const { storage, logger } = runtime;
@@ -43507,7 +44625,7 @@ function createProactiveMethods(ctx) {
           });
         }
         await storage.appendAudit({
-          id: randomUUID33(),
+          id: randomUUID34(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "proactive.config.set",
           payload: { proactive: parsed }
@@ -43526,7 +44644,7 @@ function createProactiveMethods(ctx) {
         }
         deps.proactiveManager.stop();
         await storage.appendAudit({
-          id: randomUUID33(),
+          id: randomUUID34(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "proactive.pause",
           payload: {}
@@ -43549,7 +44667,7 @@ function createProactiveMethods(ctx) {
         }
         deps.proactiveManager.start();
         await storage.appendAudit({
-          id: randomUUID33(),
+          id: randomUUID34(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "proactive.resume",
           payload: {}
@@ -43790,7 +44908,7 @@ var MAX_MESSAGE_SIZE = 1024 * 1024;
 var MAX_MESSAGE_SIZE2 = 20 * 1024;
 
 // packages/core/src/sync.ts
-import { randomUUID as randomUUID34 } from "node:crypto";
+import { randomUUID as randomUUID35 } from "node:crypto";
 import fs26 from "node:fs";
 import path28 from "node:path";
 var DEVICE_FILE = ".vaayu-device";
@@ -43806,7 +44924,7 @@ function getDeviceId(dataDir) {
     }
   } catch {
   }
-  const deviceId = `device_${randomUUID34().replace(/-/g, "").slice(0, 16)}`;
+  const deviceId = `device_${randomUUID35().replace(/-/g, "").slice(0, 16)}`;
   try {
     fs26.writeFileSync(devicePath, deviceId, "utf8");
   } catch {
@@ -44341,7 +45459,7 @@ function createSyncMethods(ctx) {
 }
 
 // apps/gateway/dist/rpc/methods/reactions.js
-import { randomUUID as randomUUID35 } from "node:crypto";
+import { randomUUID as randomUUID36 } from "node:crypto";
 function createReactionMethods(ctx) {
   const { runtime } = ctx;
   const { storage } = runtime;
@@ -44368,7 +45486,7 @@ function createReactionMethods(ctx) {
         }
         const reaction = storage.setMessageReaction(payload.sessionId, payload.messageId, payload.reaction);
         await storage.appendAudit({
-          id: randomUUID35(),
+          id: randomUUID36(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "message.react",
           payload: {
@@ -45202,7 +46320,7 @@ function resolveBridgeRequest(requestId, result) {
 }
 
 // apps/gateway/dist/gateway/bridge-registry.js
-import { randomUUID as randomUUID36 } from "node:crypto";
+import { randomUUID as randomUUID37 } from "node:crypto";
 var BridgeRegistry = class {
   bridges = /* @__PURE__ */ new Map();
   /** connectionId → bridgeId for fast lookup on disconnect. */
@@ -45212,7 +46330,7 @@ var BridgeRegistry = class {
    * Returns the generated bridge ID.
    */
   register(connectionId, manifest) {
-    const id = `bridge-${manifest.provider}-${randomUUID36().slice(0, 8)}`;
+    const id = `bridge-${manifest.provider}-${randomUUID37().slice(0, 8)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const bridge = {
       id,
@@ -45676,8 +46794,8 @@ function collectSkillPackDirs(root) {
   }
   const out = [];
   const stack = [];
-  const entries = fs28.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKILL_PACK_SKIP_DIRS.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
-  for (const entry of entries.reverse()) {
+  const entries2 = fs28.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKILL_PACK_SKIP_DIRS.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries2.reverse()) {
     stack.push(path30.join(root, entry.name));
   }
   while (stack.length) {
@@ -45911,7 +47029,7 @@ function handleSkillLogoByIdRequest(skillId, _req, res, repoRoot) {
 
 // apps/gateway/dist/routes/bandha.js
 var import_qrcode2 = __toESM(require_lib(), 1);
-import { randomBytes as randomBytes6, randomUUID as randomUUID37 } from "node:crypto";
+import { randomBytes as randomBytes6, randomUUID as randomUUID38 } from "node:crypto";
 var VALID_CHANNELS = /* @__PURE__ */ new Set([
   "telegram",
   "whatsapp",
@@ -45970,7 +47088,7 @@ function handleCreatePairing(req, res, channel, deps) {
     const now = Date.now();
     const seed = randomBytes6(32).toString("hex");
     const record = {
-      id: randomUUID37(),
+      id: randomUUID38(),
       channel,
       seed,
       note: payload?.note,
@@ -46025,7 +47143,7 @@ function handleCancelPairing(res, id, deps) {
   }
   deps.channelPairingStore.delete(id);
   deps.storage.appendAudit({
-    id: randomUUID37(),
+    id: randomUUID38(),
     time: (/* @__PURE__ */ new Date()).toISOString(),
     type: "bandha.pairing.cancelled",
     payload: { pairingId: id, channel: record.channel }
@@ -46053,7 +47171,7 @@ async function handleApprovePairing(res, id, deps) {
       note: record.note
     });
     await deps.storage.appendAudit({
-      id: randomUUID37(),
+      id: randomUUID38(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "bandha.pairing.approved",
       payload: {
@@ -46319,7 +47437,7 @@ function createHttpServer(state, repoRoot, methods, logger, healthOptions, bandh
 }
 
 // apps/gateway/dist/ws/setup.js
-import { randomUUID as randomUUID38, randomBytes as randomBytes7, createHash as createHash6 } from "node:crypto";
+import { randomUUID as randomUUID39, randomBytes as randomBytes7, createHash as createHash6 } from "node:crypto";
 
 // ../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -46341,7 +47459,7 @@ var SESSION_ID_METHOD_POLICY = {
   "message.react": { inferFromConnection: true },
   "message.reactions": { inferFromConnection: true }
 };
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function parseSessionId(raw) {
@@ -46363,12 +47481,12 @@ function rememberConnectionSession(metadata, sessionId) {
   metadata.lastSessionId = normalized;
 }
 function extractSessionIdFromResult(method, result) {
-  if (!isRecord(result))
+  if (!isRecord2(result))
     return void 0;
   if (method === "session.resolve" || method === "session.create" || method === "session.get") {
     return parseSessionId(result.id);
   }
-  if (method === "agent.run" && isRecord(result.session)) {
+  if (method === "agent.run" && isRecord2(result.session)) {
     return parseSessionId(result.session.id);
   }
   return void 0;
@@ -46381,7 +47499,7 @@ function resolveSessionScopedParams(params) {
   }
   const knownSessionCount = metadata?.sessionIds.size ?? 0;
   const canInfer = Boolean(policy.inferFromConnection && knownSessionCount === 1);
-  const payload = isRecord(rawParams) ? { ...rawParams } : {};
+  const payload = isRecord2(rawParams) ? { ...rawParams } : {};
   const rawSessionId = payload.sessionId;
   if (rawSessionId !== void 0 && rawSessionId !== null) {
     const explicitSessionId = parseSessionId(rawSessionId);
@@ -46508,7 +47626,7 @@ function setupWebSocket(params) {
   const connectionSessionMetadata = /* @__PURE__ */ new Map();
   const deviceActivityLog2 = getDeviceActivityLog();
   wss.on("connection", (socket, request) => {
-    const connectionId = randomUUID38();
+    const connectionId = randomUUID39();
     const remoteAddress = request.socket.remoteAddress;
     let isConnected = false;
     let eventSeq = 0;
@@ -46986,7 +48104,7 @@ memory.allowed=${memoryAllowed() ? "yes" : "no"}`;
 }
 
 // apps/gateway/dist/channel/telegram-slash-session.js
-import { randomUUID as randomUUID39 } from "node:crypto";
+import { randomUUID as randomUUID40 } from "node:crypto";
 async function handleSlashSession(ctx, commandName, commandArgs) {
   if (commandName !== "session")
     return null;
@@ -47011,7 +48129,7 @@ proactiveChannels=${channelLabel}`;
   if (["clear", "reset"].includes(sub)) {
     await storage.clearSessionPrefs(sessionId);
     await storage.appendAudit({
-      id: randomUUID39(),
+      id: randomUUID40(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.clear",
       payload: { sessionId, normalization }
@@ -47028,7 +48146,7 @@ proactiveChannels=${channelLabel}`;
         autoRouting: true
       });
       await storage.appendAudit({
-        id: randomUUID39(),
+        id: randomUUID40(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "session.prefs.set",
         payload: {
@@ -47051,7 +48169,7 @@ proactiveChannels=${channelLabel}`;
       autoRouting: false
     });
     await storage.appendAudit({
-      id: randomUUID39(),
+      id: randomUUID40(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.set",
       payload: {
@@ -47101,7 +48219,7 @@ proactiveChannels=${channelLabel}`;
       autoRouting: false
     });
     await storage.appendAudit({
-      id: randomUUID39(),
+      id: randomUUID40(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.set",
       payload: {
@@ -47130,7 +48248,7 @@ channels=${channelLabel}`;
         proactivePausedUntil: null
       });
       await storage.appendAudit({
-        id: randomUUID39(),
+        id: randomUUID40(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "session.prefs.set",
         payload: { sessionId, proactiveAllowed: updated.proactiveAllowed, normalization }
@@ -47144,7 +48262,7 @@ channels=${channelLabel}`;
         proactiveDeliver: false
       });
       await storage.appendAudit({
-        id: randomUUID39(),
+        id: randomUUID40(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "session.prefs.set",
         payload: { sessionId, proactiveAllowed: updated.proactiveAllowed, normalization }
@@ -47161,7 +48279,7 @@ channels=${channelLabel}`;
         proactivePausedUntil: until
       });
       await storage.appendAudit({
-        id: randomUUID39(),
+        id: randomUUID40(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "session.prefs.set",
         payload: { sessionId, proactivePausedUntil: updated.proactivePausedUntil, normalization }
@@ -47178,7 +48296,7 @@ channels=${channelLabel}`;
           proactiveAllowedChannels: null
         });
         await storage.appendAudit({
-          id: randomUUID39(),
+          id: randomUUID40(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: { sessionId, proactiveAllowedChannels: updated2.proactiveAllowedChannels, normalization }
@@ -47190,7 +48308,7 @@ channels=${channelLabel}`;
           proactiveAllowedChannels: []
         });
         await storage.appendAudit({
-          id: randomUUID39(),
+          id: randomUUID40(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "session.prefs.set",
           payload: { sessionId, proactiveAllowedChannels: updated2.proactiveAllowedChannels, normalization }
@@ -47205,7 +48323,7 @@ channels=${channelLabel}`;
         proactiveAllowedChannels: channels
       });
       await storage.appendAudit({
-        id: randomUUID39(),
+        id: randomUUID40(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "session.prefs.set",
         payload: { sessionId, proactiveAllowedChannels: updated.proactiveAllowedChannels, normalization }
@@ -47218,7 +48336,7 @@ channels=${channelLabel}`;
 }
 
 // apps/gateway/dist/channel/telegram-slash-routing.js
-import { randomUUID as randomUUID40 } from "node:crypto";
+import { randomUUID as randomUUID41 } from "node:crypto";
 async function handleSlashRouting(ctx, commandName, commandArgs) {
   const { runtime, config, telegramConfig, providers, storage, sessionId, broadcastEvent, updateProfile, appendPreferenceMemory, listProviderModels, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, inferProviderFromModel: inferProviderFromModel2 } = ctx;
   const clearSessionRoutingOverrides = async () => {
@@ -47353,7 +48471,7 @@ async function handleSlashRouting(ctx, commandName, commandArgs) {
       autoRouting: false
     });
     await storage.appendAudit({
-      id: randomUUID40(),
+      id: randomUUID41(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.set",
       payload: { sessionId }
@@ -47409,7 +48527,7 @@ autoRouting=${updated.autoRoutingDefault ? "on" : "off"}`;
   if (commandName === "reset") {
     await storage.clearSessionPrefs(sessionId);
     await storage.appendAudit({
-      id: randomUUID40(),
+      id: randomUUID41(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.clear",
       payload: { sessionId }
@@ -47429,7 +48547,7 @@ autoRouting=${updated.autoRoutingDefault ? "on" : "off"}`;
       autoRouting: commandArgs === "on"
     });
     await storage.appendAudit({
-      id: randomUUID40(),
+      id: randomUUID41(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "session.prefs.set",
       payload: {
@@ -47535,7 +48653,7 @@ function formatCubeResponse(output) {
 }
 
 // apps/gateway/dist/channel/telegram-tool-execution.js
-import { randomUUID as randomUUID41 } from "node:crypto";
+import { randomUUID as randomUUID42 } from "node:crypto";
 
 // apps/gateway/dist/formatters/weather.js
 function formatDuration(seconds) {
@@ -48078,10 +49196,10 @@ function summarizeUnknownValue(value) {
         return candidate.trim();
       }
     }
-    const entries = Object.entries(record).slice(0, 3);
-    if (!entries.length)
+    const entries2 = Object.entries(record).slice(0, 3);
+    if (!entries2.length)
       return "{}";
-    return entries.map(([k, v]) => `${k}=${summarizeUnknownValue(v)}`).join(", ");
+    return entries2.map(([k, v]) => `${k}=${summarizeUnknownValue(v)}`).join(", ");
   }
   return String(value);
 }
@@ -48404,7 +49522,7 @@ async function executeTelegramTool(input) {
   if (guardMessage) {
     if (storage) {
       await storage.appendAudit({
-        id: randomUUID41(),
+        id: randomUUID42(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "guardian.block",
         payload: {
@@ -48426,7 +49544,7 @@ async function executeTelegramTool(input) {
   });
   if (storage) {
     await storage.appendAudit({
-      id: randomUUID41(),
+      id: randomUUID42(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.invoke",
       payload: {
@@ -49567,7 +50685,7 @@ import fs31 from "node:fs";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { spawn as spawn5 } from "node:child_process";
-import { randomUUID as randomUUID42 } from "node:crypto";
+import { randomUUID as randomUUID43 } from "node:crypto";
 function sanitizeArtifactFileName(value) {
   const base = path33.basename(value || "file");
   const cleaned = base.replace(/[\u0000-\u001f\u007f]/g, "").replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
@@ -49620,7 +50738,7 @@ async function stageTelegramAttachment(params) {
   const baseName = sanitizeArtifactFileName(attachment.fileName ?? `${attachment.kind}-${attachment.id}`);
   const ext = inferAttachmentExtension(baseName, attachment.mimeType, attachment.kind);
   const finalName = ext ? `${baseName.replace(/\.[^.]+$/, "")}.${ext}` : baseName;
-  const localPath = path33.join(dir, `${Date.now()}-${attachment.kind}-${randomUUID42()}-${finalName}`);
+  const localPath = path33.join(dir, `${Date.now()}-${attachment.kind}-${randomUUID43()}-${finalName}`);
   await downloadToFile(url, localPath, 12e4);
   return { localPath, downloadUrl: url };
 }
@@ -49681,7 +50799,7 @@ function buildTelegramSystemPrompt(base, options) {
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function normalizeText2(value) {
+function normalizeText4(value) {
   return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u0000/g, "").trim();
 }
 function truncateTelegramText(value, maxChars) {
@@ -49738,7 +50856,7 @@ function renderMarkdownToTelegramHtml(value) {
   return escaped;
 }
 function formatTelegramReply(content, options = {}) {
-  const cleaned = normalizeText2(content || "");
+  const cleaned = normalizeText4(content || "");
   const tone = options.tone ?? "default";
   const includeHeader = options.includeHeader ?? false;
   const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
@@ -51517,10 +52635,10 @@ function registerAnrivaSkillTools(params) {
 }
 
 // apps/gateway/dist/gateway/kaala-setup.js
-import { randomUUID as randomUUID46 } from "node:crypto";
+import { randomUUID as randomUUID47 } from "node:crypto";
 
 // apps/agent-kaala/src/broker.ts
-import { randomUUID as randomUUID43 } from "node:crypto";
+import { randomUUID as randomUUID44 } from "node:crypto";
 var nowIso3 = () => (/* @__PURE__ */ new Date()).toISOString();
 var toErrorMessage2 = (error) => {
   if (!error) return "Unknown error";
@@ -51644,7 +52762,7 @@ function createKaalaBroker(deps, options) {
     if (existingId && tasks.has(existingId)) {
       return tasks.get(existingId).record;
     }
-    const id = existingId ?? randomUUID43();
+    const id = existingId ?? randomUUID44();
     const laneName = input.lane ?? options.defaultLane;
     const lane = getLane(laneName);
     const totalQueued = Array.from(lanes.values()).reduce(
@@ -52331,12 +53449,12 @@ function createKaalaHealthTracker(options) {
 }
 
 // apps/gateway/dist/kaala/audit.js
-import { randomUUID as randomUUID44 } from "node:crypto";
+import { randomUUID as randomUUID45 } from "node:crypto";
 async function appendKaalaAudit(storage, payload) {
   if (!storage.appendAudit)
     return;
   await storage.appendAudit({
-    id: randomUUID44(),
+    id: randomUUID45(),
     time: nowIso(),
     type: payload.type,
     payload: {
@@ -52777,7 +53895,7 @@ function createKaalaMonitor(params) {
 }
 
 // apps/gateway/dist/kaala/persist.js
-import { randomUUID as randomUUID45 } from "node:crypto";
+import { randomUUID as randomUUID46 } from "node:crypto";
 var toAgentRunRecord = (record) => {
   const metadata = record.metadata ?? {};
   const metadataWithPolicy = record.toolPolicy ? { ...metadata, toolPolicy: record.toolPolicy } : metadata;
@@ -52861,7 +53979,7 @@ function extractResultSummary(result) {
 }
 function buildEvent(event) {
   return {
-    id: randomUUID45(),
+    id: randomUUID46(),
     runId: event.taskId,
     time: event.time,
     type: event.type,
@@ -53647,7 +54765,7 @@ async function setupKaala(params) {
         if (!storage.appendAgentRunEvent)
           return;
         void storage.appendAgentRunEvent({
-          id: randomUUID46(),
+          id: randomUUID47(),
           runId: "kaala.health",
           time: snapshot.updatedAt,
           type: "health",
@@ -53768,7 +54886,7 @@ async function setupKaala(params) {
         expiresAt: new Date(now.getTime() + 9e5).toISOString()
       });
       await storage.appendAudit({
-        id: randomUUID46(),
+        id: randomUUID47(),
         time: now.toISOString(),
         type: "kaala.escalation.request",
         payload: {
@@ -53797,9 +54915,9 @@ async function setupKaala(params) {
 
 // packages/nlu/src/rules/text.ts
 var normalizePunctuation = (text) => text.replace(/^[,.;:]+|[,.;:]+$/g, "");
-var normalizeText3 = (text) => normalizePunctuation(text.trim()).replace(/\s+/g, " ").toLowerCase();
-function tokenize2(text) {
-  const normalized = normalizeText3(text);
+var normalizeText5 = (text) => normalizePunctuation(text.trim()).replace(/\s+/g, " ").toLowerCase();
+function tokenize3(text) {
+  const normalized = normalizeText5(text);
   if (!normalized) return [];
   return normalized.split(/\s+/).map((token) => token.replace(/[^a-z0-9]+/g, "")).filter(Boolean);
 }
@@ -53849,7 +54967,7 @@ function adjacentSwapAtMostOne(a, b) {
 }
 function fuzzyHasKeyword(text, keywords) {
   if (!text.trim()) return false;
-  const tokens = tokenize2(text);
+  const tokens = tokenize3(text);
   if (!tokens.length) return false;
   for (const token of tokens) {
     for (const keyword of keywords) {
@@ -53900,14 +55018,14 @@ var extractLocation = (text) => {
   return void 0;
 };
 var extractDays = (text) => {
-  const match = normalizeText3(text).match(/\b(\d{1,2})\s*(?:days|day)\b/i);
+  const match = normalizeText5(text).match(/\b(\d{1,2})\s*(?:days|day)\b/i);
   const raw = match?.[1];
   if (!raw) return void 0;
   const value = Number.parseInt(raw, 10);
   return Number.isFinite(value) ? value : void 0;
 };
 var extractHours = (text) => {
-  const match = normalizeText3(text).match(/\b(\d{1,2})\s*(?:hours|hour)\b/i);
+  const match = normalizeText5(text).match(/\b(\d{1,2})\s*(?:hours|hour)\b/i);
   const raw = match?.[1];
   if (!raw) return void 0;
   const value = Number.parseInt(raw, 10);
@@ -54016,7 +55134,7 @@ function parseIsoDateFromText(text) {
   return `${date}T${time}`;
 }
 function parseRelativeDueAt(text) {
-  const lower = normalizeText3(text);
+  const lower = normalizeText5(text);
   const match = lower.match(/\b(in|after)\s+(\d{1,2})\s*(hours|hour|days|day)\b/);
   if (!match?.[2] || !match?.[3]) return void 0;
   const value = Number.parseInt(match[2], 10);
@@ -54028,7 +55146,7 @@ function parseRelativeDueAt(text) {
   return now.toISOString();
 }
 function parseTomorrowOrTodayDueAt(text) {
-  const lower = normalizeText3(text);
+  const lower = normalizeText5(text);
   const hasTomorrow = /\btomorrow\b/.test(lower);
   const hasToday = /\btoday\b/.test(lower);
   if (!hasTomorrow && !hasToday) return void 0;
@@ -54143,7 +55261,7 @@ function normalizeTransitPlace(value) {
   return cleaned || void 0;
 }
 function parseTransitDepartureAt2(text) {
-  const normalized = normalizeText3(text);
+  const normalized = normalizeText5(text);
   const iso = normalized.match(/\b(\d{4}-\d{2}-\d{2})(?:[t\s](\d{2}:\d{2}))?\b/i);
   if (iso?.[1]) {
     const time = iso[2] ?? "09:00";
@@ -54219,7 +55337,7 @@ var buildReflection = (intent) => {
 // packages/nlu/src/rules.ts
 function interpretRules(request) {
   const rawText = request.text ?? "";
-  const normalized = normalizeText3(rawText);
+  const normalized = normalizeText5(rawText);
   if (!normalized) return null;
   if (isGreetingIntent(rawText)) {
     return {
@@ -56696,11 +57814,11 @@ function createGuardianRpcMethods(deps) {
      * Get audit log
      */
     "guardian.audit.list": async (params) => {
-      const entries = await guardian.getAuditLog({
+      const entries2 = await guardian.getAuditLog({
         userId: params.userId,
         limit: params.limit
       });
-      return { entries };
+      return { entries: entries2 };
     },
     /**
      * List authorized devices
@@ -57329,24 +58447,24 @@ function parseBoolean(value) {
 }
 function loadGatewayEnv(providerEntries) {
   const env = process.env;
-  const entries = providerEntries ?? {};
+  const entries2 = providerEntries ?? {};
   return {
     tts: {
-      minimax: env.VAAYU_MINIMAX_TTS_API_KEY || entries.minimax?.apiKey ? {
-        apiKey: env.VAAYU_MINIMAX_TTS_API_KEY ?? entries.minimax?.apiKey,
-        baseUrl: env.VAAYU_MINIMAX_TTS_BASE_URL ?? entries.minimax?.baseUrl,
+      minimax: env.VAAYU_MINIMAX_TTS_API_KEY || entries2.minimax?.apiKey ? {
+        apiKey: env.VAAYU_MINIMAX_TTS_API_KEY ?? entries2.minimax?.apiKey,
+        baseUrl: env.VAAYU_MINIMAX_TTS_BASE_URL ?? entries2.minimax?.baseUrl,
         path: env.VAAYU_MINIMAX_TTS_PATH,
         model: env.VAAYU_MINIMAX_TTS_MODEL,
         voice: env.VAAYU_MINIMAX_TTS_VOICE,
         emotion: env.VAAYU_MINIMAX_TTS_EMOTION
       } : void 0,
       openai: (() => {
-        const apiKey = env.VAAYU_OPENAI_TTS_API_KEY ?? env.OPENAI_TTS_API_KEY ?? env.OPENAI_API_KEY ?? env.VAAYU_OPENAI_API_KEY ?? entries.openai?.apiKey;
+        const apiKey = env.VAAYU_OPENAI_TTS_API_KEY ?? env.OPENAI_TTS_API_KEY ?? env.OPENAI_API_KEY ?? env.VAAYU_OPENAI_API_KEY ?? entries2.openai?.apiKey;
         if (!apiKey)
           return void 0;
         return {
           apiKey,
-          baseUrl: env.VAAYU_OPENAI_TTS_BASE_URL ?? entries.openai?.baseUrl,
+          baseUrl: env.VAAYU_OPENAI_TTS_BASE_URL ?? entries2.openai?.baseUrl,
           path: env.VAAYU_OPENAI_TTS_PATH,
           model: env.VAAYU_OPENAI_TTS_MODEL,
           voice: env.VAAYU_OPENAI_TTS_VOICE,
@@ -57596,7 +58714,7 @@ import { spawn as spawn6 } from "node:child_process";
 var _chitraguptaMemory = null;
 async function getChitraguptaMemory() {
   if (!_chitraguptaMemory) {
-    _chitraguptaMemory = await import("./chunks/src-QAXOD5SB.js");
+    _chitraguptaMemory = await import("./chunks/src-54LTTDTH.js");
   }
   return _chitraguptaMemory;
 }
@@ -58155,7 +59273,7 @@ function setupToolGuardian(params) {
 }
 
 // apps/gateway/dist/gateway/tool-execution.js
-import { randomUUID as randomUUID47 } from "node:crypto";
+import { randomUUID as randomUUID48 } from "node:crypto";
 function createToolExecutionHelpers(params) {
   const { storage, config, sessionIdentityMap, toolRegistry, toolPolicy, guardTool, broadcastEvent } = params;
   async function runTool(payload) {
@@ -58197,7 +59315,7 @@ function createToolExecutionHelpers(params) {
         }
       });
       await storage.appendAudit({
-        id: randomUUID47(),
+        id: randomUUID48(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "tool.policy_ephemeral_allow",
         payload: {
@@ -58222,7 +59340,7 @@ function createToolExecutionHelpers(params) {
       userId: payload.context?.userId ?? payload.session?.userId,
       channel: payload.context?.channel ?? payload.session?.channel,
       locale,
-      traceId: payload.context?.traceId ?? randomUUID47()
+      traceId: payload.context?.traceId ?? randomUUID48()
     };
     const guard = await guardTool({
       toolName: payload.name,
@@ -58240,7 +59358,7 @@ function createToolExecutionHelpers(params) {
         guardian: { decision: "blocked", reason }
       });
       await storage.appendAudit({
-        id: randomUUID47(),
+        id: randomUUID48(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "guardian.block",
         payload: {
@@ -58258,7 +59376,7 @@ function createToolExecutionHelpers(params) {
     }
     const result = await tool.handler(payload.input, ctx);
     await storage.appendAudit({
-      id: randomUUID47(),
+      id: randomUUID48(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.invoke",
       payload: {
@@ -58290,7 +59408,7 @@ function createToolExecutionHelpers(params) {
       expiresAt: new Date(now.getTime() + 6e5).toISOString()
     });
     await storage.appendAudit({
-      id: randomUUID47(),
+      id: randomUUID48(),
       time: now.toISOString(),
       type: "approval.request",
       payload: {
@@ -58345,7 +59463,7 @@ function createToolExecutionHelpers(params) {
       userId: request.userId,
       channel: request.channel,
       locale,
-      traceId: randomUUID47()
+      traceId: randomUUID48()
     };
     const guard = await guardTool({
       toolName: request.toolName,
@@ -58363,7 +59481,7 @@ function createToolExecutionHelpers(params) {
         guardian: { decision: "blocked", reason }
       });
       await storage.appendAudit({
-        id: randomUUID47(),
+        id: randomUUID48(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "guardian.block",
         payload: {
@@ -58388,7 +59506,7 @@ function createToolExecutionHelpers(params) {
       policy: approvalPolicyContext
     });
     await storage.appendAudit({
-      id: randomUUID47(),
+      id: randomUUID48(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.invoke",
       payload: {
@@ -58419,12 +59537,12 @@ function createToolExecutionHelpers(params) {
 }
 
 // apps/gateway/dist/gateway/tool-memory-commands.js
-import { randomUUID as randomUUID48 } from "node:crypto";
+import { randomUUID as randomUUID49 } from "node:crypto";
 function createMemoryCommandHandlers(params) {
   const { toolRegistry, toolPolicy, guardTool, storage, updateProfile, broadcastEvent, smritiHelpers, pendingMemoryDeletes } = params;
   const pendingMemoryPurges = /* @__PURE__ */ new Map();
   function issuePurgeToken(sessionId, ids, options) {
-    const token = randomUUID48();
+    const token = randomUUID49();
     const entry = {
       token,
       sessionId,
@@ -58528,7 +59646,7 @@ This token expires in 5 minutes.`
     if (!guard.allowed) {
       const reason = guard.response?.reason ?? "Guardian blocked this action.";
       await storage.appendAudit({
-        id: randomUUID48(),
+        id: randomUUID49(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "guardian.block",
         payload: {
@@ -58548,7 +59666,7 @@ This token expires in 5 minutes.`
       channel: payload.channel
     });
     await storage.appendAudit({
-      id: randomUUID48(),
+      id: randomUUID49(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.invoke",
       payload: {
@@ -58677,7 +59795,7 @@ This token expires in 5 minutes.`
       if (!guard2.allowed) {
         const reason = guard2.response?.reason ?? "Guardian blocked this action.";
         await storage.appendAudit({
-          id: randomUUID48(),
+          id: randomUUID49(),
           time: (/* @__PURE__ */ new Date()).toISOString(),
           type: "guardian.block",
           payload: {
@@ -58693,7 +59811,7 @@ This token expires in 5 minutes.`
       }
       const result2 = await tool.handler({ limit: 1 }, { sessionId: payload.sessionId, userId: payload.userId, channel: payload.channel });
       await storage.appendAudit({
-        id: randomUUID48(),
+        id: randomUUID49(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "tool.invoke",
         payload: {
@@ -58744,7 +59862,7 @@ This token expires in 5 minutes.`
     if (!guard.allowed) {
       const reason = guard.response?.reason ?? "Guardian blocked this action.";
       await storage.appendAudit({
-        id: randomUUID48(),
+        id: randomUUID49(),
         time: (/* @__PURE__ */ new Date()).toISOString(),
         type: "guardian.block",
         payload: {
@@ -58760,7 +59878,7 @@ This token expires in 5 minutes.`
     }
     const result = await searchTool.handler({ query: trimmed, limit: 3 }, { sessionId: payload.sessionId, userId: payload.userId, channel: payload.channel });
     await storage.appendAudit({
-      id: randomUUID48(),
+      id: randomUUID49(),
       time: (/* @__PURE__ */ new Date()).toISOString(),
       type: "tool.invoke",
       payload: {
@@ -58907,7 +60025,7 @@ function createWeatherDefaultsUpdater(params) {
 
 // apps/gateway/dist/channel/hub-format.js
 var DEFAULT_MAX_CHARS2 = 4e3;
-var normalizeText4 = (value) => value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u0000/g, "").trim();
+var normalizeText6 = (value) => value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\u0000/g, "").trim();
 var truncateText = (value, maxChars) => {
   if (value.length <= maxChars)
     return value;
@@ -58930,7 +60048,7 @@ var buildHeader2 = (assistantName) => {
   return `**${name}**`;
 };
 function formatHubReply(content, options = {}) {
-  const cleaned = normalizeText4(content || "");
+  const cleaned = normalizeText6(content || "");
   const tone = options.tone ?? "default";
   const includeHeader = options.includeHeader ?? false;
   const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS2;
@@ -61016,10 +62134,14 @@ function startSelfHealMonitor(params) {
   const { runtime, config, logger, smritiConfigured, monitorIntervalMs, repairCooldownMs, runOnStart } = params;
   const intervalMs = Math.max(1e4, monitorIntervalMs ?? config.broker.heartbeatMs ?? 15e3);
   const cooldownMs = Math.max(3e4, repairCooldownMs ?? intervalMs * 2);
+  const routerWindowMs = Math.max(3e4, intervalMs * 4);
+  const routerFallbackStormThreshold = 5;
+  const routerCooldownChurnThreshold = 4;
   const initialSmritiRetrieveEnabled = runtime.smriti?.retrieveEnabled !== false;
   let tickRunning = false;
   let kaalaDegraded = false;
   let smritiDegraded = false;
+  let routerDegraded = false;
   let lastKaalaRepairAt = 0;
   let lastSmritiRepairAt = 0;
   const emitServiceState = (service, status, reason) => {
@@ -61066,6 +62188,41 @@ function startSelfHealMonitor(params) {
     logger.info("self_heal_restored", { service: "smriti" });
     emitServiceState("smriti", "restored");
   };
+  const markRouterDegraded = (reason) => {
+    if (routerDegraded)
+      return;
+    routerDegraded = true;
+    logger.warn("self_heal_degraded", { service: "router", reason });
+    emitServiceState("router", "degraded", reason);
+  };
+  const markRouterRestored = () => {
+    if (!routerDegraded)
+      return;
+    routerDegraded = false;
+    logger.info("self_heal_restored", { service: "router" });
+    emitServiceState("router", "restored");
+  };
+  const evaluateRouterStorm = () => {
+    const now = Date.now();
+    const windowStart = now - routerWindowMs;
+    const recent = listRoutingTraces({ limit: 80 }).filter((row) => {
+      const timeMs = Date.parse(row.time);
+      return Number.isFinite(timeMs) && timeMs >= windowStart;
+    });
+    let fallbackCount = 0;
+    let cooldownCount = 0;
+    for (const row of recent) {
+      if (row.fallbackUsed) {
+        fallbackCount += 1;
+      }
+      const hasCooldownOverride = row.providerResolution?.overrides?.some((override) => override.type === "provider_cooldown_fallback") ?? false;
+      if (hasCooldownOverride || row.escalation?.reason === "all_candidates_cooling_down") {
+        cooldownCount += 1;
+      }
+    }
+    const unstable = fallbackCount >= routerFallbackStormThreshold || cooldownCount >= routerCooldownChurnThreshold;
+    return { unstable, fallbackCount, cooldownCount, sampleCount: recent.length };
+  };
   const maybeRepairKaala = async (reason) => {
     const now = Date.now();
     if (now - lastKaalaRepairAt < cooldownMs)
@@ -61128,6 +62285,14 @@ function startSelfHealMonitor(params) {
           }
         }
       }
+      const routerStorm = evaluateRouterStorm();
+      if (routerStorm.unstable) {
+        const reason = `fallback_storm:${routerStorm.fallbackCount}/cooldown_churn:${routerStorm.cooldownCount}`;
+        markRouterDegraded(reason);
+        await maybeRepairKaala(reason);
+      } else {
+        markRouterRestored();
+      }
     } catch (error) {
       logger.warn("self_heal_monitor_tick_failed", {
         error: error instanceof Error ? error.message : String(error)