@yugenlab/vaayu 0.1.11 → 0.1.12

package/gateway.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunks/chunk-IEKAYVA3.js";
 import {
   SqliteStorage
 } from "./chunks/chunk-EG37M4QL.js";
@@ -7,28 +8,30 @@ import {
   buildAgentTree,
   buildKaalaHealthNode
 } from "./chunks/chunk-G5VYCA6O.js";
-import "./chunks/chunk-VCUJES75.js";
-import "./chunks/chunk-JZTFJE7M.js";
-import "./chunks/chunk-F6RNEGFX.js";
-import "./chunks/chunk-QV4GPIPT.js";
-import "./chunks/chunk-W4PVGBUH.js";
-import "./chunks/chunk-7XV5ISV7.js";
-import "./chunks/chunk-IEKAYVA3.js";
+import "./chunks/chunk-TSOQ2CT3.js";
+import "./chunks/chunk-LJCT7UYP.js";
+import "./chunks/chunk-YRTGGYJU.js";
+import "./chunks/chunk-PZ4AQ22L.js";
+import "./chunks/chunk-HXHDP2PZ.js";
+import "./chunks/chunk-XP3NIH5F.js";
+import "./chunks/chunk-5E3ZS5SW.js";
+import "./chunks/chunk-26K6DS6N.js";
 import {
   IMessageAdapter,
   TelegramAdapter,
+  TringAdapter,
   TwitterAdapter,
   WhatsAppAdapter,
   generateMantra,
   require_lib,
   validateMantra
-} from "./chunks/chunk-G2QREGXK.js";
+} from "./chunks/chunk-R273KC7J.js";
 import {
   searchSessions
-} from "./chunks/chunk-3AYSJ7WB.js";
-import "./chunks/chunk-7AYYXHYZ.js";
-import "./chunks/chunk-LJUEMPLG.js";
-import "./chunks/chunk-D46QTN3G.js";
+} from "./chunks/chunk-GWYC7R2L.js";
+import "./chunks/chunk-Y6IZH6FT.js";
+import "./chunks/chunk-M2RLX5LU.js";
+import "./chunks/chunk-ARZCIITZ.js";
 import {
   addTurn,
   createSession,
@@ -38,18 +41,17 @@ import {
   listTurnsWithTimestamps,
   loadSession,
   updateSessionMeta
-} from "./chunks/chunk-ZYY6N3SP.js";
-import "./chunks/chunk-A3HOZBC5.js";
-import "./chunks/chunk-Z576WVLG.js";
-import "./chunks/chunk-V2ZIKDN4.js";
-import "./chunks/chunk-67DXWEKG.js";
-import "./chunks/chunk-2OBLQJYJ.js";
+} from "./chunks/chunk-FEDPZOZ5.js";
+import "./chunks/chunk-RVKTGKFD.js";
+import "./chunks/chunk-VEZ2DI2M.js";
+import "./chunks/chunk-H46F2Y6R.js";
+import "./chunks/chunk-KVQH4LE7.js";
 import {
   __commonJS,
   __export,
   __require,
   __toESM
-} from "./chunks/chunk-IGKYKEKT.js";
+} from "./chunks/chunk-NAQKA54E.js";
 
 // ../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
@@ -13080,8 +13082,8 @@ function createSessionLock() {
   const run = async (sessionId, fn, options) => {
     const previous = sessionLocks.get(sessionId)?.tail ?? Promise.resolve();
     let release;
-    const gate = new Promise((resolve) => {
-      release = resolve;
+    const gate = new Promise((resolve3) => {
+      release = resolve3;
     });
     sessionLocks.set(sessionId, { tail: gate });
     const controller = new AbortController();
@@ -16353,7 +16355,7 @@ async function runCodex(config, prompt, signal, dynamicSystemPrompt) {
     child.stdin.write(prompt);
     child.stdin.end();
   }
-  const code = await new Promise((resolve, reject) => {
+  const code = await new Promise((resolve3, reject) => {
     child.on("error", (err) => {
       clearTimeout(timer);
       if (err.code === "ENOENT") {
@@ -16366,7 +16368,7 @@ async function runCodex(config, prompt, signal, dynamicSystemPrompt) {
         reject(err);
       }
     });
-    child.on("close", (exitCode) => resolve(exitCode));
+    child.on("close", (exitCode) => resolve3(exitCode));
   });
   clearTimeout(timer);
   let output = null;
@@ -16517,7 +16519,7 @@ async function runClaudeCode(config, prompt, signal, dynamicSystemPrompt) {
     }
     signal.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
   }
-  const code = await new Promise((resolve, reject) => {
+  const code = await new Promise((resolve3, reject) => {
     child.on("error", (err) => {
       clearTimeout(timer);
       if (err.code === "ENOENT") {
@@ -16530,7 +16532,7 @@ async function runClaudeCode(config, prompt, signal, dynamicSystemPrompt) {
         reject(err);
       }
     });
-    child.on("close", (exitCode) => resolve(exitCode));
+    child.on("close", (exitCode) => resolve3(exitCode));
   });
   clearTimeout(timer);
   try {
@@ -17606,7 +17608,7 @@ var resolveOllamaBinary = (entry) => {
   return "ollama";
 };
 var fetchOllamaModelsFromCli = async (binPath, host) => {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     execFile(
       binPath,
       ["list"],
@@ -17621,16 +17623,16 @@ var fetchOllamaModelsFromCli = async (binPath, host) => {
         if (error) {
           const message = error instanceof Error ? error.message : String(error);
           const details = stderr?.toString().trim();
-          resolve({ error: details ? `${message} (${details})` : message });
+          resolve3({ error: details ? `${message} (${details})` : message });
           return;
         }
         const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
         if (lines.length <= 1) {
-          resolve({ models: [] });
+          resolve3({ models: [] });
           return;
         }
         const models = lines.slice(1).map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/)[0]).filter((model) => Boolean(model));
-        resolve({ models });
+        resolve3({ models });
       }
     );
   });
@@ -17672,8 +17674,8 @@ async function fetchModelList(providerId, entry, logger) {
   try {
     if (entry.type === "ollama") {
       const requestTimeoutMs2 = 8e3;
-      const sleep = (ms) => new Promise((resolve) => {
-        setTimeout(resolve, ms);
+      const sleep = (ms) => new Promise((resolve3) => {
+        setTimeout(resolve3, ms);
       });
       let lastError;
       let lastApiError;
@@ -19582,9 +19584,182 @@ function isToolAllowed(policy, toolName) {
 // packages/tools/src/mcp-manager.ts
 import fs7 from "node:fs";
 import path7 from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+
+// packages/tools/src/mcp-stdio-client.ts
 import { spawn as spawn3 } from "node:child_process";
+import { createInterface } from "node:readline";
+var McpStdioClient = class {
+  process = null;
+  reader = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  timeoutMs;
+  /* ── Reconnect state ─────────────────────────────────────────── */
+  maxReconnectAttempts;
+  reconnectAttempts = 0;
+  lastCommand = "";
+  lastArgs = [];
+  lastEnv;
+  constructor(options) {
+    this.timeoutMs = options?.timeoutMs ?? 15e3;
+    this.maxReconnectAttempts = options?.maxReconnectAttempts ?? 3;
+  }
+  /** Spawn the MCP server process and initialize JSON-RPC communication. */
+  async connect(command, args = [], env) {
+    this.lastCommand = command;
+    this.lastArgs = args;
+    this.lastEnv = env;
+    this.reconnectAttempts = 0;
+    const child = spawn3(command, args, {
+      stdio: ["pipe", "pipe", "ignore"],
+      env: { ...process.env, ...env ?? {} }
+    });
+    this.process = child;
+    this.reader = createInterface({ input: child.stdout });
+    this.reader.on("line", (line) => this.handleLine(line));
+    child.on("exit", () => {
+      for (const [id, pending] of this.pending) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("MCP server process exited"));
+        this.pending.delete(id);
+      }
+      this.process = null;
+    });
+    child.on("error", (err) => {
+      for (const [id, pending] of this.pending) {
+        clearTimeout(pending.timer);
+        pending.reject(err);
+        this.pending.delete(id);
+      }
+      this.process = null;
+    });
+    await this.call("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "vaayu-gateway", version: "0.1.0" }
+    });
+    this.writeLine(
+      JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
+    );
+  }
+  /** Send a JSON-RPC request and wait for the response. Auto-reconnects on dead process. */
+  async call(method, params) {
+    if (!this.connected && this.lastCommand) {
+      await this.reconnect();
+    }
+    if (!this.connected) {
+      throw new Error("McpStdioClient is not connected");
+    }
+    const id = this.nextId++;
+    const request = { jsonrpc: "2.0", id, method, params };
+    this.writeLine(JSON.stringify(request));
+    return new Promise((resolve3, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request timed out after ${this.timeoutMs}ms: ${method}`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve: resolve3, reject, timer });
+    });
+  }
+  /**
+   * Re-connect to the MCP server after a crash.
+   * Uses exponential backoff (100ms * 2^attempt). Throws after max attempts.
+   */
+  async reconnect() {
+    if (this.connected) return;
+    if (!this.lastCommand) {
+      throw new Error("Cannot reconnect: no previous connection params");
+    }
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      throw new Error(
+        `McpStdioClient reconnect failed after ${this.maxReconnectAttempts} attempts`
+      );
+    }
+    this.disconnect();
+    const backoffMs = 100 * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    await new Promise((r) => setTimeout(r, backoffMs));
+    await this.connect(this.lastCommand, this.lastArgs, this.lastEnv);
+  }
+  /**
+   * Check if the MCP server process is alive and responsive.
+   * Sends a lightweight tools/list ping. Returns false on any failure.
+   */
+  async isHealthy() {
+    if (!this.connected) return false;
+    try {
+      await this.listTools();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** List available tools from the MCP server. */
+  async listTools() {
+    const result = await this.call("tools/list");
+    return result.tools;
+  }
+  /** Call a tool by name with arguments. */
+  async callTool(name, args) {
+    return await this.call("tools/call", {
+      name,
+      arguments: args
+    });
+  }
+  /** Kill the child process and clean up. */
+  disconnect() {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("McpStdioClient disconnected"));
+      this.pending.delete(id);
+    }
+    if (this.process && !this.process.killed) {
+      this.process.kill("SIGTERM");
+    }
+    this.process = null;
+    if (this.reader) {
+      this.reader.close();
+      this.reader = null;
+    }
+  }
+  /** Whether the client is currently connected. */
+  get connected() {
+    return this.process !== null && !this.process.killed;
+  }
+  /** Handle an incoming NDJSON line from the MCP server stdout. */
+  handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (typeof parsed.id !== "number") return;
+    const pending = this.pending.get(parsed.id);
+    if (!pending) return;
+    this.pending.delete(parsed.id);
+    clearTimeout(pending.timer);
+    if (parsed.error) {
+      pending.reject(
+        new Error(`MCP error ${parsed.error.code}: ${parsed.error.message}`)
+      );
+    } else {
+      pending.resolve(parsed.result);
+    }
+  }
+  /** Write a single NDJSON line to the child process stdin. */
+  writeLine(data2) {
+    this.process?.stdin?.write(data2 + "\n");
+  }
+};
+
+// packages/tools/src/mcp-manager.ts
 var McpServerManager = class {
   servers = /* @__PURE__ */ new Map();
+  stdioClients = /* @__PURE__ */ new Map();
   logger;
   constructor(configs = [], options = {}) {
     this.logger = options.logger;
@@ -19628,19 +19803,42 @@ var McpServerManager = class {
       this.startServer(state);
     }
   }
+  /** Check health of all stdio clients. Returns map of serverId to healthy status. */
+  async healthCheck() {
+    const results = /* @__PURE__ */ new Map();
+    for (const [id, client] of this.stdioClients) {
+      try {
+        if (!client.connected) {
+          results.set(id, false);
+          continue;
+        }
+        await client.listTools();
+        results.set(id, true);
+      } catch {
+        results.set(id, false);
+        this.stdioClients.delete(id);
+      }
+    }
+    return results;
+  }
+  /** Stop all managed MCP server processes and disconnect stdio clients. */
   stopAll() {
     for (const state of this.servers.values()) {
       if (state.process && !state.process.killed) {
         state.process.kill("SIGTERM");
       }
     }
+    for (const [id, client] of this.stdioClients) {
+      client.disconnect();
+      this.stdioClients.delete(id);
+    }
   }
   startServer(state) {
     if (state.process && !state.process.killed) {
       return;
     }
     const { command, args, env, cwd } = state.config;
-    const child = spawn3(command, args ?? [], {
+    const child = spawn4(command, args ?? [], {
       cwd: cwd ?? process.cwd(),
       env: {
         ...process.env,
@@ -19718,6 +19916,7 @@ var McpServerManager = class {
           {
             method: "POST",
             headers: {
+              accept: "application/json",
               "content-type": "application/json",
               ...authToken ? { authorization: `Bearer ${authToken}` } : {}
             },
@@ -19729,6 +19928,16 @@ var McpServerManager = class {
             signal: ctx.signal
           }
         );
+        const contentType = response.headers.get("content-type") ?? "";
+        if (!contentType.toLowerCase().includes("application/json")) {
+          return {
+            ok: false,
+            error: {
+              code: "mcp_protocol_error",
+              message: `MCP HTTP response content-type mismatch: expected application/json, got ${contentType || "unknown"}`
+            }
+          };
+        }
         const data2 = await response.json().catch(() => null);
         if (!response.ok || !data2) {
           return {
@@ -19753,13 +19962,45 @@ var McpServerManager = class {
         };
       }
     }
-    return {
-      ok: false,
-      error: {
-        code: "mcp_unavailable",
-        message: "MCP invocation not wired yet"
+    return this.invokeViaStdio(state, toolName, input);
+  }
+  /** Invoke an MCP tool via stdio JSON-RPC. Lazily connects on first call. */
+  async invokeViaStdio(state, toolName, input) {
+    const serverId = state.config.id;
+    try {
+      let client = this.stdioClients.get(serverId);
+      if (!client || !client.connected) {
+        client = new McpStdioClient({ timeoutMs: 3e4 });
+        await client.connect(
+          state.config.command,
+          state.config.args ?? [],
+          state.config.env
+        );
+        this.stdioClients.set(serverId, client);
+        this.logger?.info("mcp_stdio_connected", { serverId });
       }
-    };
+      const result = await client.callTool(
+        toolName,
+        input ?? {}
+      );
+      const textContent = result.content?.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      if (result.isError) {
+        return {
+          ok: false,
+          error: { code: "mcp_tool_error", message: textContent || "Tool execution failed" }
+        };
+      }
+      return { ok: true, output: textContent || result };
+    } catch (error) {
+      this.stdioClients.delete(serverId);
+      return {
+        ok: false,
+        error: {
+          code: "mcp_stdio_error",
+          message: error instanceof Error ? error.message : "MCP stdio invocation failed"
+        }
+      };
+    }
   }
 };
 
@@ -19993,7 +20234,7 @@ async function loadSunCalc() {
     sunCalcCache = void 0;
   }
   try {
-    const mod = await import("./chunks/suncalc-NOHGYHDU.js");
+    const mod = await import("./chunks/suncalc-RM7URNUR.js");
     const candidates = [
       mod.default,
       mod["module.exports"],
@@ -23917,7 +24158,7 @@ function buildSkillTools(dataDir) {
           };
         }
         const driver = payload.driver ?? process.env.VAAYU_SANDBOX_DRIVER ?? "docker";
-        const { createSandboxRunner: createSandboxRunner2 } = await import("./chunks/src-6GVZTUH6.js");
+        const { createSandboxRunner: createSandboxRunner2 } = await import("./chunks/src-OPSDZEFI.js");
         const runner = createSandboxRunner2(driver);
         const result = await runner.run({
           command: "bash",
@@ -24591,6 +24832,330 @@ function registerBuiltinTools(registry, options = {}) {
   }
 }
 
+// packages/tools/src/skill-resolver.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+var EXEC_OPTS = {
+  encoding: "utf8",
+  timeout: 1e4,
+  stdio: ["ignore", "pipe", "ignore"]
+};
+var HIGH_RISK_PATTERNS2 = ["sudo ", "rm -rf", "eval(", "exec(", "child_process"];
+var MEDIUM_RISK_PATTERNS2 = ["chmod 777", "npm install"];
+var SkillResolver = class {
+  localRoot;
+  installDir;
+  logger;
+  constructor(options) {
+    this.localRoot = options?.localSkillsRoot ?? "ecosystem/skills";
+    this.installDir = options?.installDir ?? join(homedir(), ".chitragupta", "skills");
+    this.logger = options?.logger;
+  }
+  /**
+   * Search for skills matching an intent across all sources.
+   * Sources are checked in order: local registry, npm, GitHub.
+   */
+  async search(intent) {
+    const keywords = intent.toLowerCase().split(/\s+/).filter(Boolean);
+    if (keywords.length === 0) return [];
+    const results = [];
+    results.push(...this.searchLocal(keywords));
+    results.push(...this.searchNpm(keywords));
+    results.push(...this.searchGitHub(keywords));
+    return results;
+  }
+  /**
+   * Guard: validate skill safety before execution.
+   * Checks for dangerous code patterns and manifest validity.
+   */
+  guard(candidate) {
+    const warnings = [];
+    const blockedReasons = [];
+    if (candidate.manifestValid === false) {
+      blockedReasons.push("invalid_manifest: missing name or tools array");
+    }
+    if (candidate.source === "local") {
+      const skillPath = join(this.localRoot, candidate.name);
+      const patterns = this.scanFilePatterns(skillPath);
+      blockedReasons.push(...patterns.blocked);
+      warnings.push(...patterns.warnings);
+    }
+    return { safe: blockedReasons.length === 0, warnings, blockedReasons };
+  }
+  /**
+   * Install a skill candidate and return the installed skill info.
+   * Returns null on any failure.
+   */
+  async install(candidate) {
+    try {
+      const targetDir = join(this.installDir, candidate.name);
+      if (candidate.source === "npm") {
+        execSync(`npm install --prefix ${this.installDir} ${candidate.name}`, EXEC_OPTS);
+      } else if (candidate.source === "github" && candidate.url) {
+        execSync(`gh repo clone ${candidate.url} ${targetDir}`, EXEC_OPTS);
+      } else if (candidate.source === "local") {
+        return this.readInstalledSkill(join(this.localRoot, candidate.name), candidate);
+      } else {
+        this.logger?.warn("skill_install_unsupported_source", { source: candidate.source });
+        return null;
+      }
+      return this.readInstalledSkill(targetDir, candidate);
+    } catch (err) {
+      this.logger?.warn("skill_install_failed", {
+        name: candidate.name,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  /* ── Private: search sources ──────────────────────────────────── */
+  /** Scan local skills root for directories with SKILL.md or manifest.json. */
+  searchLocal(keywords) {
+    try {
+      if (!existsSync2(this.localRoot)) return [];
+      const entries2 = readdirSync(this.localRoot, { withFileTypes: true });
+      const candidates = [];
+      for (const entry of entries2) {
+        if (!entry.isDirectory()) continue;
+        const dirPath = join(this.localRoot, entry.name);
+        const hasSkillMd = existsSync2(join(dirPath, "SKILL.md"));
+        const hasManifest = existsSync2(join(dirPath, "manifest.json"));
+        if (!hasSkillMd && !hasManifest) continue;
+        const manifest = this.readManifest(dirPath);
+        const searchText = `${entry.name} ${manifest?.description ?? ""}`.toLowerCase();
+        const matches = keywords.some((kw) => searchText.includes(kw));
+        if (!matches) continue;
+        candidates.push({
+          name: entry.name,
+          source: "local",
+          description: typeof manifest?.description === "string" ? manifest.description : "",
+          version: typeof manifest?.version === "string" ? manifest.version : void 0,
+          manifestValid: this.isManifestValid(manifest)
+        });
+      }
+      return candidates;
+    } catch (err) {
+      this.logger?.warn("skill_search_local_failed", { error: err instanceof Error ? err.message : String(err) });
+      return [];
+    }
+  }
+  /** Search npm for chitragupta-skill packages matching keywords. */
+  searchNpm(keywords) {
+    try {
+      const keyword = keywords[0] ?? "";
+      const raw = execSync(`npm search chitragupta-skill-${keyword} --json 2>/dev/null`, EXEC_OPTS);
+      const parsed = JSON.parse(typeof raw === "string" ? raw : "[]");
+      if (!Array.isArray(parsed)) return [];
+      return parsed.slice(0, 10).map((pkg) => ({
+        name: pkg.name ?? "unknown",
+        source: "npm",
+        description: pkg.description ?? "",
+        version: pkg.version
+      }));
+    } catch (err) {
+      this.logger?.warn("skill_search_npm_failed", { error: err instanceof Error ? err.message : String(err) });
+      return [];
+    }
+  }
+  /** Search GitHub for repos with the chitragupta-skill topic. */
+  searchGitHub(keywords) {
+    try {
+      const raw = execSync(
+        `gh search repos --topic chitragupta-skill --json name,description,url --limit 5 2>/dev/null`,
+        EXEC_OPTS
+      );
+      const parsed = JSON.parse(typeof raw === "string" ? raw : "[]");
+      if (!Array.isArray(parsed)) return [];
+      const kw = keywords.join(" ").toLowerCase();
+      return parsed.filter((r) => `${r.name ?? ""} ${r.description ?? ""}`.toLowerCase().includes(kw)).map((r) => ({
+        name: r.name ?? "unknown",
+        source: "github",
+        description: r.description ?? "",
+        url: r.url
+      }));
+    } catch (err) {
+      this.logger?.warn("skill_search_github_failed", { error: err instanceof Error ? err.message : String(err) });
+      return [];
+    }
+  }
+  /* ── Private: helpers ─────────────────────────────────────────── */
+  /** Read and parse manifest.json from a skill directory. */
+  readManifest(dirPath) {
+    try {
+      const content = readFileSync(join(dirPath, "manifest.json"), "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /** Check whether a manifest has the required fields (name + tools array). */
+  isManifestValid(manifest) {
+    if (!manifest) return false;
+    return typeof manifest.name === "string" && Array.isArray(manifest.tools);
+  }
+  /** Scan files in a directory for dangerous patterns. */
+  scanFilePatterns(dirPath) {
+    const blocked = [];
+    const warnings = [];
+    try {
+      if (!existsSync2(dirPath)) return { blocked, warnings };
+      const files = readdirSync(dirPath).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+      for (const file of files) {
+        const content = readFileSync(join(dirPath, file), "utf8");
+        for (const pattern of HIGH_RISK_PATTERNS2) {
+          if (content.includes(pattern)) blocked.push(`${file}: contains '${pattern}'`);
+        }
+        for (const pattern of MEDIUM_RISK_PATTERNS2) {
+          if (content.includes(pattern)) warnings.push(`${file}: contains '${pattern}'`);
+        }
+      }
+    } catch (err) {
+      this.logger?.warn("skill_scan_patterns_failed", { dirPath, error: err instanceof Error ? err.message : String(err) });
+    }
+    return { blocked, warnings };
+  }
+  /** Read tool definitions from an installed skill's manifest. */
+  readInstalledSkill(skillPath, candidate) {
+    const manifest = this.readManifest(skillPath);
+    if (!manifest || !Array.isArray(manifest.tools)) return null;
+    const toolDefs = manifest.tools.map((t2) => ({
+      name: typeof t2.name === "string" ? t2.name : "unknown",
+      description: typeof t2.description === "string" ? t2.description : ""
+    }));
+    return { name: candidate.name, path: resolve(skillPath), source: candidate.source, toolDefinitions: toolDefs };
+  }
+};
+
+// packages/tools/src/skill-learner.ts
+var SkillLearner = class _SkillLearner {
+  /** In-memory feedback store (flushes to persistent storage when wired). */
+  feedback = [];
+  gaps = /* @__PURE__ */ new Map();
+  successCounts = /* @__PURE__ */ new Map();
+  failureCounts = /* @__PURE__ */ new Map();
+  gapThreshold;
+  promotionThreshold;
+  demotionThreshold;
+  logger;
+  constructor(options) {
+    this.gapThreshold = options?.gapThreshold ?? 3;
+    this.promotionThreshold = options?.promotionThreshold ?? 5;
+    this.demotionThreshold = options?.demotionThreshold ?? 3;
+    this.logger = options?.logger;
+  }
+  /** Record successful skill execution. */
+  recordSuccess(skillName, intent, sessionId, feedback) {
+    this.feedback.push({
+      skillName,
+      intent,
+      outcome: "success",
+      feedback,
+      sessionId,
+      timestamp: Date.now()
+    });
+    this.successCounts.set(skillName, (this.successCounts.get(skillName) ?? 0) + 1);
+    this.logger?.info("skill_success_recorded", { skillName, total: this.successCounts.get(skillName) });
+  }
+  /** Record skill failure or user rejection. */
+  recordFailure(skillName, intent, sessionId, reason) {
+    this.feedback.push({
+      skillName,
+      intent,
+      outcome: "failure",
+      feedback: reason,
+      sessionId,
+      timestamp: Date.now()
+    });
+    this.failureCounts.set(skillName, (this.failureCounts.get(skillName) ?? 0) + 1);
+    this.logger?.info("skill_failure_recorded", { skillName, reason, total: this.failureCounts.get(skillName) });
+  }
+  /** Record skill gap (no skill matched user intent). */
+  recordGap(intent, sessionId) {
+    const existing = this.gaps.get(intent);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existing) {
+      existing.occurrences += 1;
+      existing.lastSeen = now;
+      if (!existing.sessionIds.includes(sessionId)) existing.sessionIds.push(sessionId);
+    } else {
+      this.gaps.set(intent, { intent, occurrences: 1, firstSeen: now, lastSeen: now, sessionIds: [sessionId] });
+    }
+    this.feedback.push({
+      skillName: "",
+      intent,
+      outcome: "gap",
+      sessionId,
+      timestamp: Date.now()
+    });
+    this.logger?.info("skill_gap_recorded", { intent, occurrences: this.gaps.get(intent)?.occurrences });
+  }
+  /** Get skill gaps that have exceeded the occurrence threshold. */
+  getActionableGaps() {
+    const actionable = [];
+    for (const gap of this.gaps.values()) {
+      if (gap.occurrences >= this.gapThreshold) actionable.push(gap);
+    }
+    return actionable;
+  }
+  /** Evaluate whether a skill should be promoted (lab -> production). */
+  evaluatePromotion(skillName) {
+    return (this.successCounts.get(skillName) ?? 0) >= this.promotionThreshold;
+  }
+  /** Evaluate whether a skill should be demoted/disabled. */
+  evaluateDemotion(skillName) {
+    return (this.failureCounts.get(skillName) ?? 0) >= this.demotionThreshold;
+  }
+  /** Get raw feedback records for analysis. */
+  getFeedback() {
+    return this.feedback;
+  }
+  /** Reset counters (for testing or periodic cleanup). */
+  reset() {
+    this.feedback.length = 0;
+    this.gaps.clear();
+    this.successCounts.clear();
+    this.failureCounts.clear();
+  }
+  /** Wire 4: Serialize learner state for persistence. */
+  serialize() {
+    return {
+      feedback: [...this.feedback],
+      gaps: Object.fromEntries(this.gaps),
+      successCounts: Object.fromEntries(this.successCounts),
+      failureCounts: Object.fromEntries(this.failureCounts)
+    };
+  }
+  /** Wire 4: Restore from persisted snapshot. */
+  static restore(snapshot, options) {
+    const learner = new _SkillLearner(options);
+    for (const fb of snapshot.feedback) learner.feedback.push(fb);
+    for (const [intent, gap] of Object.entries(snapshot.gaps)) learner.gaps.set(intent, gap);
+    for (const [k, v] of Object.entries(snapshot.successCounts)) learner.successCounts.set(k, v);
+    for (const [k, v] of Object.entries(snapshot.failureCounts)) learner.failureCounts.set(k, v);
+    return learner;
+  }
+  /** Wire 4: Flush state to a JSON file for cross-restart persistence. */
+  async flush(filePath) {
+    const { writeFile, mkdir } = await import("node:fs/promises");
+    const { dirname: dirname4 } = await import("node:path");
+    await mkdir(dirname4(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(this.serialize(), null, 2), "utf-8");
+  }
+  /** Wire 4: Load state from a JSON file (best-effort). */
+  static async load(filePath, options) {
+    try {
+      const { readFile } = await import("node:fs/promises");
+      const raw = await readFile(filePath, "utf-8");
+      const snapshot = JSON.parse(raw);
+      return _SkillLearner.restore(snapshot, options);
+    } catch {
+      return null;
+    }
+  }
+};
+
 // apps/gateway/dist/agent/commands/skill-lifecycle.js
 async function handleSkillLifecycleCommand(params) {
   const { action, fromPath, deleteSource, ackRisk, notes, locale, session, message, storage, toolRegistry, toolPolicy, routingDecision, routingResult } = params;
@@ -26152,6 +26717,45 @@ function buildGreetingContinuationReply(params) {
   }
   return topic ? `${userPrefix}I'm still with you. We were on "${topic}". Want to continue from there?` : `${userPrefix}I'm still with you. Want to continue where we left off?`;
 }
+function buildRecentGreetingReply(params) {
+  const { userName, locale } = params;
+  const style = normalizeStyle(params.style);
+  const userPrefix = buildUserPrefix2(userName);
+  if (locale === "te") {
+    return `${userPrefix}\u0C07\u0C2A\u0C4D\u0C2A\u0C41\u0C21\u0C47 \u0C2E\u0C28\u0C02 hi \u0C1A\u0C46\u0C2A\u0C4D\u0C2A\u0C41\u0C15\u0C41\u0C28\u0C4D\u0C28\u0C3E\u0C02. \u0C28\u0C47\u0C28\u0C41 \u0C07\u0C15\u0C4D\u0C15\u0C21\u0C47 \u0C09\u0C28\u0C4D\u0C28\u0C3E\u0C28\u0C41 - \u0C07\u0C15 \u0C0F\u0C2E\u0C3F \u0C1A\u0C47\u0C26\u0C4D\u0C26\u0C3E\u0C02?`;
+  }
+  if (locale === "es") {
+    return `${userPrefix}Hace un momento ya nos saludamos. Sigo aqui contigo. Que hacemos ahora?`;
+  }
+  if (locale === "de") {
+    return `${userPrefix}Wir haben uns gerade eben schon begrusst. Ich bin da. Was machen wir als nachstes?`;
+  }
+  if (locale === "pl") {
+    return `${userPrefix}Przed chwila juz sie przywitalismy. Jestem tutaj. Co robimy dalej?`;
+  }
+  if (locale === "hi") {
+    return `${userPrefix}\u0905\u092D\u0940 \u0915\u0941\u091B \u092E\u093F\u0928\u091F \u092A\u0939\u0932\u0947 \u0939\u0940 \u0939\u092E\u0928\u0947 hi \u0915\u0939\u093E \u0925\u093E\u0964 \u092E\u0948\u0902 \u092F\u0939\u0940\u0902 \u0939\u0942\u0901, \u0905\u092C \u0915\u094D\u092F\u093E \u0915\u0930\u0947\u0902?`;
+  }
+  if (locale === "ja") {
+    return `${userPrefix}\u3055\u3063\u304D\u3082\u3046\u6328\u62F6\u3057\u305F\u3088\u3002\u79C1\u306F\u3053\u3053\u306B\u3044\u308B\u3002\u6B21\u306F\u4F55\u3059\u308B?`;
+  }
+  if (style === "professional") {
+    return `${userPrefix}We just greeted a moment ago. I'm here. How may I help now?`;
+  }
+  if (style === "direct") {
+    return `${userPrefix}We just said hi. I'm here. What's next?`;
+  }
+  if (style === "chatty") {
+    return `${userPrefix}Yep, we just said hi a moment ago. I'm right here with you. What are we doing next?`;
+  }
+  if (style === "sarcastic") {
+    return `${userPrefix}Yep, hi already happened a minute ago. Still here. What's the next move?`;
+  }
+  if (style === "flirty") {
+    return `${userPrefix}We just said hi a moment ago. I'm still with you. What shall we do next?`;
+  }
+  return `${userPrefix}We just said hi a moment ago. I'm here with you. What should we do next?`;
+}
 function buildAffectionReply(params) {
   const { userName, locale } = params;
   const style = normalizeStyle(params.style);
@@ -26531,20 +27135,24 @@ function buildConversationStyleSystem(params) {
 // apps/gateway/dist/agent/quick-response-smalltalk.js
 import { randomUUID as randomUUID7 } from "node:crypto";
 var RESUME_TOPIC_CUE_RE = /\b(continue|resume|pick\s+up|pick-up|where\s+we\s+left|left\s+off|carry\s+on|again|back\s+to|from\s+before|as\s+we\s+were|malli|phir)\b/i;
-var SMALLTALK_MODEL_PREFIX = "smalltalk.";
-function isSmalltalkResponseModel(model) {
-  if (typeof model !== "string")
-    return false;
-  return model.startsWith(SMALLTALK_MODEL_PREFIX);
-}
+var SAME_TURN_ECHO_MS = 2e4;
 function wantsTopicContinuationCue(text) {
   const trimmed = text.trim();
   if (!trimmed)
     return false;
   return RESUME_TOPIC_CUE_RE.test(trimmed);
 }
+function shouldSkipCurrentTurnEcho(params) {
+  const { content, trimmed, createdAt, now } = params;
+  if (content !== trimmed)
+    return false;
+  const createdAtMs = createdAt ? Date.parse(createdAt) : Number.NaN;
+  if (!Number.isFinite(createdAtMs))
+    return false;
+  return now - createdAtMs <= SAME_TURN_ECHO_MS;
+}
 async function resolveRecentTopicHint(params) {
-  const { isEstablishedSession, storage, session, trimmed, assistantName, isPureGreeting: isPureGreeting2, isPureAck: isPureAck2 } = params;
+  const { isEstablishedSession, storage, session, trimmed, assistantName, isPureGreeting: isPureGreeting2, isPureAck: isPureAck2, maxTopicAgeMs } = params;
   if (!isEstablishedSession)
     return void 0;
   try {
@@ -26559,6 +27167,7 @@ async function resolveRecentTopicHint(params) {
       if (event.role === "assistant" && pendingUserEvent) {
         candidates.push({
           content: pendingUserEvent.content.trim(),
+          createdAt: pendingUserEvent.createdAt,
           assistantModel: typeof event.metadata?.model === "string" ? event.metadata.model : void 0
         });
         pendingUserEvent = void 0;
@@ -26567,22 +27176,30 @@ async function resolveRecentTopicHint(params) {
     if (pendingUserEvent) {
       candidates.push({
         content: pendingUserEvent.content.trim(),
+        createdAt: pendingUserEvent.createdAt,
         assistantModel: void 0
       });
     }
-    let skippedCurrentTurn = false;
+    const now = Date.now();
     for (const candidate of [...candidates].reverse()) {
       const content = candidate.content;
       if (!content)
         continue;
-      if (!skippedCurrentTurn && content === trimmed) {
-        skippedCurrentTurn = true;
+      if (shouldSkipCurrentTurnEcho({
+        content,
+        trimmed,
+        createdAt: candidate.createdAt,
+        now
+      })) {
         continue;
       }
-      if (isPureGreeting2(content, assistantName) || isPureAck2(content, assistantName)) {
-        continue;
+      if (typeof maxTopicAgeMs === "number" && Number.isFinite(maxTopicAgeMs) && maxTopicAgeMs > 0) {
+        const candidateTime = candidate.createdAt ? Date.parse(candidate.createdAt) : Number.NaN;
+        if (Number.isFinite(candidateTime) && now - candidateTime > maxTopicAgeMs) {
+          continue;
+        }
       }
-      if (candidate.assistantModel && !isSmalltalkResponseModel(candidate.assistantModel)) {
+      if (isPureGreeting2(content, assistantName) || isPureAck2(content, assistantName)) {
         continue;
       }
       const topic = content.replace(/\s+/g, " ").replace(/[!?.,;:]+$/g, "");
@@ -26594,6 +27211,43 @@ async function resolveRecentTopicHint(params) {
   }
   return void 0;
 }
+function resolveContinuityWindowMs(windowMinutes) {
+  const minutes = Number.isFinite(windowMinutes) ? Math.max(1, Math.min(180, Number(windowMinutes))) : 8;
+  return minutes * 6e4;
+}
+async function resolveGreetingContinuityDecision(params) {
+  const { continuityEnabled, continuityWindowMinutes, isEstablishedSession, storage, session, trimmed, assistantName, isPureGreeting: isPureGreeting2, isPureAck: isPureAck2 } = params;
+  const hasResumeCue = wantsTopicContinuationCue(trimmed);
+  if (!isEstablishedSession)
+    return { continuation: hasResumeCue, repeatedGreeting: false };
+  if (!continuityEnabled && !hasResumeCue)
+    return { continuation: false, repeatedGreeting: false };
+  const windowMs = resolveContinuityWindowMs(continuityWindowMinutes);
+  const updatedAtMs = session.updatedAt ? Date.parse(session.updatedAt) : Number.NaN;
+  const now = Date.now();
+  const recentSessionActivity = Number.isFinite(updatedAtMs) && now - updatedAtMs <= windowMs;
+  if (!hasResumeCue) {
+    if (!continuityEnabled || !recentSessionActivity) {
+      return { continuation: false, repeatedGreeting: false };
+    }
+    const repeatedWindowMs = Math.min(windowMs, 2e4);
+    if (Number.isFinite(updatedAtMs) && now - updatedAtMs <= repeatedWindowMs) {
+      return { continuation: false, repeatedGreeting: true };
+    }
+    return { continuation: true, repeatedGreeting: false };
+  }
+  const topic = await resolveRecentTopicHint({
+    isEstablishedSession,
+    storage,
+    session,
+    trimmed,
+    assistantName,
+    isPureGreeting: isPureGreeting2,
+    isPureAck: isPureAck2,
+    maxTopicAgeMs: hasResumeCue ? void 0 : windowMs
+  });
+  return { continuation: true, repeatedGreeting: false, topic };
+}
 async function recordSmalltalkFastLane(params) {
   const { routingResult, storage, sessionId, locale, matched, mode, intent, confidence, threshold } = params;
   routingResult.smalltalkFastLane = {
@@ -26643,8 +27297,8 @@ async function maybeHandleSemanticSmalltalk(params) {
       preferEmbeddings: true
     }).catch(() => null);
     let timeoutHandle;
-    const timeoutPromise = new Promise((resolve) => {
-      timeoutHandle = setTimeout(() => resolve(SEMANTIC_TIMEOUT_SENTINEL), SEMANTIC_NLU_BUDGET_MS);
+    const timeoutPromise = new Promise((resolve3) => {
+      timeoutHandle = setTimeout(() => resolve3(SEMANTIC_TIMEOUT_SENTINEL), SEMANTIC_NLU_BUDGET_MS);
     });
     const interpretedOrTimeout = await Promise.race([
       interpretedPromise,
@@ -26778,7 +27432,6 @@ async function handleQuickResponses(params) {
   const mode = params.mode ?? "full";
   const locationAssignments = mode === "full" ? extractLocationAssignments2(message.text) : null;
   const isEstablishedSession = session.updatedAt !== session.createdAt;
-  const isMatureSession = isEstablishedSession && Date.now() - new Date(session.createdAt).getTime() > 3 * 6e4;
   const conversationStyle = resolveConversationStyle({
     sessionId: session.id,
     text: trimmed,
@@ -26791,6 +27444,12 @@ async function handleQuickResponses(params) {
       existing: profile.toneTags
     })
   };
+  if (conversationStyle.source === "explicit" && conversationStyle.changed && conversationStyle.style !== "default") {
+    const updated = updateProfile({ toneTags: profileForStyledReplies.toneTags ?? profile.toneTags });
+    broadcastEvent("profile.updated", updated);
+    void appendPreferenceMemory(`Tone: ${conversationStyle.style}`, ["preference", "style", "tone"]).catch(() => {
+    });
+  }
   const emitLocal = async (model, replyText) => {
     const reply = normalizeAgentReply(replyText);
     await appendAssistantEvent(storage, session.id, reply, {
@@ -26815,9 +27474,10 @@ async function handleQuickResponses(params) {
   const emitFastLaneHit = (mode2, intent) => emitSmalltalkFastLane({ matched: true, mode: mode2, intent, confidence: 1, threshold: 1 });
   const emitSmalltalk = async (kind) => {
     await emitFastLaneHit(kind === "greeting" ? "greeting_rule" : "ack_rule", kind === "greeting" ? "smalltalk.greeting" : "smalltalk.ack");
-    if (kind === "greeting" && (isMatureSession || wantsTopicContinuationCue(trimmed))) {
-      const hasResumeCue = wantsTopicContinuationCue(trimmed);
-      const topic = hasResumeCue ? await resolveRecentTopicHint({
+    if (kind === "greeting") {
+      const greetingContinuity = await resolveGreetingContinuityDecision({
+        continuityEnabled: params.continuity?.enabled ?? true,
+        continuityWindowMinutes: params.continuity?.windowMinutes,
         isEstablishedSession,
         storage,
         session,
@@ -26825,13 +27485,22 @@ async function handleQuickResponses(params) {
         assistantName: profile.assistantName,
         isPureGreeting: isPureGreeting2,
         isPureAck: isPureAck2
-      }) : void 0;
-      return emitLocal("smalltalk.greeting", buildGreetingContinuationReply({
-        userName: profile.userName?.trim(),
-        locale,
-        topic,
-        style: conversationStyle.style
-      }));
+      });
+      if (greetingContinuity.repeatedGreeting) {
+        return emitLocal("smalltalk.greeting", buildRecentGreetingReply({
+          userName: profile.userName?.trim(),
+          locale,
+          style: conversationStyle.style
+        }));
+      }
+      if (greetingContinuity.continuation) {
+        return emitLocal("smalltalk.greeting", buildGreetingContinuationReply({
+          userName: profile.userName?.trim(),
+          locale,
+          topic: greetingContinuity.topic,
+          style: conversationStyle.style
+        }));
+      }
     }
     return emitLocal(kind === "greeting" ? "smalltalk.greeting" : "smalltalk.ack", buildSmalltalkReply2(profileForStyledReplies, kind, message.channel, locale));
   };
@@ -30226,21 +30895,30 @@ function isAbortLikeError(error) {
   if (!error)
     return false;
   const textFrom = (value) => typeof value === "string" ? value : String(value ?? "");
+  const hasAbortMarker = (value) => /abort|aborted|aborterror|abortederror/i.test(value);
   if (error instanceof Error) {
     const name = textFrom(error.name);
     const message = textFrom(error.message);
-    if (/abort/i.test(name) || /abort|aborted/i.test(message))
+    if (hasAbortMarker(name) || hasAbortMarker(message))
+      return true;
+    const cause = error.cause;
+    if (cause && isAbortLikeError(cause))
       return true;
     return false;
   }
   if (typeof error === "string") {
-    return /abort|aborted/i.test(error);
+    return hasAbortMarker(error);
   }
   if (typeof error === "object" && error !== null) {
     const entry = error;
     const name = textFrom(entry.name);
     const message = textFrom(entry.message);
-    return /abort/i.test(name) || /abort|aborted/i.test(message);
+    const code = textFrom(entry.code);
+    if (hasAbortMarker(name) || hasAbortMarker(message) || hasAbortMarker(code))
+      return true;
+    if (entry.cause && isAbortLikeError(entry.cause))
+      return true;
+    return false;
   }
   return false;
 }
@@ -30931,8 +31609,21 @@ async function handleToolPlanning(params) {
     await appendAssistantEvent(storage, session.id, locationPrompt, { providerId: "tool", model: promptModel }, message);
     return buildEarlyResult(session, promptModel, locationPrompt, routingDecision, routingResult);
   }
+  let recommendedToolsForDecision = [];
+  if (chitraguptaBridge) {
+    try {
+      recommendedToolsForDecision = chitraguptaBridge.recommend(normalized.norm);
+    } catch {
+      recommendedToolsForDecision = [];
+    }
+  }
   const tool = toolRegistry.get(toolName);
   if (tool) {
+    const hasChosenRecommendation = recommendedToolsForDecision.includes(toolName);
+    const preferredTool = recommendedToolsForDecision.find((name) => name && name !== toolName);
+    if (!hasChosenRecommendation && preferredTool) {
+      chitraguptaBridge?.onSkillRejected(preferredTool, toolName);
+    }
     if (signal?.aborted) {
       return buildEarlyResult(session, "agent.aborted", t(locale, "system.request_cancelled"), routingDecision, routingResult);
     }
@@ -31879,12 +32570,24 @@ function resolveInitialProviderAndModel(params) {
         tier: terminalChain.tier
       });
     } else {
-      resolvedProviderId = "__template__";
-      capturedTemplateResponse = terminalChain.templateResponse;
-      logger.warn("provider_all_exhausted_template_fallback", {
-        sessionId,
-        templateResponse: terminalChain.templateResponse?.slice(0, 80)
-      });
+      const finalFallbackProviders = ["google", "openai"];
+      const configuredFallback = providers.list().find((provider) => finalFallbackProviders.includes(provider.id));
+      if (configuredFallback) {
+        resolvedProviderId = configuredFallback.id;
+        resolvedModel = void 0;
+        logger.warn("provider_resolved_via_final_template_fallback", {
+          sessionId,
+          fallbackProviderId: configuredFallback.id,
+          tier: terminalChain.tier
+        });
+      } else {
+        resolvedProviderId = "__template__";
+        capturedTemplateResponse = terminalChain.templateResponse;
+        logger.warn("provider_all_exhausted_template_fallback", {
+          sessionId,
+          templateResponse: terminalChain.templateResponse?.slice(0, 80)
+        });
+      }
     }
   }
   return {
@@ -36737,6 +37440,19 @@ function mapMargaComplexityToTier(complexity) {
     return "fast";
   return complexity === "complex" || complexity === "expert" ? "deep" : "fast";
 }
+async function resolveMargaDecisionLocalFirst(input) {
+  if (!input.autoRouting)
+    return null;
+  const localClassifier = input.localClassifier ?? ((text, hasTools) => classifyMessage(text, hasTools));
+  const localDecision = localClassifier(input.routingText, input.hasTools);
+  if (localDecision)
+    return localDecision;
+  return await input.runtime.chitraguptaBridge?.decideRoute({
+    message: input.routingText,
+    hasTools: input.hasTools,
+    bindingStrategy: "hybrid"
+  }) ?? null;
+}
 var MANAS_TYPE_THRESHOLDS = {
   system_command: 0.5,
   conversation: 0.5,
@@ -36749,6 +37465,31 @@ var MANAS_TYPE_THRESHOLDS = {
   agentic_task: 0.65
 };
 var MANAS_SHORTCIRCUIT_FALLBACK = 0.55;
+var DEFAULT_POLICY_SIDECAR_CONFIDENCE = {
+  minConfidenceForCautious: 0.7,
+  minConfidenceForDeny: 0.82,
+  minConfidenceForSafeFastLane: 0.55,
+  downgradePolicy: "standard"
+};
+function applyPolicySidecarConfidenceOverride(policyClassifier, config) {
+  if (policyClassifier.source !== "sidecar")
+    return policyClassifier;
+  if (policyClassifier.policy === "standard")
+    return policyClassifier;
+  const thresholds = { ...DEFAULT_POLICY_SIDECAR_CONFIDENCE, ...config ?? {} };
+  const minConfidence = policyClassifier.policy === "deny" ? thresholds.minConfidenceForDeny : policyClassifier.policy === "cautious" ? thresholds.minConfidenceForCautious : thresholds.minConfidenceForSafeFastLane;
+  if (policyClassifier.confidence >= minConfidence)
+    return policyClassifier;
+  const downgraded = thresholds.downgradePolicy;
+  return {
+    ...policyClassifier,
+    policy: downgraded,
+    reasons: [
+      ...policyClassifier.reasons ?? [],
+      `policy_confidence_override:${policyClassifier.policy}->${downgraded}:${policyClassifier.confidence.toFixed(2)}<${minConfidence.toFixed(2)}`
+    ]
+  };
+}
 async function resolveRoutingDecision(input) {
   const { routingText, locale, languageSource, autoRouting, sessionId, payload, prefs, profile, providers, config, runtime, deps, sessionRoute, hasPayloadOverride, sessionPinExpired, budgetPressure, latencyPreference, conversationStyleHint } = input;
   const activeSessionPin = !hasPayloadOverride && !sessionPinExpired && sessionRoute.pinProviderId ? {
@@ -36798,6 +37539,7 @@ async function resolveRoutingDecision(input) {
       };
     }
   }
+  policyClassifier = applyPolicySidecarConfidenceOverride(policyClassifier, config.routing.policySidecarConfidence);
   const naturalCommand = detectNaturalLanguageCommand(routingText, locale);
   const commandText = naturalCommand ?? payload.message.text;
   const command = parseCommand(commandText);
@@ -36812,11 +37554,12 @@ async function resolveRoutingDecision(input) {
     looksLikeRecentRecap: deps.looksLikeRecentRecap
   });
   const hasTools = runtime.toolRegistry.list().length > 0;
-  const margaDecision = autoRouting ? await runtime.chitraguptaBridge?.decideRoute({
-    message: routingText,
+  const margaDecision = await resolveMargaDecisionLocalFirst({
+    autoRouting,
+    routingText,
     hasTools,
-    bindingStrategy: "hybrid"
-  }) ?? classifyMessage(routingText, hasTools) : null;
+    runtime
+  });
   const margaRoutingDecision = autoRouting && margaDecision?.providerId && providers.get(margaDecision.providerId) ? {
     target: {
       providerId: margaDecision.providerId,
@@ -37357,8 +38100,8 @@ function buildObservationMask(toolName, lineCount, charCount, turnsAgo) {
 var DEFAULT_CHAT_ATTEMPT_TIMEOUT_MS = 15e3;
 var MIN_CHAT_ATTEMPT_TIMEOUT_MS = 1e3;
 var MAX_CHAT_ATTEMPT_TIMEOUT_MS = 12e4;
-var GENERAL_LOCAL_TIMEOUT_CAP_MS = 8e3;
-var SMALLTALK_LOCAL_TIMEOUT_CAP_MS = 3500;
+var GENERAL_LOCAL_TIMEOUT_CAP_MS = 6e3;
+var SMALLTALK_LOCAL_TIMEOUT_CAP_MS = 2500;
 var DEFAULT_CHAT_MAX_ATTEMPTS = 3;
 var MIN_CHAT_MAX_ATTEMPTS = 1;
 var MAX_CHAT_MAX_ATTEMPTS = 10;
@@ -37521,7 +38264,8 @@ async function runChatWithFallback(params) {
     listProviders: listProviders2,
     preferCliForConversation
   });
-  const maxAttempts = resolveChatMaxAttempts(config);
+  const configuredMaxAttempts = resolveChatMaxAttempts(config);
+  const maxAttempts = params.actionabilityKind === "smalltalk" || params.actionabilityKind === "general" ? Math.min(configuredMaxAttempts, 2) : configuredMaxAttempts;
   const attempts = builtAttempts;
   if (attempts.length > maxAttempts) {
     logger.info("provider_attempts_limited", {
@@ -38284,9 +39028,32 @@ function resolveSmalltalkProviderFallback(params) {
 
 // apps/gateway/dist/agent/loop-chat-result.js
 async function handleChatPhase(input) {
-  const { deps, session, payload, runSignal, runId, routingDecision, routingResult, actionability, margaDecision, resolvedProviderId, resolvedModel, semanticCacheCategory, semanticCacheRule, routingText, context, retrievalHits, retrievalDecision, normalizedOutboundMeta, combinedSystem, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, listProviderModels, profile, locale, toolPolicy, budgetFallbackTarget, maybeAppendSmritiMemorySafe, enqueueSmritiMemoryAppendSafe, allowMemory, memoryAllowed, memoryManager, stripModelThinking: stripModelThinking2, manasRouteHint } = input;
+  const { deps, session, payload, runSignal, runId, routingDecision, routingResult, actionability, margaDecision, resolvedProviderId, resolvedModel, semanticCacheCategory, semanticCacheRule, routingText, context, retrievalHits, retrievalDecision, normalizedOutboundMeta, combinedSystem, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, listProviderModels, profile, locale, conversationStyleHint, turiyaSignal, toolPolicy, budgetFallbackTarget, maybeAppendSmritiMemorySafe, enqueueSmritiMemoryAppendSafe = maybeAppendSmritiMemorySafe, allowMemory, memoryAllowed, memoryManager, stripModelThinking: stripModelThinking2, manasRouteHint } = input;
   const { runtime, formatProviderError: formatProviderError2, lastAnthropicCallAt } = deps;
   const { config, logger, storage, providers, getProvider } = runtime;
+  const profileForConversationalFallback = conversationStyleHint && conversationStyleHint !== "default" ? {
+    ...profile,
+    toneTags: styleToToneTags({
+      style: conversationStyleHint,
+      existing: profile.toneTags
+    })
+  } : profile;
+  const emitTuriyaOutcome = (reward, context2) => {
+    if (!runtime.chitraguptaBridge || !turiyaSignal?.tier)
+      return;
+    const boundedReward = Number(Math.max(-1, Math.min(1, reward)).toFixed(4));
+    const outcomeContext = {
+      confidence: Number(turiyaSignal.confidence.toFixed(4)),
+      costEstimate: Number(turiyaSignal.costEstimate.toFixed(4)),
+      ...context2 ?? {}
+    };
+    void runtime.chitraguptaBridge.recordTuriyaOutcome({
+      tier: turiyaSignal.tier,
+      reward: boundedReward,
+      context: outcomeContext
+    }).catch(() => {
+    });
+  };
   if (margaDecision?.skipLLM) {
     logger.info("marga_skip_llm", {
       sessionId: session.id,
@@ -38294,7 +39061,7 @@ async function handleChatPhase(input) {
       complexity: margaDecision.complexity
     });
     const skipKind = margaDecision.taskType === "heartbeat" ? "ack" : "greeting";
-    const skipContent = deps.buildSmalltalkReply(runtime.profile, skipKind, payload.message.channel, locale);
+    const skipContent = deps.buildSmalltalkReply(profileForConversationalFallback, skipKind, payload.message.channel, locale);
     const skipModel = `marga:${margaDecision.taskType}`;
     await appendAssistantEvent(storage, session.id, skipContent, {
       providerId: "marga",
@@ -38312,6 +39079,7 @@ async function handleChatPhase(input) {
     });
     routingResult.selected = { providerId: "marga", model: skipModel };
     routingResult.fallbackUsed = false;
+    emitTuriyaOutcome(0.95, { margaSkip: 1, providerFailure: 0, fallbackUsed: 0 });
     return buildEarlyResult(session, skipModel, skipContent, routingDecision, routingResult);
   }
   if (!margaDecision?.skipLLM && manasRouteHint?.action === "skip_llm") {
@@ -38377,6 +39145,7 @@ async function handleChatPhase(input) {
     }, payload.message);
     routingResult.selected = cached2.selected;
     routingResult.fallbackUsed = false;
+    emitTuriyaOutcome(0.8, { semanticCacheHit: 1, providerFailure: 0, fallbackUsed: 0 });
     return buildEarlyResult(session, cacheModel, cached2.responseContent, routingDecision, routingResult);
   }
   const agenticTools = runtime.toolRegistry.list().filter((t2) => deps.isToolAllowed(toolPolicy, t2.name)).filter((t2) => !t2.name.startsWith("memory.")).map((t2) => ({
@@ -38443,7 +39212,8 @@ async function handleChatPhase(input) {
       routingResult.fallbackUsed = false;
       return buildEarlyResult(session, recoveryModel, recoveryContent, routingDecision, routingResult);
     }
-    const effectiveActionability = inferSmalltalkActionability(actionability, payload.message.text, profile, { isPureGreeting: deps.isPureGreeting, isPureAck: deps.isPureAck }, margaDecision);
+    const inferredActionability = inferSmalltalkActionability(actionability, payload.message.text, profile, { isPureGreeting: deps.isPureGreeting, isPureAck: deps.isPureAck }, margaDecision);
+    const effectiveActionability = inferredActionability.kind === "smalltalk" || margaDecision?.taskType !== "smalltalk" ? inferredActionability : { kind: "smalltalk", reason: "smalltalk_greeting" };
     if (escalation.reason !== "request_aborted" && effectiveActionability.kind !== "smalltalk") {
       const degradedToolResult = await handleToolPlanning({
         session,
@@ -38493,14 +39263,38 @@ async function handleChatPhase(input) {
       });
       if (degradedToolResult) {
         routingResult.escalation = escalation;
+        emitTuriyaOutcome(0.3, { degradedToolRecovery: 1, providerFailure: 1, fallbackUsed: 1 });
         return degradedToolResult;
       }
+      if (actionability.kind === "tool" || routingResult.actionability?.kind === "tool") {
+        const recoveryContent = "I'm in recovery mode right now and can still run deterministic tools. Try a direct ask like weather, forecast, notes, reminders, or time.";
+        const recoveryModel = "tool.recovery";
+        routingResult.escalation = escalation;
+        await appendAssistantEvent(storage, session.id, recoveryContent, {
+          providerId: "tool",
+          model: recoveryModel
+        }, payload.message);
+        await maybeAppendSmritiMemorySafe({
+          userText: payload.message.text,
+          assistantText: recoveryContent,
+          sessionId: session.id,
+          channel: payload.message.channel,
+          chatId: payload.message.chatId,
+          userId: payload.message.userId,
+          providerId: "tool",
+          model: recoveryModel
+        });
+        routingResult.selected = { providerId: "tool", model: recoveryModel };
+        routingResult.fallbackUsed = false;
+        emitTuriyaOutcome(0.15, { toolRecoveryPrompt: 1, providerFailure: 1, fallbackUsed: 1 });
+        return buildEarlyResult(session, recoveryModel, recoveryContent, routingDecision, routingResult);
+      }
     }
     const smalltalkFallback = resolveSmalltalkProviderFallback({
       actionability: effectiveActionability,
       escalation,
       buildSmalltalkReply: deps.buildSmalltalkReply,
-      profile,
+      profile: profileForConversationalFallback,
       channel: payload.message.channel,
       locale
     });
@@ -38522,6 +39316,7 @@ async function handleChatPhase(input) {
       });
       routingResult.selected = { providerId: "local", model: smalltalkFallback.model };
       routingResult.fallbackUsed = false;
+      emitTuriyaOutcome(0.25, { smalltalkFallback: 1, providerFailure: 1, fallbackUsed: 1 });
       return buildEarlyResult(session, smalltalkFallback.model, smalltalkFallback.content, routingDecision, routingResult);
     }
     const content = chatResult.friendlyMessage ? chatResult.friendlyMessage : formatProviderError2(chatResult.error ?? new Error("Provider failed"));
@@ -38543,12 +39338,13 @@ async function handleChatPhase(input) {
     });
     routingResult.selected = { providerId: "error", model: errorModel };
     routingResult.fallbackUsed = false;
+    emitTuriyaOutcome(-1, { errorEscalation: 1, providerFailure: 1, fallbackUsed: 1 });
     return buildEarlyResult(session, errorModel, content, routingDecision, routingResult);
   }
   const { response, provider, model, fallbackUsed } = chatResult;
   let finalResponse = response;
   if (response.toolCalls?.length && agenticTools.length > 0) {
-    const { runAgenticToolLoop } = await import("./chunks/agentic-tool-loop-O3NUV7KG.js");
+    const { runAgenticToolLoop } = await import("./chunks/agentic-tool-loop-NQESOBLC.js");
     const agenticResult = await runAgenticToolLoop({
       toolCalls: response.toolCalls,
       initialContent: response.content,
@@ -38616,6 +39412,11 @@ async function handleChatPhase(input) {
       }
     });
   }
+  emitTuriyaOutcome(fallbackUsed ? 0.55 : 1, {
+    providerFailure: 0,
+    fallbackUsed: fallbackUsed ? 1 : 0,
+    semanticCacheWrite: cacheStored ? 1 : 0
+  });
   return finalizeChatRun({
     storage,
     session,
@@ -38664,11 +39465,11 @@ async function executeAgentRun(params) {
   const { deps, session, payload, runId, sessionRoute, runSignal } = params;
   const { runtime, stripModelThinking: stripModelThinking2, formatProviderError: formatProviderError2, buildProfileSystemPrompt: buildProfileSystemPrompt2, smritiAutoMemoryReady, smritiAutoMemorySessions, runSmritiAutoMemoryScript, smritiClient, smritiRetrieveEnabled, smritiRetrieveLimit, listProviderModels, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, inferProviderFromModel: inferProviderFromModel2, lastAnthropicCallAt, memoryManager } = deps;
   const { config, logger, storage, providers, soulPrompt, getProvider, memoryAllowed, maybeAppendSmritiMemory, enqueueSmritiMemoryAppend } = runtime;
-  const normalizationFromMessage = payload.message.normalization;
-  const normalizedIncoming = normalizeIncomingText(payload.message.text ?? "");
-  const hasMatchingNormalization = normalizationFromMessage?.audit?.raw === normalizedIncoming.raw && normalizationFromMessage?.audit?.norm === normalizedIncoming.norm;
-  const normalizedAuditContext = hasMatchingNormalization && normalizationFromMessage?.audit ? normalizationFromMessage.audit : buildNormalizationAuditContext(normalizedIncoming);
-  const normalizedOutboundMeta = hasMatchingNormalization && normalizationFromMessage?.outbound ? normalizationFromMessage.outbound : buildNormalizationOutboundMeta(normalizedIncoming);
+  const normFrom = payload.message.normalization;
+  const normInc = normalizeIncomingText(payload.message.text ?? "");
+  const normMatch = normFrom?.audit?.raw === normInc.raw && normFrom?.audit?.norm === normInc.norm;
+  const normalizedAuditContext = normMatch && normFrom?.audit ? normFrom.audit : buildNormalizationAuditContext(normInc);
+  const normalizedOutboundMeta = normMatch && normFrom?.outbound ? normFrom.outbound : buildNormalizationOutboundMeta(normInc);
   const routingText = normalizedAuditContext.norm || payload.message.text;
   const retrievalText = normalizedAuditContext.search || normalizedAuditContext.norm || payload.message.text;
   const message = {
@@ -38768,16 +39569,8 @@ async function executeAgentRun(params) {
   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)
-      });
+    void storage.setSessionRoute(session.id, { agentId: sessionRoute.agentId, laneId: sessionRoute.laneId, queueMode: sessionRoute.queueMode, announceMode: sessionRoute.announceMode }).catch((e) => {
+      logger.warn("session_route_pin_clear_failed", { sessionId: session.id, error: e instanceof Error ? e.message : String(e) });
     });
   }
   const earlyBudgetState = await evaluateBudgetState({ storage, config, logger });
@@ -38816,7 +39609,7 @@ async function executeAgentRun(params) {
     latencyPreference,
     conversationStyleHint: earlyStyleHint !== "default" ? earlyStyleHint : void 0
   });
-  const { command, actionability, policyClassifier, margaDecision, routingDecision, complexitySignal, scoringResult, earlyRoutingResult, activeSessionPin, manasRouteHint, manasClassification, complexityProfile34 } = routing;
+  const { command, actionability, policyClassifier, margaDecision, routingDecision, complexitySignal, scoringResult, earlyRoutingResult, activeSessionPin, turiyaSignal, manasRouteHint, manasClassification, complexityProfile34 } = routing;
   if (!command) {
     const allowMemoryEarly = memoryAllowed() && payload.memoryMode !== "disabled";
     const maybeAppendSmritiMemorySafeEarly = allowMemoryEarly ? maybeAppendSmritiMemory : async () => {
@@ -39090,9 +39883,10 @@ async function executeAgentRun(params) {
   });
   if (runSignal.aborted)
     throw new Error("Request aborted");
+  let chitraguptaRecs = [];
   try {
-    const chitraguptaRecs = runtime.chitraguptaBridge?.recommend(payload.message.text);
-    if (chitraguptaRecs && chitraguptaRecs.length > 0) {
+    chitraguptaRecs = runtime.chitraguptaBridge?.recommend(payload.message.text) ?? [];
+    if (chitraguptaRecs.length > 0) {
       logger.debug("chitragupta_recommendations", {
         sessionId: session.id,
         query: payload.message.text.slice(0, 100),
@@ -39123,7 +39917,7 @@ async function executeAgentRun(params) {
   });
   if (preChatResult)
     return preChatResult;
-  return handleChatPhase({
+  const chatPhaseResult = await handleChatPhase({
     margaDecision,
     deps,
     session,
@@ -39150,6 +39944,8 @@ async function executeAgentRun(params) {
     locale,
     toolPolicy,
     budgetFallbackTarget,
+    conversationStyleHint: conversationStyle.style,
+    turiyaSignal,
     maybeAppendSmritiMemorySafe,
     enqueueSmritiMemoryAppendSafe,
     allowMemory,
@@ -39158,6 +39954,22 @@ async function executeAgentRun(params) {
     stripModelThinking: stripModelThinking2,
     manasRouteHint
   });
+  try {
+    const bridge = runtime.chitraguptaBridge;
+    if (bridge && chitraguptaRecs.length > 0) {
+      const toolCallNames = (chatPhaseResult.response.toolCalls ?? []).map((toolCall) => toolCall?.name?.trim()).filter((name) => Boolean(name));
+      if (toolCallNames.length > 0) {
+        const chosenTool = toolCallNames[0] ?? "llm";
+        for (const rec of chitraguptaRecs) {
+          if (rec && !toolCallNames.includes(rec)) {
+            bridge.onSkillRejected(rec, chosenTool);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return chatPhaseResult;
 }
 
 // apps/gateway/dist/routing-trace.js
@@ -39631,6 +40443,16 @@ function createAgentLoop(deps) {
         error: error instanceof Error ? error.message : String(error)
       });
     }
+    try {
+      const bridge = runtime.chitraguptaBridge;
+      const noToolUsed = !result.response.toolCalls?.length;
+      const isSubstantive = payload.message.text.trim().length > 10;
+      const isNonTemplate = result.response.model !== "template:deterministic" && result.response.model !== "system.queued" && result.response.model !== "system.continuity";
+      if (bridge && noToolUsed && isSubstantive && isNonTemplate) {
+        bridge.recordSkillGap(payload.message.text, result.session.id);
+      }
+    } catch {
+    }
     return result;
   }
   return runAgent;
@@ -44142,7 +44964,7 @@ async function forwardToBridge(runtime, connectionId, request) {
   if (!bridgeConnection) {
     throw new Error("Bridge connection not found or disconnected");
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const requestId = `fwd-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     const timer = setTimeout(() => {
       pendingBridgeRequests.delete(requestId);
@@ -44152,7 +44974,7 @@ async function forwardToBridge(runtime, connectionId, request) {
       resolve: (result) => {
         clearTimeout(timer);
         pendingBridgeRequests.delete(requestId);
-        resolve(result);
+        resolve3(result);
       }
     });
     bridgeConnection.sendEvent("bridge.request", {
@@ -44211,10 +45033,10 @@ function createBridgeExecutor(bridgeRegistry, connections) {
     }
     const timeoutMs = ctx?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const requestId = `anriva-tool-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       const timer = setTimeout(() => {
         pendingBridgeRequests.delete(requestId);
-        resolve({
+        resolve3({
           ok: false,
           error: { code: "bridge_timeout", message: `Bridge request timed out after ${timeoutMs}ms` }
         });
@@ -44223,7 +45045,7 @@ function createBridgeExecutor(bridgeRegistry, connections) {
         ctx.signal.addEventListener("abort", () => {
           clearTimeout(timer);
           pendingBridgeRequests.delete(requestId);
-          resolve({
+          resolve3({
             ok: false,
             error: { code: "aborted", message: "Request aborted" }
           });
@@ -44233,7 +45055,7 @@ function createBridgeExecutor(bridgeRegistry, connections) {
         resolve: (result) => {
           clearTimeout(timer);
           pendingBridgeRequests.delete(requestId);
-          resolve({
+          resolve3({
             ok: result.ok,
             output: result.payload,
             error: result.error
@@ -45984,7 +46806,7 @@ function createKaalaBroker(deps, options) {
       dispatch(lane);
     }
   };
-  const spawn7 = (input) => {
+  const spawn8 = (input) => {
     if (!options.enabled) {
       throw new Error("Kaala broker is disabled.");
     }
@@ -46036,13 +46858,13 @@ function createKaalaBroker(deps, options) {
       parentRunId: input.parentRunId,
       metadata: input.metadata
     };
-    let resolve;
+    let resolve3;
     const promise = new Promise((res) => {
-      resolve = res;
+      resolve3 = res;
     });
     const entry = {
       record,
-      resolve,
+      resolve: resolve3,
       promise,
       cancelled: false,
       controller: new AbortController()
@@ -46090,8 +46912,8 @@ function createKaalaBroker(deps, options) {
     if (entry.record.endedAt) return entry.record;
     if (!timeoutMs) return entry.promise;
     let timeoutId;
-    const timeoutPromise = new Promise((resolve) => {
-      timeoutId = setTimeout(() => resolve(void 0), timeoutMs);
+    const timeoutPromise = new Promise((resolve3) => {
+      timeoutId = setTimeout(() => resolve3(void 0), timeoutMs);
     });
     const result = await Promise.race([entry.promise, timeoutPromise]);
     if (timeoutId) clearTimeout(timeoutId);
@@ -46163,7 +46985,7 @@ function createKaalaBroker(deps, options) {
     };
   };
   return {
-    spawn: spawn7,
+    spawn: spawn8,
     list,
     get,
     wait: wait2,
@@ -46190,8 +47012,8 @@ function buildMetrics(entry, result) {
 }
 async function runWithTimeout(action, timeoutMs) {
   let timeoutId;
-  const timeoutPromise = new Promise((resolve) => {
-    timeoutId = setTimeout(() => resolve({ timedOut: true }), timeoutMs);
+  const timeoutPromise = new Promise((resolve3) => {
+    timeoutId = setTimeout(() => resolve3({ timedOut: true }), timeoutMs);
   });
   try {
     const result = await Promise.race([
@@ -46746,8 +47568,15 @@ var CHANNEL_IDS = [
   "imessage",
   "web"
 ];
-var isChannelId = (value) => Boolean(value) && CHANNEL_IDS.includes(value);
-var toChannelId = (value) => isChannelId(value) ? value : void 0;
+var CHANNEL_ALIASES = {
+  whispr: "signal"
+};
+var isChannelId = (value) => Boolean(value) && (CHANNEL_IDS.includes(normalizeChannelId(value)) || CHANNEL_IDS.includes(value));
+var toChannelId = (value) => isChannelId(value) ? normalizeChannelId(value) : void 0;
+function normalizeChannelId(value) {
+  const normalized = CHANNEL_ALIASES[value.trim().toLowerCase()];
+  return normalized ?? value.toLowerCase();
+}
 
 // apps/gateway/dist/kaala/audit.js
 import { randomUUID as randomUUID25 } from "node:crypto";
@@ -50007,20 +50836,20 @@ function hasRegexSupport(lang) {
 
 // packages/nlu/src/prototypes.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var YAML_PATH = join(__dirname, "intent-prototypes.yaml");
+var YAML_PATH = join2(__dirname, "intent-prototypes.yaml");
 var cached = null;
 function loadIntentPrototypes() {
   if (cached) return cached;
   let raw;
   try {
-    raw = readFileSync(YAML_PATH, "utf-8");
+    raw = readFileSync2(YAML_PATH, "utf-8");
   } catch {
-    const fallbackPath = join(__dirname, "..", "src", "intent-prototypes.yaml");
-    raw = readFileSync(fallbackPath, "utf-8");
+    const fallbackPath = join2(__dirname, "..", "src", "intent-prototypes.yaml");
+    raw = readFileSync2(fallbackPath, "utf-8");
   }
   const parsed = (0, import_yaml.parse)(raw);
   cached = parsed;
@@ -50369,6 +51198,9 @@ var DEFAULT_HYBRID_THRESHOLD = 0.6;
 var DEFAULT_EMBEDDING_THRESHOLD = 0.62;
 var PREFER_EMBEDDING_TIMEOUT_MS = 350;
 var DEFAULT_SMALLTALK_CLOUD_TIMEOUT_MS = 900;
+var DEFAULT_OLLAMA_CHAT_MODEL = "qwen3:8b";
+var SHORT_CHECKIN_PACK_LOCALE_SEPARATOR = /[-_]/;
+var WHITESPACE_RE = /\s+/g;
 var SOCIAL_CHECKIN_RE = /\b(h(?:ow|w)\s*(?:are|r)\s*(?:you|u)|how(?:'s|\s+is)\s+it\s+going|what(?:'s|\s+is)\s+up|you\s+there|all\s+good|namaste|namaskar(?:am|a)?|namaskaram|vanakkam|bagunava|bagunnava|bagnava|ela\s+undh?i|em[i]?\s+chest(?:h|)un(?:n|)av(?:u|a)?|em[i]?\s+chest(?:h|)un(?:n|)ar(?:u|a)?|como\s+estas|como\s+esta|que\s+tal|wie\s+geht(?:\s+es|s)(?:\s+(?:dir|ihnen))?|alles\s+gut|comment\s+(?:ca|ça)\s+va|ca\s+va|ça\s+va|kaise\s+(?:ho|hai|hain)|aap\s+kaise\s+(?:ho|hain)|kya\s+haal(?:\s+hai)?|kya\s+chal\s+raha\s+hai|कैसे\s+(?:हो|हैं)|क्या\s+हाल(?:\s+है)?|क्या\s+चल\s+रहा\s+है|お元気|元気(?:ですか)?|調子どう|調子はどう|genki(?:\s+desu\s+ka)?|konnichiwa|ohayo(?:u)?|nasilsin|nasilsiniz|как\s+дела|كيف\s+حالك)\b/i;
 var SOCIAL_ACTION_GUARD_RE = /\b(weather|forecast|clima|tiempo|wetter|pogoda|meteo|rain|snow|temperature|temp|router|network|wifi|device|client|connected|lan|scan|time|clock|remind|note|notes|search|find|nearest|hospital|train|rail|journey|memory|session|provider|model|language|lang|tone|style|emoji|persona|set|delete|forget|clear|music|play|transcrib|calendar|event|todo|joke|funny|meme|story|poem|quote|news|latest|top|tell\s+me|who\s+(?:are|r)\s+(?:you|u)|what\s+are\s+you|what\s+can\s+(?:you|u)\s+do)\b/i;
 var SHORT_SOCIAL_TOKEN_RE = /[^\p{L}\p{N}']+/gu;
@@ -50460,7 +51292,36 @@ function normalizeBaseUrl4(value) {
     return void 0;
   return trimmed.replace(/\/$/, "");
 }
-function looksLikeGenericSocialCheckin(text) {
+function normalizeCheckinPhrase(input) {
+  return input.toLowerCase().replace(SHORT_SOCIAL_TOKEN_RE, " ").trim().replace(WHITESPACE_RE, " ");
+}
+function resolveLocalePhrasePack(packs, language) {
+  if (!packs)
+    return /* @__PURE__ */ new Set();
+  const locale = (language ?? "").trim().toLowerCase();
+  const baseLocale = locale.split(SHORT_CHECKIN_PACK_LOCALE_SEPARATOR)[0] ?? "";
+  const candidates = [
+    packs[locale],
+    packs[baseLocale],
+    packs.default,
+    packs["*"]
+  ].filter((value) => Array.isArray(value));
+  const terms = /* @__PURE__ */ new Set();
+  for (const pack of candidates) {
+    for (const phrase of pack) {
+      const normalized = normalizeCheckinPhrase(phrase);
+      if (!normalized)
+        continue;
+      terms.add(normalized);
+      for (const token of normalized.split(" ")) {
+        if (token)
+          terms.add(token);
+      }
+    }
+  }
+  return terms;
+}
+function looksLikeGenericSocialCheckin(text, options) {
   const trimmed = text.trim();
   if (!trimmed || trimmed.startsWith("/"))
     return false;
@@ -50481,12 +51342,16 @@ function looksLikeGenericSocialCheckin(text) {
     return false;
   if (SOCIAL_CHECKIN_RE.test(trimmed))
     return true;
+  const localeTerms = resolveLocalePhrasePack(options?.phrasePacks, options?.language);
+  const normalizedText = normalizeCheckinPhrase(trimmed);
+  if (localeTerms.size > 0 && localeTerms.has(normalizedText))
+    return true;
   if (words.length > 3)
     return false;
   const normalizedWords = words.map((word) => word.toLowerCase().replace(SHORT_SOCIAL_TOKEN_RE, "")).filter(Boolean);
   if (!normalizedWords.length || normalizedWords.length > 3)
     return false;
-  return normalizedWords.every((word) => SHORT_SOCIAL_TOKENS.has(word));
+  return normalizedWords.every((word) => SHORT_SOCIAL_TOKENS.has(word) || localeTerms.has(word));
 }
 async function detectRequestLanguage(text, config, logger) {
   const provider = config.nlu?.langDetectProvider ?? "auto";
@@ -50507,7 +51372,7 @@ function resolveDefaultModel(providerId, entry) {
     return entry.models[0];
   if (entry.type === "ollama") {
     const required = entry.requiredModels?.find((model) => !/embed|bge/i.test(model));
-    return required ?? "llama3.2:1b";
+    return required ?? DEFAULT_OLLAMA_CHAT_MODEL;
   }
   if (entry.type === "minimax")
     return "MiniMax-M2.5-Lightning";
@@ -51300,7 +52165,15 @@ function createHybridNluInterpreter(params) {
     if (langDetectEnabled) {
       detectedLang = await detectRequestLanguage(request.text, config, logger);
     }
-    if (request.preferEmbeddings && looksLikeGenericSocialCheckin(request.text)) {
+    const fastEmbeddingCandidates = request.preferEmbeddings ? embeddingCandidates.map((candidate) => ({
+      ...candidate,
+      models: candidate.models.slice(0, 1),
+      timeoutMs: Math.min(candidate.timeoutMs, PREFER_EMBEDDING_TIMEOUT_MS)
+    })) : embeddingCandidates;
+    if (request.preferEmbeddings && looksLikeGenericSocialCheckin(request.text, {
+      language: detectedLang,
+      phrasePacks: config.nlu?.shortCheckinPacks
+    })) {
       if (smalltalkCloudFallbackEnabled && candidates.length > 0) {
         const smalltalkCandidates = prioritizeSmalltalkFallbackCandidates(candidates, {
           preferredProviderId: llmConfig?.smalltalkCloudProviderId,
@@ -51326,7 +52199,7 @@ function createHybridNluInterpreter(params) {
       return mergeNluResults(rulesResult, deterministicSmalltalk, hybridThreshold);
     }
     if (embeddingFirst) {
-      const embeddingResult2 = await classifyWithEmbeddings(request, embeddingCandidates, logger, embeddingThreshold, detectedLang);
+      const embeddingResult2 = await classifyWithEmbeddings(request, fastEmbeddingCandidates, logger, embeddingThreshold, detectedLang);
       if (embeddingResult2) {
         if (hasRegexSupport(detectedLang) && rulesResult && rulesResult.intent !== "unknown") {
           if (rulesResult.intent === embeddingResult2.intent) {
@@ -51350,16 +52223,16 @@ function createHybridNluInterpreter(params) {
       return { ...rulesResult, language: detectedLang };
     }
     if (request.preferEmbeddings) {
-      const fastEmbeddingCandidates = embeddingCandidates.map((candidate) => ({
-        ...candidate,
-        models: candidate.models.slice(0, 1),
-        timeoutMs: Math.min(candidate.timeoutMs, PREFER_EMBEDDING_TIMEOUT_MS)
-      }));
-      const embeddingOnlyResult = await classifyWithEmbeddings(request, fastEmbeddingCandidates, logger, embeddingThreshold, detectedLang);
-      if (embeddingOnlyResult) {
-        return mergeNluResults(rulesResult, embeddingOnlyResult, hybridThreshold);
+      if (!embeddingFirst) {
+        const embeddingOnlyResult = await classifyWithEmbeddings(request, fastEmbeddingCandidates, logger, embeddingThreshold, detectedLang);
+        if (embeddingOnlyResult) {
+          return mergeNluResults(rulesResult, embeddingOnlyResult, hybridThreshold);
+        }
       }
-      if (looksLikeGenericSocialCheckin(request.text)) {
+      if (looksLikeGenericSocialCheckin(request.text, {
+        language: detectedLang,
+        phrasePacks: config.nlu?.shortCheckinPacks
+      })) {
         return {
           intent: "smalltalk.greeting",
           confidence: 0.61,
@@ -51779,8 +52652,73 @@ function isLoopbackHost(host) {
 import fs39 from "node:fs";
 import os10 from "node:os";
 import path37 from "node:path";
+import { pathToFileURL } from "node:url";
 
 // packages/config/src/schema-nlu.ts
+var DEFAULT_SHORT_CHECKIN_PACKS = {
+  en: [
+    "hi",
+    "hello",
+    "hey",
+    "how are you",
+    "whats up",
+    "just checking"
+  ],
+  es: [
+    "hola",
+    "como estas",
+    "que tal",
+    "todo bien"
+  ],
+  fr: [
+    "bonjour",
+    "salut",
+    "ca va",
+    "comment ca va"
+  ],
+  de: [
+    "hallo",
+    "wie gehts",
+    "alles gut",
+    "guten morgen"
+  ],
+  hi: [
+    "namaste",
+    "kaise ho",
+    "aap kaise hain",
+    "kya haal hai"
+  ],
+  te: [
+    "namaskaram",
+    "bagunnava",
+    "em chesthunavu",
+    "ela unnava"
+  ],
+  ja: [
+    "konnichiwa",
+    "genki desu ka",
+    "ohayo",
+    "konbanwa"
+  ],
+  ar: [
+    "marhaba",
+    "ahlan",
+    "kayfa haluk",
+    "kayf halak"
+  ],
+  tr: [
+    "merhaba",
+    "nasilsin",
+    "nasilsiniz",
+    "iyi misin"
+  ],
+  ru: [
+    "privet",
+    "kak dela",
+    "zdravstvuy",
+    "dobryy den"
+  ]
+};
 var nluSchema = external_exports.object({
   enabled: external_exports.boolean().default(false),
   // Remote NLU service is optional; Vaayu always has in-process rule NLU.
@@ -51800,6 +52738,9 @@ var nluSchema = external_exports.object({
   langDetectMinConfidence: external_exports.number().min(0).max(1).default(0.55),
   // Minimum cosine similarity for embedding-based intent classification.
   embeddingThreshold: external_exports.number().min(0).max(1).default(0.62),
+  // Locale-indexed short-checkin phrase packs for greeting/check-in fast lane.
+  // Top-10 locales ship by default (en, es, fr, de, hi, te, ja, ar, tr, ru).
+  shortCheckinPacks: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())).default(DEFAULT_SHORT_CHECKIN_PACKS),
   // GLiNER v2.1 endpoint for language-agnostic NER slot filling.
   glinerEndpoint: external_exports.string().default("http://localhost:8501"),
   // GLiNER API path (supports FastAPI adapters like /gliner-2).
@@ -51856,6 +52797,12 @@ var nluSchema = external_exports.object({
 }).default({});
 
 // packages/config/src/schema-channels.ts
+var normalizeTringPlatform = (value) => {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "whispr") return "signal";
+  return normalized;
+};
+var tringPlatformSchema = external_exports.string().transform((value) => normalizeTringPlatform(value)).pipe(external_exports.enum(["whatsapp", "telegram", "signal"]));
 var telegramSchema = external_exports.object({
   enabled: external_exports.boolean().default(false),
   botToken: external_exports.string().optional(),
@@ -51955,11 +52902,24 @@ var imessageSchema = external_exports.object({
     });
   }
 }).default({});
+var tringSchema = external_exports.object({
+  enabled: external_exports.boolean().default(false),
+  daemonUrl: external_exports.string().default("http://localhost:8787"),
+  tringBin: external_exports.string().optional(),
+  platforms: external_exports.array(tringPlatformSchema).default(["whatsapp", "telegram", "signal"]),
+  pollIntervalMs: external_exports.number().int().min(500).max(6e4).default(2e3),
+  autoStartDaemon: external_exports.boolean().default(true),
+  allowedChats: external_exports.array(external_exports.string()).optional(),
+  providerId: external_exports.string().optional(),
+  model: external_exports.string().default("mock-1"),
+  system: external_exports.string().optional()
+}).default({});
 var channelsSchema = external_exports.object({
   telegram: telegramSchema,
   twitter: twitterSchema,
   whatsapp: whatsappSchema,
-  imessage: imessageSchema
+  imessage: imessageSchema,
+  tring: tringSchema
 }).default({});
 
 // packages/config/src/schema.ts
@@ -52152,6 +53112,15 @@ var routingSchema = external_exports.object({
   reasoning: external_exports.object({
     mode: external_exports.enum(["off", "auto", "on"]).default("off"),
     modelOverrides: external_exports.record(external_exports.string(), external_exports.string()).default({})
+  }).default({}),
+  policySidecarConfidence: external_exports.object({
+    // Avoid low-confidence deep routing signals from sidecar.
+    minConfidenceForCautious: external_exports.number().min(0).max(1).default(0.7),
+    minConfidenceForDeny: external_exports.number().min(0).max(1).default(0.82),
+    // Keep safe-fast-lane reasonably confident too.
+    minConfidenceForSafeFastLane: external_exports.number().min(0).max(1).default(0.55),
+    // Policy to apply when sidecar confidence is below threshold.
+    downgradePolicy: external_exports.enum(["standard", "safe_fast_lane"]).default("standard")
   }).default({})
 }).default({});
 var mcpServerSchema = external_exports.object({
@@ -54515,7 +55484,7 @@ var FileStorage = class {
 import path25 from "node:path";
 async function createStorage(options) {
   if (options.driver === "sqlite") {
-    const module = await import("./chunks/sqlite-7BC4DJTN.js");
+    const module = await import("./chunks/sqlite-4N7YH2KK.js");
     const sqlitePath = options.sqlitePath ?? path25.join(options.dataDir, "vaayu.db");
     return new module.SqliteStorage({ sqlitePath });
   }
@@ -54523,7 +55492,7 @@ async function createStorage(options) {
     if (!options.postgresUrl) {
       throw new Error("Postgres driver requires postgresUrl");
     }
-    const module = await import("./chunks/postgres-7GZDDX77.js");
+    const module = await import("./chunks/postgres-YLCUNVPQ.js");
     return module.PostgresStorage.create({ url: options.postgresUrl });
   }
   return new FileStorage({ dataDir: options.dataDir });
@@ -55311,131 +56280,15 @@ var IdempotencyStore = class {
   }
 };
 
-// apps/gateway/dist/models-cache.js
+// apps/gateway/dist/memory/smriti.js
 import fs30 from "node:fs";
 import path28 from "node:path";
-function readCacheFile(cachePath, logger) {
-  if (!fs30.existsSync(cachePath))
-    return null;
-  try {
-    const raw = fs30.readFileSync(cachePath, "utf8");
-    if (!raw.trim())
-      return null;
-    const parsed = JSON.parse(raw);
-    if (!parsed || parsed.version !== 1)
-      return null;
-    return parsed;
-  } catch (error) {
-    logger?.warn("provider_model_cache_read_failed", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return null;
-  }
-}
-function writeCacheFile(cachePath, cache, logger) {
-  try {
-    fs30.mkdirSync(path28.dirname(cachePath), { recursive: true });
-    const providers = {};
-    for (const [providerId, entry] of cache.entries()) {
-      providers[providerId] = entry;
-    }
-    const payload = {
-      version: 1,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      providers
-    };
-    fs30.writeFileSync(cachePath, JSON.stringify(payload, null, 2));
-  } catch (error) {
-    logger?.warn("provider_model_cache_write_failed", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-function createProviderModelCacheStore(params) {
-  const { cachePath, logger } = params;
-  const cache = /* @__PURE__ */ new Map();
-  const existing = readCacheFile(cachePath, logger);
-  if (existing?.providers) {
-    for (const [providerId, entry] of Object.entries(existing.providers)) {
-      cache.set(providerId, entry);
-    }
-  }
-  let pending = null;
-  const flush = () => writeCacheFile(cachePath, cache, logger);
-  const scheduleFlush = () => {
-    if (pending)
-      return;
-    pending = setTimeout(() => {
-      pending = null;
-      flush();
-    }, 500);
-  };
-  return {
-    cache,
-    get: (providerId) => cache.get(providerId),
-    set: (providerId, entry) => {
-      cache.set(providerId, entry);
-      scheduleFlush();
-    },
-    update: (providerId, update) => {
-      const existingEntry = cache.get(providerId);
-      if (!existingEntry)
-        return;
-      cache.set(providerId, { ...existingEntry, ...update });
-      scheduleFlush();
-    },
-    flush
-  };
-}
-
-// apps/gateway/dist/models-refresh.js
-function startModelRefreshLoop(params) {
-  const { enabled, intervalMs, jitterMs, initialDelayMs, providerIds, refreshProvider, logger } = params;
-  if (!enabled || providerIds.length === 0) {
-    return null;
-  }
-  let stopped = false;
-  let timer = null;
-  const nextDelay = () => {
-    const jitter = jitterMs > 0 ? Math.floor(Math.random() * jitterMs) : 0;
-    return intervalMs + jitter;
-  };
-  const runCycle = async () => {
-    if (stopped)
-      return;
-    for (const providerId of providerIds) {
-      if (stopped)
-        return;
-      try {
-        await refreshProvider(providerId);
-      } catch (error) {
-        logger.warn("provider_models_refresh_failed", {
-          providerId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    }
-    timer = setTimeout(runCycle, nextDelay());
-  };
-  timer = setTimeout(runCycle, Math.max(0, initialDelayMs ?? intervalMs));
-  return {
-    stop: () => {
-      stopped = true;
-      if (timer)
-        clearTimeout(timer);
-    }
-  };
-}
-
-// apps/gateway/dist/memory/smriti.js
-import fs31 from "node:fs";
-import path29 from "node:path";
 import { randomUUID as randomUUID34 } from "node:crypto";
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var _chitraguptaMemory = null;
 async function getChitraguptaMemory() {
   if (!_chitraguptaMemory) {
-    _chitraguptaMemory = await import("./chunks/dist-CY5NX2IK.js");
+    _chitraguptaMemory = await import("./chunks/dist-ESCM3CP5.js");
   }
   return _chitraguptaMemory;
 }
@@ -55473,7 +56326,7 @@ function computeRetryDelayMs(retries) {
 function createSmritiHelpers(deps) {
   const { logger, getProfile, memoryAllowed, markdownMemory, smritiClient, smritiSource, smritiAutoCapture, smritiAutoCaptureMode, smritiDefaultTags, smritiBaseUrl, smritiApiKey, smritiPrefix, smritiOwner, smritiTimeoutMs, smritiAutoMemoryReady, smritiAutoMemoryPython, smritiAutoMemorySessionScript, smritiAutoMemoryPromptScript, storageRoot, repoRoot } = deps;
   const smritiState = {};
-  const outboxPath2 = path29.join(storageRoot ?? repoRoot, OUTBOX_FILE);
+  const outboxPath2 = path28.join(storageRoot ?? repoRoot, OUTBOX_FILE);
   let outboxLoaded = false;
   let outboxEntries2 = [];
   let outboxOps = Promise.resolve();
@@ -55488,7 +56341,7 @@ function createSmritiHelpers(deps) {
     if (outboxLoaded)
       return;
     try {
-      const raw = await fs31.promises.readFile(outboxPath2, "utf8");
+      const raw = await fs30.promises.readFile(outboxPath2, "utf8");
       const parsed = JSON.parse(raw);
       outboxEntries2 = Array.isArray(parsed) ? parsed.filter(isSmritiOutboxEntry) : [];
     } catch {
@@ -55497,12 +56350,12 @@ function createSmritiHelpers(deps) {
     outboxLoaded = true;
   }
   async function persistOutboxUnsafe() {
-    const dir = path29.dirname(outboxPath2);
-    await fs31.promises.mkdir(dir, { recursive: true });
+    const dir = path28.dirname(outboxPath2);
+    await fs30.promises.mkdir(dir, { recursive: true });
     const tempPath = `${outboxPath2}.tmp`;
-    await fs31.promises.writeFile(tempPath, `${JSON.stringify(outboxEntries2, null, 2)}
+    await fs30.promises.writeFile(tempPath, `${JSON.stringify(outboxEntries2, null, 2)}
 `, "utf8");
-    await fs31.promises.rename(tempPath, outboxPath2);
+    await fs30.promises.rename(tempPath, outboxPath2);
   }
   function shouldSkipDailyTranscriptWrite() {
     return isSmritiMemoryEnabled() && isSmritiWriteThroughEnabled();
@@ -55767,11 +56620,11 @@ function createSmritiHelpers(deps) {
     if (!smritiAutoMemoryReady)
       return null;
     const scriptPath = params.kind === "session" ? smritiAutoMemorySessionScript : smritiAutoMemoryPromptScript;
-    if (!fs31.existsSync(scriptPath))
+    if (!fs30.existsSync(scriptPath))
       return null;
     const env = buildSmritiAutoMemoryEnv({ userId: params.userId });
-    return await new Promise((resolve) => {
-      const child = spawn4(smritiAutoMemoryPython, [scriptPath], {
+    return await new Promise((resolve3) => {
+      const child = spawn5(smritiAutoMemoryPython, [scriptPath], {
         env,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -55779,7 +56632,7 @@ function createSmritiHelpers(deps) {
       let stderr = "";
       const timeout = setTimeout(() => {
         child.kill("SIGKILL");
-        resolve(null);
+        resolve3(null);
       }, 15e3);
       child.stdout.on("data", (chunk) => {
         stdout += chunk.toString();
@@ -55793,7 +56646,7 @@ function createSmritiHelpers(deps) {
           kind: params.kind,
           error: error.message
         });
-        resolve(null);
+        resolve3(null);
       });
       child.on("close", () => {
         clearTimeout(timeout);
@@ -55805,17 +56658,17 @@ function createSmritiHelpers(deps) {
         }
         const trimmed = stdout.trim();
         if (!trimmed)
-          return resolve(null);
+          return resolve3(null);
         try {
           const parsed = JSON.parse(trimmed);
           const message = typeof parsed.systemMessage === "string" ? parsed.systemMessage.trim() : "";
-          resolve(message || null);
+          resolve3(message || null);
         } catch (error) {
           logger.warn("smriti_auto_memory_parse_failed", {
             kind: params.kind,
             error: error instanceof Error ? error.message : String(error)
           });
-          resolve(null);
+          resolve3(null);
         }
       });
       if (params.input)
@@ -55866,6 +56719,122 @@ function createSmritiHelpers(deps) {
   };
 }
 
+// apps/gateway/dist/models-cache.js
+import fs31 from "node:fs";
+import path29 from "node:path";
+function readCacheFile(cachePath, logger) {
+  if (!fs31.existsSync(cachePath))
+    return null;
+  try {
+    const raw = fs31.readFileSync(cachePath, "utf8");
+    if (!raw.trim())
+      return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.version !== 1)
+      return null;
+    return parsed;
+  } catch (error) {
+    logger?.warn("provider_model_cache_read_failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function writeCacheFile(cachePath, cache, logger) {
+  try {
+    fs31.mkdirSync(path29.dirname(cachePath), { recursive: true });
+    const providers = {};
+    for (const [providerId, entry] of cache.entries()) {
+      providers[providerId] = entry;
+    }
+    const payload = {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      providers
+    };
+    fs31.writeFileSync(cachePath, JSON.stringify(payload, null, 2));
+  } catch (error) {
+    logger?.warn("provider_model_cache_write_failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function createProviderModelCacheStore(params) {
+  const { cachePath, logger } = params;
+  const cache = /* @__PURE__ */ new Map();
+  const existing = readCacheFile(cachePath, logger);
+  if (existing?.providers) {
+    for (const [providerId, entry] of Object.entries(existing.providers)) {
+      cache.set(providerId, entry);
+    }
+  }
+  let pending = null;
+  const flush = () => writeCacheFile(cachePath, cache, logger);
+  const scheduleFlush = () => {
+    if (pending)
+      return;
+    pending = setTimeout(() => {
+      pending = null;
+      flush();
+    }, 500);
+  };
+  return {
+    cache,
+    get: (providerId) => cache.get(providerId),
+    set: (providerId, entry) => {
+      cache.set(providerId, entry);
+      scheduleFlush();
+    },
+    update: (providerId, update) => {
+      const existingEntry = cache.get(providerId);
+      if (!existingEntry)
+        return;
+      cache.set(providerId, { ...existingEntry, ...update });
+      scheduleFlush();
+    },
+    flush
+  };
+}
+
+// apps/gateway/dist/models-refresh.js
+function startModelRefreshLoop(params) {
+  const { enabled, intervalMs, jitterMs, initialDelayMs, providerIds, refreshProvider, logger } = params;
+  if (!enabled || providerIds.length === 0) {
+    return null;
+  }
+  let stopped = false;
+  let timer = null;
+  const nextDelay = () => {
+    const jitter = jitterMs > 0 ? Math.floor(Math.random() * jitterMs) : 0;
+    return intervalMs + jitter;
+  };
+  const runCycle = async () => {
+    if (stopped)
+      return;
+    for (const providerId of providerIds) {
+      if (stopped)
+        return;
+      try {
+        await refreshProvider(providerId);
+      } catch (error) {
+        logger.warn("provider_models_refresh_failed", {
+          providerId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    timer = setTimeout(runCycle, nextDelay());
+  };
+  timer = setTimeout(runCycle, Math.max(0, initialDelayMs ?? intervalMs));
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+}
+
 // apps/gateway/dist/runtime/memory-markdown.js
 import fs32 from "node:fs";
 import path30 from "node:path";
@@ -55910,65 +56879,259 @@ function createMarkdownMemoryWriter(params) {
   return { enabled, dailyDir, longTermPath, appendDaily, appendLongTerm };
 }
 
-// apps/gateway/dist/gateway/summary-llm.js
-function buildOutboundPromptText4(messages) {
-  return messages.map((message) => `${message.role}: ${message.content}`).join("\n");
-}
-function createSummaryLLM(getProvider, getModel, logger) {
-  return {
-    async generate(prompt) {
-      const provider = getProvider();
-      if (!provider) {
-        logger?.warn("summary_llm_no_provider");
-        throw new Error("No provider available for summarization");
+// apps/gateway/dist/gateway/config-path.js
+import fs33 from "node:fs";
+import path31 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var GATEWAY_CONFIG_FILENAMES = [
+  "vaayu.config.json",
+  "vaayu.config.yaml",
+  "vaayu.config.yml"
+];
+function resolvePreferredGatewayConfigPath(params) {
+  const envConfigPath = params?.envConfigPath ?? process.env.VAAYU_CONFIG;
+  if (envConfigPath?.trim()) {
+    return void 0;
+  }
+  const existsSync5 = params?.existsSync ?? fs33.existsSync;
+  const moduleFilePath = params?.moduleFilePath ?? fileURLToPath2(import.meta.url);
+  let currentDir = path31.dirname(moduleFilePath);
+  for (let depth = 0; depth < 10; depth += 1) {
+    for (const filename of GATEWAY_CONFIG_FILENAMES) {
+      const candidate = path31.join(currentDir, filename);
+      if (existsSync5(candidate)) {
+        return candidate;
       }
-      const model = getModel() ?? "gpt-4o-mini";
+    }
+    const parent = path31.dirname(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  return void 0;
+}
+
+// apps/gateway/dist/gateway/identity-loader.js
+import fs34 from "node:fs";
+import path32 from "node:path";
+var MAX_PROMPT_CHARS_DEFAULT = 12e3;
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (!value)
+      continue;
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+function buildCandidateRoots(repoRoot) {
+  const roots = [repoRoot];
+  let current = repoRoot;
+  for (let i = 0; i < 3; i += 1) {
+    const parent = path32.dirname(current);
+    if (!parent || parent === current)
+      break;
+    roots.push(parent);
+    current = parent;
+  }
+  return uniqueStrings(roots);
+}
+function readFirstExisting(roots, filenames) {
+  for (const root of roots) {
+    for (const name of filenames) {
+      const candidate = path32.join(root, name);
       try {
-        const messages = [
-          {
-            role: "system",
-            content: "You are a concise summarizer. Generate clear, factual summaries that preserve important details."
-          },
-          {
-            role: "user",
-            content: prompt
+        if (!fs34.existsSync(candidate))
+          continue;
+        const text = fs34.readFileSync(candidate, "utf8").trim();
+        if (!text)
+          continue;
+        return { file: candidate, text };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function extractIdentityFields(identity, user) {
+  const fields = {};
+  if (identity) {
+    const nameMatch = identity.match(/(?:^|\n)\s*(?:-\s*)?(?:\*\*)?Name(?:\*\*)?:\s*(?:\*\*)?(.+?)(?:\*\*)?$/im);
+    if (nameMatch?.[1]) {
+      const raw = nameMatch[1].trim().replace(/^_\(?|_?\)?$/g, "");
+      if (raw && !raw.startsWith("(") && raw.length < 64) {
+        fields.assistantName = raw;
+      }
+    }
+    const emojiMatch = identity.match(/(?:^|\n)\s*(?:-\s*)?(?:\*\*)?Emoji(?:\*\*)?:\s*(?:\*\*)?(.+?)(?:\*\*)?$/im);
+    if (emojiMatch?.[1]) {
+      const raw = emojiMatch[1].trim().replace(/^_\(?|_?\)?$/g, "");
+      if (raw && !raw.startsWith("(") && raw.length < 8) {
+        fields.emoji = raw;
+      }
+    }
+  }
+  if (user) {
+    if (!fields.userName) {
+      const callMatch = user.match(/(?:^|\n)\s*(?:What to call them|Call them|User name|userName):\s*(.+?)$/im);
+      if (callMatch?.[1]) {
+        const raw = callMatch[1].trim().split(/\s*[/,]\s*/)[0];
+        if (raw && raw.length < 64) {
+          fields.userName = raw;
+        }
+      }
+    }
+    if (!fields.assistantName) {
+      const assistantCallMatch = user.match(/(?:^|\n)\s*(?:What to call assistant|Assistant name|assistantName):\s*(.+?)$/im);
+      if (assistantCallMatch?.[1]) {
+        const raw = assistantCallMatch[1].trim();
+        if (raw && raw.length < 64) {
+          fields.assistantName = raw;
+        }
+      }
+    }
+  }
+  return fields;
+}
+function truncatePrompt(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
+  return `${text.slice(0, maxChars)}
+
+[...identity truncated]`;
+}
+function loadWorkspaceIdentityPrompt(params) {
+  const roots = buildCandidateRoots(params.repoRoot);
+  const maxChars = params.maxPromptChars ?? MAX_PROMPT_CHARS_DEFAULT;
+  const filesLoaded = [];
+  const parts = [];
+  const soul = readFirstExisting(roots, ["SOUL.md", "soul.md"]);
+  if (soul) {
+    filesLoaded.push(soul.file);
+    parts.push(soul.text);
+  }
+  const identity = readFirstExisting(roots, ["IDENTITY.md", "identity.md"]);
+  if (identity) {
+    filesLoaded.push(identity.file);
+    parts.push(identity.text);
+  }
+  const personality = readFirstExisting(roots, ["PERSONALITY.md", "personality.md"]);
+  if (personality) {
+    filesLoaded.push(personality.file);
+    parts.push(personality.text);
+  }
+  const user = readFirstExisting(roots, ["USER.md", "user.md"]);
+  if (user) {
+    filesLoaded.push(user.file);
+    parts.push(user.text);
+  }
+  const fields = extractIdentityFields(identity?.text, user?.text);
+  const prompt = truncatePrompt(parts.filter(Boolean).join("\n\n"), maxChars).trim();
+  return { prompt, rootsChecked: roots, filesLoaded, fields };
+}
+function reloadIdentity(params) {
+  return loadWorkspaceIdentityPrompt(params);
+}
+
+// apps/gateway/dist/gateway/setup-smriti.js
+import fs35 from "node:fs";
+import path33 from "node:path";
+function resolveSmritiRuntimeConfig(params) {
+  const { config, repoRoot, logger } = params;
+  const smritiConfig = config.smriti ?? {};
+  const smritiEnabled = smritiConfig.enabled ?? false;
+  const smritiBaseUrl = smritiConfig.baseUrl ?? "http://127.0.0.1:7788";
+  const smritiConfigPath = process.env.SMRITI_CONFIG_PATH ?? path33.resolve(repoRoot, "smriti", "smriti.config.json");
+  let smritiLocalConfig = null;
+  if (smritiEnabled && smritiBaseUrl && fs35.existsSync(smritiConfigPath)) {
+    try {
+      const raw = fs35.readFileSync(smritiConfigPath, "utf8");
+      smritiLocalConfig = JSON.parse(raw);
+    } catch (error) {
+      logger.warn("smriti_config_load_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  let smritiApiKey = smritiConfig.apiKey;
+  if (!smritiApiKey && smritiEnabled && smritiBaseUrl) {
+    try {
+      const parsed = new URL(smritiBaseUrl);
+      if (isLoopbackHost(parsed.hostname)) {
+        const storageRoot = smritiLocalConfig?.storage?.root;
+        if (storageRoot) {
+          const baseDir = path33.dirname(smritiConfigPath);
+          const resolvedStorage = path33.isAbsolute(storageRoot) ? storageRoot : path33.resolve(baseDir, storageRoot);
+          const keyPath = path33.join(resolvedStorage, "keys", "master.key");
+          if (fs35.existsSync(keyPath)) {
+            const key = fs35.readFileSync(keyPath, "utf8").trim();
+            if (key) {
+              smritiApiKey = key;
+              logger.info("smriti_master_key_loaded", { path: keyPath });
+            }
           }
-        ];
-        const requestMeta = buildChatMeta({
-          purpose: "summary",
-          providerId: provider.id,
-          model,
-          normalization: buildNormalizationOutboundMeta(normalizeIncomingText(buildOutboundPromptText4(messages)))
-        });
-        const response = await chatWithPolicy({
-          provider,
-          request: buildChatRequest({
-            model,
-            messages,
-            temperature: 0.3,
-            maxTokens: 1024,
-            metadata: requestMeta
-          }),
-          logger,
-          meta: requestMeta
-        });
-        logger?.info("summary_llm_generated", {
-          provider: provider.id,
-          model,
-          inputLength: prompt.length,
-          outputLength: response.content.length
-        });
-        return response.content;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger?.error("summary_llm_error", {
-          error: message,
-          provider: provider.id,
-          model
-        });
-        throw error;
+        }
       }
+    } catch (error) {
+      logger.warn("smriti_master_key_load_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
+  }
+  const smritiPrefix = smritiConfig.prefix;
+  const smritiOwner = smritiConfig.owner;
+  const smritiAutoCapture = smritiConfig.autoCapture ?? false;
+  const smritiAutoCaptureMode = smritiConfig.autoCaptureMode ?? "exchange";
+  const smritiRetrieveEnabled = smritiConfig.retrieveEnabled ?? false;
+  const smritiRetrieveLimit = smritiConfig.retrieveLimit ?? 5;
+  const smritiDefaultTags = smritiConfig.defaultTags ?? void 0;
+  const smritiSource = smritiConfig.source;
+  const smritiAutoMemoryEnabled = smritiConfig.autoMemoryEnabled ?? false;
+  const smritiAutoMemoryPython = smritiConfig.autoMemoryPython ?? "python3";
+  const smritiAutoMemoryFallbackRoot = path33.resolve(repoRoot, "skills-core", "smriti-auto-memory", "hooks", "scripts");
+  const smritiAutoMemoryRootCandidates = [
+    smritiAutoMemoryFallbackRoot,
+    path33.resolve(repoRoot, "..", "ecosystem", "skills", "smriti-auto-memory", "hooks", "scripts"),
+    path33.resolve(repoRoot, "skills", "smriti-auto-memory", "hooks", "scripts")
+  ];
+  const smritiAutoMemoryDefaultRoot = smritiAutoMemoryRootCandidates.find((candidate) => fs35.existsSync(candidate)) ?? smritiAutoMemoryFallbackRoot;
+  const smritiAutoMemoryRoot = smritiConfig.autoMemoryPath ?? smritiAutoMemoryDefaultRoot;
+  const smritiAutoMemorySessionScript = path33.join(smritiAutoMemoryRoot, "session-start.py");
+  const smritiAutoMemoryPromptScript = path33.join(smritiAutoMemoryRoot, "user-prompt.py");
+  const smritiAutoMemoryReady = smritiEnabled && smritiAutoMemoryEnabled && Boolean(smritiApiKey) && fs35.existsSync(smritiAutoMemorySessionScript) && fs35.existsSync(smritiAutoMemoryPromptScript);
+  const smritiClientOptions = smritiEnabled && smritiBaseUrl ? {
+    baseUrl: smritiBaseUrl,
+    apiKey: smritiApiKey,
+    timeoutMs: smritiConfig.timeoutMs,
+    prefix: smritiPrefix ? smritiPrefix.replace(/\/$/, "") : smritiOwner ? `user/${normalizeSmritiOwner(smritiOwner)}` : void 0
+  } : void 0;
+  return {
+    smritiConfig,
+    smritiEnabled,
+    smritiBaseUrl,
+    smritiApiKey,
+    smritiPrefix,
+    smritiOwner,
+    smritiAutoCapture,
+    smritiAutoCaptureMode,
+    smritiRetrieveEnabled,
+    smritiRetrieveLimit,
+    smritiDefaultTags,
+    smritiSource,
+    smritiAutoMemoryEnabled,
+    smritiAutoMemoryPython,
+    smritiAutoMemoryRoot,
+    smritiAutoMemorySessionScript,
+    smritiAutoMemoryPromptScript,
+    smritiAutoMemoryReady,
+    smritiClientOptions,
+    smritiVectorProvider: smritiLocalConfig?.vector?.provider,
+    smritiVectorFallbacks: smritiLocalConfig?.vector?.fallbackProviders,
+    smritiEmbeddingProviders: smritiLocalConfig?.embeddings?.providerPriority
   };
 }
 
@@ -56028,8 +57191,8 @@ function cleanupPairings(pairingStore, channelPairingStore) {
 }
 
 // apps/gateway/dist/gateway/tool-registry.js
-import path31 from "node:path";
-import fs33 from "node:fs";
+import path34 from "node:path";
+import fs36 from "node:fs";
 
 // apps/gateway/dist/gateway/smriti-status.js
 async function buildSmritiStatus(params) {
@@ -56269,13 +57432,13 @@ async function setupToolRegistry(params) {
   });
   const autoMcpServers = [];
   if (gwEnv.holoCube.enabled && gwEnv.holoCube.bridgeUrl) {
-    const defaultHoloManifestPath = path31.resolve(repoRoot, "..", "ecosystem", "skills", "holo-cube", "server", "mcp.manifest.json");
+    const defaultHoloManifestPath = path34.resolve(repoRoot, "..", "ecosystem", "skills", "holo-cube", "server", "mcp.manifest.json");
     const holoManifestCandidates = [
       defaultHoloManifestPath,
-      path31.resolve(repoRoot, "skills-core", "holo-cube", "server", "mcp.manifest.json"),
-      path31.resolve(repoRoot, "skills", "holo-cube", "server", "mcp.manifest.json")
+      path34.resolve(repoRoot, "skills-core", "holo-cube", "server", "mcp.manifest.json"),
+      path34.resolve(repoRoot, "skills", "holo-cube", "server", "mcp.manifest.json")
     ];
-    const holoManifestPath = holoManifestCandidates.find((candidate) => fs33.existsSync(candidate)) ?? defaultHoloManifestPath;
+    const holoManifestPath = holoManifestCandidates.find((candidate) => fs36.existsSync(candidate)) ?? defaultHoloManifestPath;
     autoMcpServers.push({
       id: "holocube",
       command: "node",
@@ -56302,23 +57465,23 @@ async function setupToolRegistry(params) {
 }
 
 // apps/gateway/dist/gateway/tool-policy.js
-import fs34 from "node:fs";
-import path32 from "node:path";
+import fs37 from "node:fs";
+import path35 from "node:path";
 function createToolPolicyLoader(logger) {
   return (customPath, baseDir) => {
     const cwd = baseDir ?? process.cwd();
-    const fallbackPolicyPath = path32.resolve(cwd, "skills-core", "skills.config.json");
+    const fallbackPolicyPath = path35.resolve(cwd, "skills-core", "skills.config.json");
     const defaultCandidates = [
       fallbackPolicyPath,
-      path32.resolve(cwd, "skills", "skills.config.json")
+      path35.resolve(cwd, "skills", "skills.config.json")
     ];
     const configuredBase = customPath ?? process.env.VAAYU_SKILLS_CONFIG;
-    const firstExisting = defaultCandidates.find((candidate) => fs34.existsSync(candidate));
-    const policyPath = configuredBase ? path32.isAbsolute(configuredBase) ? configuredBase : path32.resolve(cwd, configuredBase) : firstExisting ?? fallbackPolicyPath;
-    if (!fs34.existsSync(policyPath))
+    const firstExisting = defaultCandidates.find((candidate) => fs37.existsSync(candidate));
+    const policyPath = configuredBase ? path35.isAbsolute(configuredBase) ? configuredBase : path35.resolve(cwd, configuredBase) : firstExisting ?? fallbackPolicyPath;
+    if (!fs37.existsSync(policyPath))
       return void 0;
     try {
-      const raw = fs34.readFileSync(policyPath, "utf8");
+      const raw = fs37.readFileSync(policyPath, "utf8");
       const parsed = JSON.parse(raw);
       return {
         allow: Array.isArray(parsed.allow) ? parsed.allow : [],
@@ -57150,8 +58313,8 @@ function createWeatherDefaultsUpdater(params) {
 }
 
 // apps/gateway/dist/skills.js
-import fs35 from "node:fs";
-import path33 from "node:path";
+import fs38 from "node:fs";
+import path36 from "node:path";
 var SKILL_PACK_SKIP_DIRS = /* @__PURE__ */ new Set([
   "assets",
   "resources",
@@ -57165,17 +58328,17 @@ var SKILL_PACK_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".tmp"
 ]);
 function isSkillPackDir(dir) {
-  return fs35.existsSync(path33.join(dir, "manifest.json")) && fs35.existsSync(path33.join(dir, "SKILL.md"));
+  return fs38.existsSync(path36.join(dir, "manifest.json")) && fs38.existsSync(path36.join(dir, "SKILL.md"));
 }
 function collectSkillPackDirs(root) {
-  if (!fs35.existsSync(root)) {
+  if (!fs38.existsSync(root)) {
     return [];
   }
   const out = [];
   const stack = [];
-  const entries2 = fs35.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !SKILL_PACK_SKIP_DIRS.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+  const entries2 = fs38.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(path33.join(root, entry.name));
+    stack.push(path36.join(root, entry.name));
   }
   while (stack.length) {
     const dir = stack.pop();
@@ -57187,21 +58350,21 @@ function collectSkillPackDirs(root) {
     }
     let children;
     try {
-      children = fs35.readdirSync(dir, { withFileTypes: true });
+      children = fs38.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     const ordered = children.filter((child) => child.isDirectory()).filter((child) => !SKILL_PACK_SKIP_DIRS.has(child.name)).filter((child) => !child.name.startsWith(".")).sort((a, b) => a.name.localeCompare(b.name));
     for (const child of ordered.reverse()) {
-      stack.push(path33.join(dir, child.name));
+      stack.push(path36.join(dir, child.name));
     }
   }
   return out;
 }
 function resolveSkillAssetPath(options) {
-  const baseRoot = path33.resolve(options.repoRoot, options.root);
-  const direct = path33.join(baseRoot, options.skillId, ...options.relativePath);
-  if (fs35.existsSync(direct)) {
+  const baseRoot = path36.resolve(options.repoRoot, options.root);
+  const direct = path36.join(baseRoot, options.skillId, ...options.relativePath);
+  if (fs38.existsSync(direct)) {
     return direct;
   }
   const maxDepth = 5;
@@ -57216,7 +58379,7 @@ function resolveSkillAssetPath(options) {
       continue;
     let children;
     try {
-      children = fs35.readdirSync(next.dir, { withFileTypes: true });
+      children = fs38.readdirSync(next.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -57227,10 +58390,10 @@ function resolveSkillAssetPath(options) {
         continue;
       if (child.name.startsWith("."))
         continue;
-      const childDir = path33.join(next.dir, child.name);
+      const childDir = path36.join(next.dir, child.name);
       if (child.name === options.skillId) {
-        const candidate = path33.join(childDir, ...options.relativePath);
-        if (fs35.existsSync(candidate)) {
+        const candidate = path36.join(childDir, ...options.relativePath);
+        if (fs38.existsSync(candidate)) {
           return candidate;
         }
       }
@@ -57244,30 +58407,30 @@ function resolveSkillAssetPath(options) {
 }
 function loadSkillManifests(includeLab, baseDir) {
   const rootDir = baseDir ?? process.cwd();
-  const ecosystemDir = path33.resolve(rootDir, "..", "ecosystem");
+  const ecosystemDir = path36.resolve(rootDir, "..", "ecosystem");
   const coreStableRoots = [
-    path33.resolve(rootDir, "skills-core"),
+    path36.resolve(rootDir, "skills-core"),
     // Legacy fallback during migration.
-    path33.resolve(rootDir, "skills")
+    path36.resolve(rootDir, "skills")
   ];
   const roots = [
     ...coreStableRoots.map((dir) => ({ dir, status: "stable" })),
     // Approved third-party skills
-    { dir: path33.resolve(ecosystemDir, "skills"), status: "stable" },
+    { dir: path36.resolve(ecosystemDir, "skills"), status: "stable" },
     // Community submissions (discoverable, not tool-executable by default)
-    { dir: path33.resolve(ecosystemDir, "skill-community"), status: "community" }
+    { dir: path36.resolve(ecosystemDir, "skill-community"), status: "community" }
   ];
   if (includeLab) {
-    roots.push({ dir: path33.resolve(ecosystemDir, "skill-lab"), status: "lab" });
+    roots.push({ dir: path36.resolve(ecosystemDir, "skill-lab"), status: "lab" });
   }
   const manifests = [];
   const seen = /* @__PURE__ */ new Set();
   for (const root of roots) {
     const packDirs = collectSkillPackDirs(root.dir);
     for (const packDir of packDirs) {
-      const manifestPath = path33.join(packDir, "manifest.json");
+      const manifestPath = path36.join(packDir, "manifest.json");
       try {
-        const raw = fs35.readFileSync(manifestPath, "utf8");
+        const raw = fs38.readFileSync(manifestPath, "utf8");
         const data2 = JSON.parse(raw);
         if (!data2.id) {
           continue;
@@ -58074,6 +59237,7 @@ function setupGatewayStores(params) {
   let twitterAdapter;
   let whatsappAdapter;
   let imessageAdapter;
+  let tringAdapter;
   let skillManifests = loadSkillManifests(gwEnv.skillsLabEnabled, repoRoot);
   const telegramAdapterRef = {
     get: () => telegramAdapter,
@@ -58099,6 +59263,12 @@ function setupGatewayStores(params) {
       imessageAdapter = adapter;
     }
   };
+  const tringAdapterRef = {
+    get: () => tringAdapter,
+    set: (adapter) => {
+      tringAdapter = adapter;
+    }
+  };
   const skillManifestsRef = {
     get: () => skillManifests,
     set: (skills) => {
@@ -58198,6 +59368,11 @@ function setupGatewayStores(params) {
       });
       return;
     }
+    const tringChannel = normalizeTringChannel(channel);
+    if (tringAdapter && tringChannel) {
+      await sendTringMessage(tringAdapter, tringChannel, chatId, content);
+      return;
+    }
     if (channel === "hub") {
       const profile = getProfile?.();
       await sendHubReply({
@@ -58213,7 +59388,15 @@ function setupGatewayStores(params) {
     }
   }
   async function isChannelAllowed(channel, chatId, userId) {
+    const tringPlatforms = (config.channels.tring.platforms ?? []).map((platform) => normalizeTringPlatform2(platform)).filter((platform) => Boolean(platform));
+    const tringEnabledFor = (platform) => Boolean(config.channels.tring.enabled && tringPlatforms.includes(platform));
+    const tringAllowedChats = config.channels.tring.allowedChats ?? [];
     if (channel === "telegram") {
+      if (!config.channels.telegram.enabled && tringEnabledFor("telegram")) {
+        if (tringAllowedChats.length === 0)
+          return true;
+        return tringAllowedChats.includes(chatId);
+      }
       const configured = config.channels.telegram.allowedChats ?? [];
       const requirePairing = config.channels.telegram.requirePairing ?? configured.length === 0;
       if (!requirePairing && configured.includes(chatId))
@@ -58227,12 +59410,23 @@ function setupGatewayStores(params) {
         return true;
     }
     if (channel === "whatsapp") {
+      if (!config.channels.whatsapp.enabled && tringEnabledFor("whatsapp")) {
+        if (tringAllowedChats.length === 0)
+          return true;
+        return tringAllowedChats.includes(chatId);
+      }
       const allowedNumbers = config.channels.whatsapp.allowedNumbers ?? [];
       if (allowedNumbers.length === 0)
         return true;
       if (chatId && allowedNumbers.includes(chatId))
         return true;
     }
+    if ((channel === "signal" || channel === "whispr") && tringEnabledFor("signal")) {
+      if (tringAllowedChats.length === 0)
+        return true;
+      if (chatId && tringAllowedChats.includes(chatId))
+        return true;
+    }
     if (channel === "imessage") {
       const allowedChats = config.channels.imessage.allowedChats ?? [];
       if (allowedChats.length === 0)
@@ -58257,6 +59451,7 @@ function setupGatewayStores(params) {
     twitterAdapterRef,
     whatsappAdapterRef,
     imessageAdapterRef,
+    tringAdapterRef,
     skillManifestsRef,
     broadcastEvent,
     getProvider,
@@ -58264,6 +59459,26 @@ function setupGatewayStores(params) {
     isChannelAllowed
   };
 }
+async function sendTringMessage(adapter, platform, chatId, content) {
+  await adapter.sendMessage(platform, chatId, content);
+}
+function normalizeTringPlatform2(platform) {
+  const normalized = platform.trim().toLowerCase();
+  if (normalized === "whispr")
+    return "signal";
+  if (normalized === "telegram" || normalized === "whatsapp" || normalized === "signal")
+    return normalized;
+  return void 0;
+}
+function normalizeTringChannel(channel) {
+  if (channel === "telegram")
+    return "telegram";
+  if (channel === "whatsapp")
+    return "whatsapp";
+  if (channel === "signal" || channel === "whispr")
+    return "signal";
+  return void 0;
+}
 
 // apps/gateway/dist/gateway/setup-tools.js
 async function setupGatewayTools(ctx) {
@@ -58340,271 +59555,244 @@ async function setupGatewayTools(ctx) {
   };
 }
 
-// apps/gateway/dist/gateway/setup-smriti.js
-import fs36 from "node:fs";
-import path34 from "node:path";
-function resolveSmritiRuntimeConfig(params) {
-  const { config, repoRoot, logger } = params;
-  const smritiConfig = config.smriti ?? {};
-  const smritiEnabled = smritiConfig.enabled ?? false;
-  const smritiBaseUrl = smritiConfig.baseUrl ?? "http://127.0.0.1:7788";
-  const smritiConfigPath = process.env.SMRITI_CONFIG_PATH ?? path34.resolve(repoRoot, "smriti", "smriti.config.json");
-  let smritiLocalConfig = null;
-  if (smritiEnabled && smritiBaseUrl && fs36.existsSync(smritiConfigPath)) {
-    try {
-      const raw = fs36.readFileSync(smritiConfigPath, "utf8");
-      smritiLocalConfig = JSON.parse(raw);
-    } catch (error) {
-      logger.warn("smriti_config_load_failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  let smritiApiKey = smritiConfig.apiKey;
-  if (!smritiApiKey && smritiEnabled && smritiBaseUrl) {
-    try {
-      const parsed = new URL(smritiBaseUrl);
-      if (isLoopbackHost(parsed.hostname)) {
-        const storageRoot = smritiLocalConfig?.storage?.root;
-        if (storageRoot) {
-          const baseDir = path34.dirname(smritiConfigPath);
-          const resolvedStorage = path34.isAbsolute(storageRoot) ? storageRoot : path34.resolve(baseDir, storageRoot);
-          const keyPath = path34.join(resolvedStorage, "keys", "master.key");
-          if (fs36.existsSync(keyPath)) {
-            const key = fs36.readFileSync(keyPath, "utf8").trim();
-            if (key) {
-              smritiApiKey = key;
-              logger.info("smriti_master_key_loaded", { path: keyPath });
-            }
+// apps/gateway/dist/gateway/summary-llm.js
+function buildOutboundPromptText4(messages) {
+  return messages.map((message) => `${message.role}: ${message.content}`).join("\n");
+}
+function createSummaryLLM(getProvider, getModel, logger) {
+  return {
+    async generate(prompt) {
+      const provider = getProvider();
+      if (!provider) {
+        logger?.warn("summary_llm_no_provider");
+        throw new Error("No provider available for summarization");
+      }
+      const model = getModel() ?? "gpt-4o-mini";
+      try {
+        const messages = [
+          {
+            role: "system",
+            content: "You are a concise summarizer. Generate clear, factual summaries that preserve important details."
+          },
+          {
+            role: "user",
+            content: prompt
           }
-        }
+        ];
+        const requestMeta = buildChatMeta({
+          purpose: "summary",
+          providerId: provider.id,
+          model,
+          normalization: buildNormalizationOutboundMeta(normalizeIncomingText(buildOutboundPromptText4(messages)))
+        });
+        const response = await chatWithPolicy({
+          provider,
+          request: buildChatRequest({
+            model,
+            messages,
+            temperature: 0.3,
+            maxTokens: 1024,
+            metadata: requestMeta
+          }),
+          logger,
+          meta: requestMeta
+        });
+        logger?.info("summary_llm_generated", {
+          provider: provider.id,
+          model,
+          inputLength: prompt.length,
+          outputLength: response.content.length
+        });
+        return response.content;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger?.error("summary_llm_error", {
+          error: message,
+          provider: provider.id,
+          model
+        });
+        throw error;
       }
-    } catch (error) {
-      logger.warn("smriti_master_key_load_failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
     }
-  }
-  const smritiPrefix = smritiConfig.prefix;
-  const smritiOwner = smritiConfig.owner;
-  const smritiAutoCapture = smritiConfig.autoCapture ?? false;
-  const smritiAutoCaptureMode = smritiConfig.autoCaptureMode ?? "exchange";
-  const smritiRetrieveEnabled = smritiConfig.retrieveEnabled ?? false;
-  const smritiRetrieveLimit = smritiConfig.retrieveLimit ?? 5;
-  const smritiDefaultTags = smritiConfig.defaultTags ?? void 0;
-  const smritiSource = smritiConfig.source;
-  const smritiAutoMemoryEnabled = smritiConfig.autoMemoryEnabled ?? false;
-  const smritiAutoMemoryPython = smritiConfig.autoMemoryPython ?? "python3";
-  const smritiAutoMemoryFallbackRoot = path34.resolve(repoRoot, "skills-core", "smriti-auto-memory", "hooks", "scripts");
-  const smritiAutoMemoryRootCandidates = [
-    smritiAutoMemoryFallbackRoot,
-    path34.resolve(repoRoot, "..", "ecosystem", "skills", "smriti-auto-memory", "hooks", "scripts"),
-    path34.resolve(repoRoot, "skills", "smriti-auto-memory", "hooks", "scripts")
-  ];
-  const smritiAutoMemoryDefaultRoot = smritiAutoMemoryRootCandidates.find((candidate) => fs36.existsSync(candidate)) ?? smritiAutoMemoryFallbackRoot;
-  const smritiAutoMemoryRoot = smritiConfig.autoMemoryPath ?? smritiAutoMemoryDefaultRoot;
-  const smritiAutoMemorySessionScript = path34.join(smritiAutoMemoryRoot, "session-start.py");
-  const smritiAutoMemoryPromptScript = path34.join(smritiAutoMemoryRoot, "user-prompt.py");
-  const smritiAutoMemoryReady = smritiEnabled && smritiAutoMemoryEnabled && Boolean(smritiApiKey) && fs36.existsSync(smritiAutoMemorySessionScript) && fs36.existsSync(smritiAutoMemoryPromptScript);
-  const smritiClientOptions = smritiEnabled && smritiBaseUrl ? {
-    baseUrl: smritiBaseUrl,
-    apiKey: smritiApiKey,
-    timeoutMs: smritiConfig.timeoutMs,
-    prefix: smritiPrefix ? smritiPrefix.replace(/\/$/, "") : smritiOwner ? `user/${normalizeSmritiOwner(smritiOwner)}` : void 0
-  } : void 0;
-  return {
-    smritiConfig,
-    smritiEnabled,
-    smritiBaseUrl,
-    smritiApiKey,
-    smritiPrefix,
-    smritiOwner,
-    smritiAutoCapture,
-    smritiAutoCaptureMode,
-    smritiRetrieveEnabled,
-    smritiRetrieveLimit,
-    smritiDefaultTags,
-    smritiSource,
-    smritiAutoMemoryEnabled,
-    smritiAutoMemoryPython,
-    smritiAutoMemoryRoot,
-    smritiAutoMemorySessionScript,
-    smritiAutoMemoryPromptScript,
-    smritiAutoMemoryReady,
-    smritiClientOptions,
-    smritiVectorProvider: smritiLocalConfig?.vector?.provider,
-    smritiVectorFallbacks: smritiLocalConfig?.vector?.fallbackProviders,
-    smritiEmbeddingProviders: smritiLocalConfig?.embeddings?.providerPriority
   };
 }
 
-// apps/gateway/dist/gateway/identity-loader.js
-import fs37 from "node:fs";
-import path35 from "node:path";
-var MAX_PROMPT_CHARS_DEFAULT = 12e3;
-function uniqueStrings(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const value of values) {
-    if (!value)
-      continue;
-    if (seen.has(value))
-      continue;
-    seen.add(value);
-    out.push(value);
+// apps/gateway/dist/gateway/setup-core.js
+var HARD_DEPRECATED_MODELS = {
+  anthropic: /* @__PURE__ */ new Set([
+    "claude-sonnet-4-20250514",
+    "claude-opus-4-5",
+    "claude-opus-4-5-20251101",
+    "claude-3-5-haiku-20241022"
+  ])
+};
+var KOSHA_DISCOVERY_REFRESH_MS = 5 * 60 * 1e3;
+var KOSHA_PATH_ENV = "KOSHA_DISCOVERY_PATH";
+var koshaState = {};
+async function resolveKoshaRegistry(refresh) {
+  const now = Date.now();
+  if (!refresh && koshaState.registry && koshaState.resolvedAt) {
+    if (now - koshaState.resolvedAt < KOSHA_DISCOVERY_REFRESH_MS) {
+      return {
+        registry: koshaState.registry,
+        source: "cached"
+      };
+    }
   }
-  return out;
-}
-function buildCandidateRoots(repoRoot) {
-  const roots = [repoRoot];
-  let current = repoRoot;
-  for (let i = 0; i < 3; i += 1) {
-    const parent = path35.dirname(current);
-    if (!parent || parent === current)
-      break;
-    roots.push(parent);
-    current = parent;
+  if (koshaState.loadingPromise) {
+    return koshaState.loadingPromise;
   }
-  return uniqueStrings(roots);
-}
-function readFirstExisting(roots, filenames) {
-  for (const root of roots) {
-    for (const name of filenames) {
-      const candidate = path35.join(root, name);
+  const loadRegistry = async () => {
+    const importTargets = [];
+    const envPath = process.env[KOSHA_PATH_ENV];
+    if (envPath) {
+      importTargets.push(envPath);
+      if (envPath.endsWith("dist/index.js") === false) {
+        importTargets.push(path37.join(envPath, "dist", "index.js"));
+      }
+    }
+    const localCandidate = path37.resolve(process.cwd(), "..", "kosha-discovery", "dist", "index.js");
+    importTargets.push(localCandidate);
+    importTargets.push("kosha-discovery");
+    let lastFailure;
+    let lastFailureTarget;
+    for (const rawTarget of importTargets) {
+      const target = fs39.existsSync(rawTarget) ? pathToFileURL(path37.resolve(rawTarget)).href : rawTarget;
+      const source = rawTarget;
       try {
-        if (!fs37.existsSync(candidate))
+        const mod = await import(target);
+        if (!mod?.createKosha) {
+          lastFailure = `Kosha module missing createKosha export: ${source}`;
+          lastFailureTarget = source;
           continue;
-        const text = fs37.readFileSync(candidate, "utf8").trim();
-        if (!text)
+        }
+        const registry = await mod.createKosha();
+        if (!registry?.models || typeof registry.models !== "function") {
+          lastFailure = `Invalid Kosha registry shape from ${source}`;
+          lastFailureTarget = source;
           continue;
-        return { file: candidate, text };
-      } catch {
+        }
+        return { registry, source };
+      } catch (error) {
+        lastFailure = error instanceof Error ? error.message : String(error);
+        lastFailureTarget = source;
       }
     }
+    return {
+      error: lastFailure ?? "kosha discovery unavailable",
+      source: lastFailureTarget
+    };
+  };
+  const start = Date.now();
+  const inFlight = loadRegistry().finally(() => {
+    koshaState.loadingPromise = void 0;
+  });
+  koshaState.loadingPromise = inFlight;
+  const resolution = await inFlight;
+  if (!resolution.registry) {
+    const elapsedMs = Date.now() - start;
+    return {
+      ...resolution,
+      error: `${resolution.error} (refresh_ms=${elapsedMs})`
+    };
   }
-  return null;
+  if (resolution.source === void 0) {
+    resolution.source = "resolved";
+  }
+  koshaState.registry = resolution.registry;
+  koshaState.resolvedAt = Date.now();
+  return {
+    ...resolution,
+    source: resolution.source
+  };
 }
-function extractIdentityFields(identity, user) {
-  const fields = {};
-  if (identity) {
-    const nameMatch = identity.match(/(?:^|\n)\s*(?:-\s*)?(?:\*\*)?Name(?:\*\*)?:\s*(?:\*\*)?(.+?)(?:\*\*)?$/im);
-    if (nameMatch?.[1]) {
-      const raw = nameMatch[1].trim().replace(/^_\(?|_?\)?$/g, "");
-      if (raw && !raw.startsWith("(") && raw.length < 64) {
-        fields.assistantName = raw;
-      }
-    }
-    const emojiMatch = identity.match(/(?:^|\n)\s*(?:-\s*)?(?:\*\*)?Emoji(?:\*\*)?:\s*(?:\*\*)?(.+?)(?:\*\*)?$/im);
-    if (emojiMatch?.[1]) {
-      const raw = emojiMatch[1].trim().replace(/^_\(?|_?\)?$/g, "");
-      if (raw && !raw.startsWith("(") && raw.length < 8) {
-        fields.emoji = raw;
-      }
+function resolveProviderEnvApiKey(envKeys) {
+  for (const key of envKeys) {
+    const value = process.env[key];
+    if (value?.trim()) {
+      return value.trim();
     }
   }
-  if (user) {
-    if (!fields.userName) {
-      const callMatch = user.match(/(?:^|\n)\s*(?:What to call them|Call them|User name|userName):\s*(.+?)$/im);
-      if (callMatch?.[1]) {
-        const raw = callMatch[1].trim().split(/\s*[/,]\s*/)[0];
-        if (raw && raw.length < 64) {
-          fields.userName = raw;
-        }
-      }
+  return void 0;
+}
+function enrichProvidersWithEnvDefaults(baseEntries) {
+  const resolvedEntries = { ...baseEntries };
+  const fallbackSpecs = [
+    {
+      providerId: "google",
+      type: "google",
+      defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta",
+      envKeys: ["GOOGLE_API_KEY", "GEMINI_API_KEY", "VAAYU_GOOGLE_API_KEY", "VAAYU_PROVIDER_GOOGLE_API_KEY"]
+    },
+    {
+      providerId: "openai",
+      type: "openai-compatible",
+      defaultBaseUrl: "https://api.openai.com/v1",
+      envKeys: ["OPENAI_API_KEY", "VAAYU_OPENAI_API_KEY", "VAAYU_PROVIDER_OPENAI_API_KEY", "VAAYU_EMBEDDING_API_KEY"]
     }
-    if (!fields.assistantName) {
-      const assistantCallMatch = user.match(/(?:^|\n)\s*(?:What to call assistant|Assistant name|assistantName):\s*(.+?)$/im);
-      if (assistantCallMatch?.[1]) {
-        const raw = assistantCallMatch[1].trim();
-        if (raw && raw.length < 64) {
-          fields.assistantName = raw;
-        }
-      }
+  ];
+  for (const spec of fallbackSpecs) {
+    const existing = resolvedEntries[spec.providerId];
+    const apiKey = resolveProviderEnvApiKey(spec.envKeys);
+    const baseUrl = (() => {
+      const explicit = process.env[`VAAYU_PROVIDER_${spec.providerId.toUpperCase()}_BASE_URL`];
+      return existing?.baseUrl || explicit || spec.defaultBaseUrl;
+    })();
+    if (!existing && !apiKey) {
+      continue;
     }
+    resolvedEntries[spec.providerId] = {
+      ...existing,
+      type: existing?.type || spec.type,
+      baseUrl: existing?.baseUrl || baseUrl,
+      apiKey: existing?.apiKey || apiKey
+    };
   }
-  return fields;
+  return resolvedEntries;
 }
-function truncatePrompt(text, maxChars) {
-  if (text.length <= maxChars)
-    return text;
-  return `${text.slice(0, maxChars)}
-
-[...identity truncated]`;
-}
-function loadWorkspaceIdentityPrompt(params) {
-  const roots = buildCandidateRoots(params.repoRoot);
-  const maxChars = params.maxPromptChars ?? MAX_PROMPT_CHARS_DEFAULT;
-  const filesLoaded = [];
-  const parts = [];
-  const soul = readFirstExisting(roots, ["SOUL.md", "soul.md"]);
-  if (soul) {
-    filesLoaded.push(soul.file);
-    parts.push(soul.text);
-  }
-  const identity = readFirstExisting(roots, ["IDENTITY.md", "identity.md"]);
-  if (identity) {
-    filesLoaded.push(identity.file);
-    parts.push(identity.text);
-  }
-  const personality = readFirstExisting(roots, ["PERSONALITY.md", "personality.md"]);
-  if (personality) {
-    filesLoaded.push(personality.file);
-    parts.push(personality.text);
-  }
-  const user = readFirstExisting(roots, ["USER.md", "user.md"]);
-  if (user) {
-    filesLoaded.push(user.file);
-    parts.push(user.text);
+async function listProviderModelsFromKosha(providerId, refresh, overrideLayers) {
+  const resolution = await resolveKoshaRegistry(refresh);
+  if (!resolution.registry) {
+    return {
+      models: [],
+      source: resolution.source === "cached" ? "cached" : "fallback",
+      error: resolution.error ?? "kosha_discovery_unavailable"
+    };
   }
-  const fields = extractIdentityFields(identity?.text, user?.text);
-  const prompt = truncatePrompt(parts.filter(Boolean).join("\n\n"), maxChars).trim();
-  return { prompt, rootsChecked: roots, filesLoaded, fields };
-}
-function reloadIdentity(params) {
-  return loadWorkspaceIdentityPrompt(params);
-}
-
-// apps/gateway/dist/gateway/config-path.js
-import fs38 from "node:fs";
-import path36 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-var GATEWAY_CONFIG_FILENAMES = [
-  "vaayu.config.json",
-  "vaayu.config.yaml",
-  "vaayu.config.yml"
-];
-function resolvePreferredGatewayConfigPath(params) {
-  const envConfigPath = params?.envConfigPath ?? process.env.VAAYU_CONFIG;
-  if (envConfigPath?.trim()) {
-    return void 0;
+  const registry = resolution.registry;
+  const cards = /* @__PURE__ */ new Map();
+  const direct = registry.models({
+    provider: providerId,
+    mode: "chat"
+  });
+  for (const card of direct) {
+    const key = `${card.provider ?? providerId}:${card.id}`;
+    cards.set(key, card);
   }
-  const existsSync3 = params?.existsSync ?? fs38.existsSync;
-  const moduleFilePath = params?.moduleFilePath ?? fileURLToPath2(import.meta.url);
-  let currentDir = path36.dirname(moduleFilePath);
-  for (let depth = 0; depth < 10; depth += 1) {
-    for (const filename of GATEWAY_CONFIG_FILENAMES) {
-      const candidate = path36.join(currentDir, filename);
-      if (existsSync3(candidate)) {
-        return candidate;
+  if (!cards.size) {
+    for (const card of registry.models({
+      originProvider: providerId,
+      mode: "chat"
+    })) {
+      const key = `${card.provider ?? providerId}:${card.id}`;
+      if (!cards.has(key)) {
+        cards.set(key, card);
       }
     }
-    const parent = path36.dirname(currentDir);
-    if (parent === currentDir)
-      break;
-    currentDir = parent;
   }
-  return void 0;
+  if (!cards.size) {
+    return {
+      models: [],
+      source: resolution.source === "cached" ? "cached" : "fallback",
+      error: `No chat models found in kosha for provider "${providerId}"`
+    };
+  }
+  const rawModels = Array.from(cards.values()).map((card) => card.id);
+  return {
+    models: applyModelOverrides(Array.from(new Set(rawModels)), overrideLayers),
+    source: "kosha"
+  };
 }
-
-// apps/gateway/dist/gateway/setup-core.js
-var HARD_DEPRECATED_MODELS = {
-  anthropic: /* @__PURE__ */ new Set([
-    "claude-sonnet-4-20250514",
-    "claude-opus-4-5",
-    "claude-opus-4-5-20251101",
-    "claude-3-5-haiku-20241022"
-  ])
-};
 function stripHardDeprecatedModels(providerId, models) {
   const blocked = HARD_DEPRECATED_MODELS[providerId];
   if (!blocked || blocked.size === 0)
@@ -58659,6 +59847,7 @@ async function setupGatewayCore() {
   }
   const state = { startedAt: Date.now(), httpRequestCount: 0 };
   const idempotency = new IdempotencyStore(12e4);
+  config.providers.entries = enrichProvidersWithEnvDefaults(config.providers.entries);
   const providers = createRegistry(config.providers);
   if (providers.list().length === 0) {
     providers.register(new MockProvider({ id: "mock" }));
@@ -58766,6 +59955,21 @@ async function setupGatewayCore() {
         error = remote.error;
       }
     }
+    if (!models.length) {
+      const kosha = await listProviderModelsFromKosha(providerId, refresh, overrideLayers);
+      if (kosha.models.length) {
+        models = stripHardDeprecatedModels(providerId, applyModelOverrides(kosha.models, overrideLayers));
+        modelSource = kosha.source;
+        error ??= kosha.error;
+      } else if (kosha.error) {
+        error = error ? `${error}; ${kosha.error}` : kosha.error;
+        logger.warn("model_list_kosha_unavailable", {
+          providerId,
+          reason: kosha.error,
+          refresh
+        });
+      }
+    }
     if (!models.length && cached2?.models?.length) {
       const cachedModels = stripHardDeprecatedModels(providerId, applyModelOverrides(cached2.models, overrideLayers));
       if (cachedModels.length) {
@@ -58893,7 +60097,7 @@ async function setupGatewayCore() {
       "proactiveAllowed",
       "proactiveAllowedChannels"
     ]) {
-      if (Object.prototype.hasOwnProperty.call(raw, key) && raw[key] === null) {
+      if (Object.hasOwn(raw, key) && raw[key] === null) {
         cleared[key] = void 0;
       }
     }
@@ -60344,14 +61548,14 @@ async function bootstrapCliProviders(logger, providers) {
   }
 }
 
-// packages/backup/src/manager.js
+// packages/backup/src/manager.ts
 import path42 from "node:path";
 
-// packages/backup/src/storage.js
+// packages/backup/src/storage.ts
 import path39 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 
-// packages/backup/src/utils.js
+// packages/backup/src/utils.ts
 import fs40 from "node:fs";
 import path38 from "node:path";
 import os11 from "node:os";
@@ -60382,8 +61586,7 @@ function createSnapshotId(date = /* @__PURE__ */ new Date()) {
 function readJson3(filePath, fallback) {
   try {
     const raw = fs40.readFileSync(filePath, "utf8");
-    if (!raw)
-      return fallback;
+    if (!raw) return fallback;
     return JSON.parse(raw);
   } catch {
     return fallback;
@@ -60403,12 +61606,11 @@ function copyDirSafe(src, dest) {
   fs40.cpSync(src, dest, { recursive: true });
 }
 function deleteDirSafe(dir) {
-  if (!fs40.existsSync(dir))
-    return;
+  if (!fs40.existsSync(dir)) return;
   fs40.rmSync(dir, { recursive: true, force: true });
 }
 
-// packages/backup/src/storage.js
+// packages/backup/src/storage.ts
 async function backupStorage(params) {
   const { storage, snapshotDir, logger } = params;
   const driver = storage.driver;
@@ -60436,7 +61638,11 @@ async function backupStorage(params) {
     }
     if (driver === "postgres") {
       const dest = path39.join(storageDir, "postgres.dump");
-      const result = spawnSync2("pg_dump", ["--format=c", "--file", dest, storage.postgresUrl ?? ""], { stdio: "pipe" });
+      const result = spawnSync2(
+        "pg_dump",
+        ["--format=c", "--file", dest, storage.postgresUrl ?? ""],
+        { stdio: "pipe" }
+      );
       if (result.status !== 0) {
         const error = result.stderr?.toString() || "pg_dump failed";
         logger.warn("backup_pg_dump_failed", { error });
@@ -60472,7 +61678,11 @@ async function restoreStorage(params) {
     }
     if (storage.driver === "postgres") {
       const dumpPath = path39.join(storageDir, "postgres.dump");
-      const result = spawnSync2("pg_restore", ["--clean", "--if-exists", "--dbname", storage.postgresUrl ?? "", dumpPath], { stdio: "pipe" });
+      const result = spawnSync2(
+        "pg_restore",
+        ["--clean", "--if-exists", "--dbname", storage.postgresUrl ?? "", dumpPath],
+        { stdio: "pipe" }
+      );
       if (result.status !== 0) {
         const error = result.stderr?.toString() || "pg_restore failed";
         logger.warn("backup_pg_restore_failed", { error });
@@ -60486,15 +61696,14 @@ async function restoreStorage(params) {
   }
 }
 
-// packages/backup/src/qdrant.js
+// packages/backup/src/qdrant.ts
 import fs41 from "node:fs";
 import path40 from "node:path";
 var DEFAULT_COLLECTION2 = "vaayu-smriti";
 var DEFAULT_TIMEOUT_MS3 = 8e3;
 function buildHeaders(apiKey) {
   const headers = { "content-type": "application/json" };
-  if (apiKey)
-    headers["api-key"] = apiKey;
+  if (apiKey) headers["api-key"] = apiKey;
   return headers;
 }
 async function fetchJson3(url, init, timeoutMs) {
@@ -60520,7 +61729,11 @@ async function backupQdrant(params) {
   const collection = config.collection ?? DEFAULT_COLLECTION2;
   const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   try {
-    const createResp = await fetchJson3(`${url}/collections/${collection}/snapshots`, { method: "POST", headers: buildHeaders(config.apiKey), body: "{}" }, timeoutMs);
+    const createResp = await fetchJson3(
+      `${url}/collections/${collection}/snapshots`,
+      { method: "POST", headers: buildHeaders(config.apiKey), body: "{}" },
+      timeoutMs
+    );
     const snapshotName = createResp?.result?.name ?? createResp?.name;
     if (!snapshotName) {
       return { ok: false, error: "Missing snapshot name" };
@@ -60544,7 +61757,7 @@ async function backupQdrant(params) {
   }
 }
 
-// packages/backup/src/manifest.js
+// packages/backup/src/manifest.ts
 import path41 from "node:path";
 var INDEX_NAME = "index.json";
 var MANIFEST_NAME = "manifest.json";
@@ -60572,10 +61785,9 @@ function saveBackupManifest(snapshotDir, manifest) {
   writeJson2(getManifestPath(snapshotDir), manifest);
 }
 
-// packages/backup/src/manager.js
+// packages/backup/src/manager.ts
 var shouldRun = (lastAt, intervalMinutes) => {
-  if (!lastAt)
-    return true;
+  if (!lastAt) return true;
   const elapsed = Date.now() - Date.parse(lastAt);
   return elapsed >= intervalMinutes * 6e4;
 };
@@ -60656,11 +61868,9 @@ function createBackupManager(params) {
     return restoreStorage({ storage, snapshotDir, logger });
   };
   const start = () => {
-    if (!config.enabled || timer)
-      return;
+    if (!config.enabled || timer) return;
     timer = setInterval(() => {
-      if (!config.enabled)
-        return;
+      if (!config.enabled) return;
       if (shouldRun(lastStorageRunAt, config.intervalMinutes)) {
         void run("scheduled").catch((error) => {
           logger.warn("backup_scheduled_run_failed", {
@@ -60678,8 +61888,7 @@ function createBackupManager(params) {
     }
   };
   const stop = () => {
-    if (!timer)
-      return;
+    if (!timer) return;
     clearInterval(timer);
     timer = void 0;
   };
@@ -60704,8 +61913,7 @@ function updateIndex(localDir, manifest, keepLast, keepDays) {
   const next = [manifest, ...index.backups.filter((item) => item.id !== manifest.id)];
   const now = Date.now();
   const filtered = next.filter((item, idx) => {
-    if (keepLast && idx < keepLast)
-      return true;
+    if (keepLast && idx < keepLast) return true;
     if (keepDays) {
       const created = Date.parse(item.startedAt);
       return now - created <= keepDays * 24 * 60 * 60 * 1e3;
@@ -60720,8 +61928,8 @@ function updateIndex(localDir, manifest, keepLast, keepDays) {
 }
 
 // apps/gateway/dist/providers/health.js
-import { spawn as spawn5 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
 import net from "node:net";
 var DEFAULT_OLLAMA_URL = "http://127.0.0.1:11434";
 var parseModel = (model) => {
@@ -60741,8 +61949,8 @@ var matchesRequired = (required, installed) => {
   }
   return required.base === installed.base;
 };
-var wait = (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
+var wait = (ms) => new Promise((resolve3) => {
+  setTimeout(resolve3, ms);
 });
 var normalizeBaseUrl5 = (value) => {
   if (!value)
@@ -60835,7 +62043,7 @@ var resolveOllamaBinary2 = () => {
     return process.env.OLLAMA_PATH;
   const candidates = ["/opt/homebrew/bin/ollama", "/usr/local/bin/ollama", "/usr/bin/ollama"];
   for (const candidate of candidates) {
-    if (existsSync2(candidate))
+    if (existsSync3(candidate))
       return candidate;
   }
   return "ollama";
@@ -60864,24 +62072,24 @@ var isTcpListening = async (baseUrl) => {
   }
   if (!host || !Number.isFinite(port) || port <= 0)
     return false;
-  return await new Promise((resolve) => {
+  return await new Promise((resolve3) => {
     const socket = net.connect({ host, port });
     const timeout = setTimeout(() => {
       socket.destroy();
-      resolve(false);
+      resolve3(false);
     }, 350);
     socket.once("connect", () => {
       clearTimeout(timeout);
       socket.destroy();
-      resolve(true);
+      resolve3(true);
     });
     socket.once("error", () => {
       clearTimeout(timeout);
-      resolve(false);
+      resolve3(false);
     });
   });
 };
-var tryStartOllama = async (logger, params) => new Promise((resolve) => {
+var tryStartOllama = async (logger, params) => new Promise((resolve3) => {
   try {
     const bin = resolveOllamaBinary2();
     const env = { ...process.env };
@@ -60892,7 +62100,7 @@ var tryStartOllama = async (logger, params) => new Promise((resolve) => {
     if (params?.keepAlive) {
       env.OLLAMA_KEEP_ALIVE = params.keepAlive;
     }
-    const proc = spawn5(bin, ["serve"], {
+    const proc = spawn6(bin, ["serve"], {
       detached: true,
       stdio: "ignore",
       env
@@ -60908,7 +62116,7 @@ var tryStartOllama = async (logger, params) => new Promise((resolve) => {
         host,
         keepAlive: params?.keepAlive
       });
-      resolve(false);
+      resolve3(false);
     });
     proc.once("exit", (code, signal) => {
       if (settled)
@@ -60921,7 +62129,7 @@ var tryStartOllama = async (logger, params) => new Promise((resolve) => {
         host,
         keepAlive: params?.keepAlive
       });
-      resolve(false);
+      resolve3(false);
     });
     setTimeout(() => {
       if (settled)
@@ -60932,7 +62140,7 @@ var tryStartOllama = async (logger, params) => new Promise((resolve) => {
         host,
         keepAlive: params?.keepAlive
       });
-      resolve(true);
+      resolve3(true);
     }, 300);
   } catch (error) {
     logger.warn("ollama_autostart_failed", {
@@ -60941,7 +62149,7 @@ var tryStartOllama = async (logger, params) => new Promise((resolve) => {
       host: resolveOllamaHost(params?.baseUrl),
       keepAlive: params?.keepAlive
     });
-    resolve(false);
+    resolve3(false);
   }
 });
 async function fetchOllamaModels(entry, providerId, logger) {
@@ -61667,25 +62875,108 @@ function acquireGatewayInstanceLock(params) {
   throw new Error(`Gateway instance lock unavailable: ${lockPath}`);
 }
 
+// apps/gateway/dist/chitragupta-bridge/bridge.js
+import { dirname as dirname2, extname, resolve as resolve2 } from "node:path";
+
+// apps/gateway/dist/chitragupta-bridge/turiya-helpers.js
+async function classifyTuriya(baseUrls, timeoutMs, params) {
+  const text = params.text?.trim();
+  if (!text)
+    return null;
+  for (const baseUrl of baseUrls) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}/api/turiya/classify`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ text, messageCount: params.messageCount, hasTools: params.hasTools, memoryHits: params.memoryHits }),
+        signal: controller.signal
+      });
+      if (!response.ok)
+        continue;
+      const payload = await response.json();
+      if (typeof payload.tier !== "string")
+        continue;
+      return {
+        tier: payload.tier,
+        confidence: typeof payload.confidence === "number" ? payload.confidence : 0.5,
+        costEstimate: typeof payload.costEstimate === "number" ? payload.costEstimate : 0
+      };
+    } catch {
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  return null;
+}
+async function recordTuriyaOutcome(baseUrls, timeoutMs, params) {
+  for (const baseUrl of baseUrls) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      await fetch(`${baseUrl}/api/turiya/outcome`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(params),
+        signal: controller.signal
+      });
+      return;
+    } catch {
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
 // apps/gateway/dist/chitragupta-bridge/bridge.js
 var CACHE_TTL_MS = 500;
+var DEFAULT_SKILL_LEARNER_STATE_FILE = "skill-learner-state.json";
 var ChitraguptaBridge = class _ChitraguptaBridge {
   orchestrator;
+  vidyaBridge;
   logger;
   margaBaseUrl;
   margaTimeoutMs;
   skillsUsedPerSession = /* @__PURE__ */ new Map();
   shiksha;
   crystallizer;
+  skillResolver;
+  skillLearner;
+  skillLearnerStatePath;
+  loggedShikshaUnavailable = false;
+  loggedCrystallizerUnavailable = false;
   recCache = null;
   recCacheQuery = "";
-  constructor(orchestrator, logger, margaBaseUrl, margaTimeoutMs, shiksha = null, crystallizer = null) {
+  constructor(orchestrator, vidyaBridge, logger, margaBaseUrl, margaTimeoutMs, shiksha = null, crystallizer = null, skillResolver, skillLearner, skillLearnerStatePath) {
     this.orchestrator = orchestrator;
+    this.vidyaBridge = vidyaBridge;
     this.logger = logger;
     this.margaBaseUrl = margaBaseUrl.replace(/\/+$/, "");
     this.margaTimeoutMs = margaTimeoutMs;
     this.shiksha = shiksha;
     this.crystallizer = crystallizer;
+    this.skillResolver = skillResolver ?? new SkillResolver({
+      logger: { info: (m, d) => logger.info(m, d), warn: (m, d) => logger.warn(m, d) }
+    });
+    this.skillLearner = skillLearner ?? new SkillLearner({
+      logger: { info: (m, d) => logger.info(m, d), warn: (m, d) => logger.warn(m, d) }
+    });
+    this.skillLearnerStatePath = skillLearnerStatePath ?? _ChitraguptaBridge.resolveSkillLearnerStatePath();
+  }
+  static resolveSkillLearnerStatePath(configPersistPath) {
+    const explicitPath = process.env.VAAYU_SKILL_LEARNER_STATE_PATH?.trim();
+    if (explicitPath)
+      return resolve2(explicitPath);
+    const configuredBase = configPersistPath?.trim();
+    if (configuredBase) {
+      const baseDir = extname(configuredBase) ? dirname2(configuredBase) : configuredBase;
+      return resolve2(baseDir, DEFAULT_SKILL_LEARNER_STATE_FILE);
+    }
+    const home = process.env.CHITRAGUPTA_HOME?.trim();
+    if (home)
+      return resolve2(home, DEFAULT_SKILL_LEARNER_STATE_FILE);
+    return resolve2(process.cwd(), ".chitragupta", DEFAULT_SKILL_LEARNER_STATE_FILE);
   }
   /* ── Factory ───────────────────────────────────────────────────── */
   /** Create a bridge instance. Returns null if Chitragupta is unavailable. */
@@ -61705,24 +62996,29 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
       }
       if (!vidya)
         throw lastError ?? new Error("Chitragupta skill runtime not found");
-      const registry = new vidya.SkillRegistry();
-      const bridge = new vidya.VidyaBridge(registry);
+      const Ctor = vidya;
+      const registry = new Ctor.SkillRegistry();
+      const bridge = new Ctor.VidyaBridge(registry);
       const autoLearn = config.enableAutoLearn ?? false;
       let shiksha = null;
-      if (autoLearn && vidya.ShikshaController) {
+      if (autoLearn && Ctor.ShikshaController) {
         try {
-          shiksha = new vidya.ShikshaController({ registry });
+          shiksha = new Ctor.ShikshaController({ registry });
         } catch {
         }
       }
+      if (autoLearn && !shiksha)
+        logger.warn("chitragupta_shiksha_unavailable", { autoLearn });
       let crystallizer = null;
-      if (vidya.SkillCrystallizer) {
+      if (Ctor.SkillCrystallizer) {
         try {
-          crystallizer = new vidya.SkillCrystallizer();
+          crystallizer = new Ctor.SkillCrystallizer();
         } catch {
         }
       }
-      const orchestrator = new vidya.VidyaOrchestrator({ registry, bridge }, { persistPath: config.persistPath, enableAutoLearn: autoLearn, enableAutoComposition: true });
+      if (!crystallizer)
+        logger.warn("chitragupta_crystallizer_unavailable");
+      const orchestrator = new Ctor.VidyaOrchestrator({ registry, bridge }, { persistPath: config.persistPath, enableAutoLearn: autoLearn, enableAutoComposition: true });
       await orchestrator.initialize();
       logger.info("chitragupta_bridge_initialized", {
         initialized: orchestrator.isInitialized,
@@ -61733,14 +63029,17 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
       const margaBaseUrl = process.env.VAAYU_CHITRAGUPTA_BASE_URL?.trim() || "http://localhost:3141";
       const timeoutFromEnv = Number.parseInt(process.env.VAAYU_CHITRAGUPTA_MARGA_TIMEOUT_MS ?? "", 10);
       const margaTimeoutMs = Number.isFinite(timeoutFromEnv) && timeoutFromEnv > 0 ? timeoutFromEnv : 150;
-      return new _ChitraguptaBridge(orchestrator, logger, margaBaseUrl, margaTimeoutMs, shiksha, crystallizer);
+      const logAdapter = { info: (m, d) => logger.info(m, d), warn: (m, d) => logger.warn(m, d) };
+      const skillResolver = new SkillResolver({ logger: logAdapter });
+      const skillLearnerStatePath = _ChitraguptaBridge.resolveSkillLearnerStatePath(config.persistPath);
+      const skillLearner = await SkillLearner.load(skillLearnerStatePath, { logger: logAdapter }) ?? new SkillLearner({ logger: logAdapter });
+      return new _ChitraguptaBridge(orchestrator, bridge, logger, margaBaseUrl, margaTimeoutMs, shiksha, crystallizer, skillResolver, skillLearner, skillLearnerStatePath);
     } catch (err) {
-      logger.debug("chitragupta_bridge_unavailable", {
-        reason: err instanceof Error ? err.message : String(err)
-      });
+      logger.debug("chitragupta_bridge_unavailable", { reason: err instanceof Error ? err.message : String(err) });
       return null;
     }
   }
+  /** Get Marga base URL candidates for HTTP calls. */
   getMargaBaseUrlCandidates() {
     const c = this.margaBaseUrl.replace(/\/+$/, "");
     const r = [c];
@@ -61750,6 +63049,7 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
       r.push("http://127.0.0.1:3141");
     return r;
   }
+  /* ── Marga Routing ────────────────────────────────────────────── */
   /** Query Chitragupta's stateless routing endpoint. Returns null when unavailable. */
   async decideRoute(params) {
     const message = params.message?.trim();
@@ -61774,10 +63074,6 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
         });
         if (!response.ok) {
           lastError = `HTTP ${response.status}`;
-          this.logger.debug("chitragupta_marga_http_error", {
-            status: response.status,
-            baseUrl
-          });
           continue;
         }
         const payload = await response.json();
@@ -61785,17 +63081,8 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
         const modelId = typeof payload.modelId === "string" ? payload.modelId.trim() : "";
         if (!providerId || !modelId) {
           lastError = "invalid_payload";
-          this.logger.debug("chitragupta_marga_invalid_payload", {
-            baseUrl
-          });
           continue;
         }
-        if (baseUrl !== this.margaBaseUrl) {
-          this.logger.debug("chitragupta_marga_baseurl_fallback_used", {
-            configuredBaseUrl: this.margaBaseUrl,
-            resolvedBaseUrl: baseUrl
-          });
-        }
         return {
           providerId,
           modelId,
@@ -61811,12 +63098,28 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
         clearTimeout(timeout);
       }
     }
-    this.logger.debug("chitragupta_marga_unavailable", {
-      reason: lastError,
-      baseUrl: this.margaBaseUrl
-    });
+    this.logger.debug("chitragupta_marga_unavailable", { reason: lastError, baseUrl: this.margaBaseUrl });
     return null;
   }
+  /* ── Tool Registration ────────────────────────────────────────── */
+  /** Register gateway tools with Vidya. Safe no-op when unavailable. */
+  registerTools(tools) {
+    if (!tools.length)
+      return 0;
+    const fn = this.vidyaBridge?.registerToolsAsSkills;
+    if (typeof fn !== "function")
+      return 0;
+    try {
+      const normalized = tools.map((t2) => ({ name: t2.name, description: t2.description ?? "", inputSchema: t2.inputSchema, tags: t2.tags, aliases: t2.aliases })).filter((t2) => t2.name.trim().length > 0);
+      if (!normalized.length)
+        return 0;
+      fn.call(this.vidyaBridge, normalized);
+      return normalized.length;
+    } catch (error) {
+      this.logger.debug("chitragupta_bridge_tool_registration_failed", { error: error instanceof Error ? error.message : String(error) });
+      return 0;
+    }
+  }
   /* ── Recommend ─────────────────────────────────────────────────── */
   /** Return recommended skill/tool names for a query (cached per-turn). */
   recommend(query) {
@@ -61824,8 +63127,7 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
       if (this.recCache && this.recCacheQuery === query && Date.now() - this.recCache.ts < CACHE_TTL_MS) {
         return this.recCache.names;
       }
-      const matches = this.orchestrator.recommend(query);
-      const names = matches.map((m) => m.manifest.name);
+      const names = this.orchestrator.recommend(query).map((m) => m.manifest.name);
       this.recCache = { names, ts: Date.now() };
       this.recCacheQuery = query;
       return names;
@@ -61840,17 +63142,14 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
       this.orchestrator.onSkillExecuted(toolName, success, latencyMs, sessionId);
       if (sessionId) {
         const list = this.skillsUsedPerSession.get(sessionId) ?? [];
-        if (!list.includes(toolName)) {
+        if (!list.includes(toolName))
           list.push(toolName);
-        }
         this.skillsUsedPerSession.set(sessionId, list);
       }
     } catch {
     }
   }
-  /**
-   * Report when the LLM picks a different tool than Chitragupta recommended.
-   */
+  /** Report when the LLM picks a different tool than Chitragupta recommended. */
   onSkillRejected(rejectedTool, chosenTool) {
     try {
       this.orchestrator.onSkillRejected(rejectedTool, chosenTool);
@@ -61858,113 +63157,138 @@ var ChitraguptaBridge = class _ChitraguptaBridge {
     }
   }
   /* ── Session lifecycle ─────────────────────────────────────────── */
-  /**
-   * Flush skill tracking data for a completed session.
-   */
+  /** Flush skill tracking data for a completed session. */
   onSessionEnd(sessionId) {
     try {
       const skillsUsed = this.skillsUsedPerSession.get(sessionId) ?? [];
       this.orchestrator.onSessionEnd(sessionId, skillsUsed);
       this.skillsUsedPerSession.delete(sessionId);
+      void this.skillLearner.flush(this.skillLearnerStatePath).catch((error) => {
+        this.logger.warn("skill_learner_flush_failed", { error: error instanceof Error ? error.message : String(error) });
+      });
     } catch {
     }
   }
-  /* ── Crystallization Pipeline (Gap 3) ─────────────────────────── */
+  /* ── Crystallization Pipeline ─────────────────────────────────── */
   /** Run crystallization on mature Vidhis. Fire-and-forget safe. */
   tryCrystallize(vidhis) {
     try {
-      if (!this.crystallizer || vidhis.length === 0)
+      if (vidhis.length === 0)
         return 0;
+      if (!this.crystallizer) {
+        if (!this.loggedCrystallizerUnavailable) {
+          this.loggedCrystallizerUnavailable = true;
+          this.logger.warn("chitragupta_crystallizer_unavailable");
+        }
+        return 0;
+      }
       const results = this.crystallizer.crystallize([...vidhis]);
       const ok = results.filter((s) => s.status === "registered" || s.status === "approved");
-      if (ok.length > 0) {
+      if (ok.length > 0)
         this.logger.info("chitragupta_crystallized_skills", { count: ok.length, names: ok.map((s) => s.skillName) });
-      }
       return ok.length;
     } catch {
       return 0;
     }
   }
-  /* ── Proactive Scan / Vasana (Gap 4) ──────────────────────────── */
+  /* ── Proactive Scan / Vasana ──────────────────────────────────── */
   /** Scan Vasana tendencies for proactive skill learning. Fire-and-forget safe. */
   proactiveScan(vasanas) {
     try {
-      if (!this.shiksha || vasanas.length === 0)
+      if (vasanas.length === 0)
         return [];
+      if (!this.shiksha) {
+        if (!this.loggedShikshaUnavailable) {
+          this.loggedShikshaUnavailable = true;
+          this.logger.warn("chitragupta_shiksha_unavailable", { autoLearn: false });
+        }
+        return [];
+      }
       const suggestions = this.shiksha.proactiveScan(vasanas);
-      if (suggestions.length > 0) {
+      if (suggestions.length > 0)
         this.logger.info("chitragupta_proactive_suggestions", { count: suggestions.length, topics: suggestions.slice(0, 5) });
-      }
       return suggestions;
     } catch {
       return [];
     }
   }
-  /* ── Turiya Bandit Routing ─────────────────────────────────────── */
+  /* ── Turiya Bandit Routing (delegated) ────────────────────────── */
   /** Query Chitragupta's Turiya contextual bandit. Returns null when unavailable. */
   async classifyTuriya(params) {
-    const text = params.text?.trim();
-    if (!text)
+    return classifyTuriya(this.getMargaBaseUrlCandidates(), this.margaTimeoutMs, params);
+  }
+  /** Send reward feedback to Chitragupta's Turiya router. Fire-and-forget. */
+  async recordTuriyaOutcome(params) {
+    return recordTuriyaOutcome(this.getMargaBaseUrlCandidates(), this.margaTimeoutMs, params);
+  }
+  /* ── Skill Resolution Pipeline ────────────────────────────────── */
+  /** Search for a skill matching the given intent. Returns first safe candidate or null. */
+  async resolveSkill(intent) {
+    try {
+      const candidates = await this.skillResolver.search(intent);
+      for (const candidate of candidates) {
+        const guardResult = this.skillResolver.guard(candidate);
+        if (guardResult.safe)
+          return candidate;
+        this.logger.debug("skill_candidate_blocked", { name: candidate.name, reasons: guardResult.blockedReasons });
+      }
       return null;
-    const baseUrls = this.getMargaBaseUrlCandidates();
-    for (const baseUrl of baseUrls) {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), this.margaTimeoutMs);
-      try {
-        const response = await fetch(`${baseUrl}/api/turiya/classify`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            text,
-            messageCount: params.messageCount,
-            hasTools: params.hasTools,
-            memoryHits: params.memoryHits
-          }),
-          signal: controller.signal
+    } catch {
+      return null;
+    }
+  }
+  /** Record a skill gap and auto-trigger search if threshold exceeded. */
+  recordSkillGap(intent, sessionId) {
+    try {
+      this.skillLearner.recordGap(intent, sessionId);
+      const actionable = this.skillLearner.getActionableGaps();
+      if (actionable.length > 0) {
+        this.logger.info("skill_gaps_actionable", { count: actionable.length, intents: actionable.map((g) => g.intent) });
+        void this.autoResolveGaps(actionable).catch(() => {
         });
-        if (!response.ok)
-          continue;
-        const payload = await response.json();
-        if (typeof payload.tier !== "string")
-          continue;
-        return {
-          tier: payload.tier,
-          confidence: typeof payload.confidence === "number" ? payload.confidence : 0.5,
-          costEstimate: typeof payload.costEstimate === "number" ? payload.costEstimate : 0
-        };
-      } catch {
-      } finally {
-        clearTimeout(timeout);
       }
+    } catch {
     }
-    return null;
   }
-  /** Send reward feedback to Chitragupta's Turiya router. Fire-and-forget. */
-  async recordTuriyaOutcome(params) {
-    const baseUrls = this.getMargaBaseUrlCandidates();
-    for (const baseUrl of baseUrls) {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), this.margaTimeoutMs);
-      try {
-        await fetch(`${baseUrl}/api/turiya/outcome`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify(params),
-          signal: controller.signal
-        });
-        return;
-      } catch {
-      } finally {
-        clearTimeout(timeout);
+  /**
+   * Auto-resolve skill gaps by searching for and installing matching candidates.
+   * Processes at most 3 gaps per invocation to avoid runaway resolution loops.
+   */
+  async autoResolveGaps(gaps) {
+    for (const gap of gaps.slice(0, 3)) {
+      const candidate = await this.resolveSkill(gap.intent);
+      if (candidate) {
+        const installed = await this.skillResolver.install(candidate);
+        if (installed) {
+          this.logger.info("skill_auto_installed", { name: installed.name, source: installed.source });
+        }
       }
     }
   }
+  /** Record skill execution result for learning. */
+  recordSkillFeedback(skillName, intent, sessionId, success, feedback) {
+    try {
+      if (success) {
+        this.skillLearner.recordSuccess(skillName, intent, sessionId, feedback);
+        if (this.skillLearner.evaluatePromotion(skillName))
+          this.logger.info("skill_promotion_ready", { skillName });
+      } else {
+        this.skillLearner.recordFailure(skillName, intent, sessionId, feedback ?? "unknown");
+        if (this.skillLearner.evaluateDemotion(skillName))
+          this.logger.warn("skill_demotion_triggered", { skillName });
+      }
+    } catch {
+    }
+  }
   /* ── Cleanup ───────────────────────────────────────────────────── */
   /** Persist state and release resources. */
   dispose() {
     try {
       this.orchestrator.persist().catch(() => {
       });
+      void this.skillLearner.flush(this.skillLearnerStatePath).catch((error) => {
+        this.logger.warn("skill_learner_flush_failed", { error: error instanceof Error ? error.message : String(error) });
+      });
       this.skillsUsedPerSession.clear();
       this.recCache = null;
       this.logger.info("chitragupta_bridge_disposed");
@@ -62508,22 +63832,22 @@ function json(res, status, body) {
   res.end(JSON.stringify(body));
 }
 function readBody(req) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
     req.on("end", () => {
       const raw = Buffer.concat(chunks).toString("utf8");
       if (!raw) {
-        resolve(void 0);
+        resolve3(void 0);
         return;
       }
       try {
-        resolve(JSON.parse(raw));
+        resolve3(JSON.parse(raw));
       } catch {
-        resolve(void 0);
+        resolve3(void 0);
       }
     });
-    req.on("error", () => resolve(void 0));
+    req.on("error", () => resolve3(void 0));
   });
 }
 
@@ -65070,7 +66394,7 @@ ${issues}`
     if (records.length === 0) {
       return "No subagents have run yet.";
     }
-    const { buildAgentTree: buildAgentTree2 } = await import("./chunks/tree-RSHKDTCR.js");
+    const { buildAgentTree: buildAgentTree2 } = await import("./chunks/tree-FIUVGJ5J.js");
     const roots = buildAgentTree2(records);
     const lines = [];
     const render = (nodes, depth) => {
@@ -65185,7 +66509,7 @@ import path46 from "node:path";
 import fs45 from "node:fs";
 import { Readable } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { randomUUID as randomUUID42 } from "node:crypto";
 function sanitizeArtifactFileName(value) {
   const base = path46.basename(value || "file");
@@ -65244,15 +66568,15 @@ async function stageTelegramAttachment(params) {
   return { localPath, downloadUrl: url };
 }
 async function extractPdfText(pdfPath) {
-  return await new Promise((resolve) => {
-    const child = spawn6("pdftotext", ["-layout", pdfPath, "-"], {
+  return await new Promise((resolve3) => {
+    const child = spawn7("pdftotext", ["-layout", pdfPath, "-"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve({ ok: false, error: "pdftotext_timeout" });
+      resolve3({ ok: false, error: "pdftotext_timeout" });
     }, 6e4);
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -65263,18 +66587,18 @@ async function extractPdfText(pdfPath) {
     child.on("error", (err) => {
       clearTimeout(timeout);
       const code = err?.code;
-      resolve({ ok: false, error: code === "ENOENT" ? "pdftotext_missing" : err.message });
+      resolve3({ ok: false, error: code === "ENOENT" ? "pdftotext_missing" : err.message });
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
       if (code !== 0) {
-        resolve({
+        resolve3({
           ok: false,
           error: stderr.trim() || `pdftotext_exit_${code}`
         });
         return;
       }
-      resolve({ ok: true, text: stdout });
+      resolve3({ ok: true, text: stdout });
     });
   });
 }
@@ -66375,6 +67699,210 @@ function setupIMessage(deps) {
   return adapter;
 }
 
+// apps/gateway/dist/channel/tring-setup.js
+function setupTring(deps) {
+  const { runtime, tringConfig, isChannelAllowed } = deps;
+  const { config, logger, storage, broadcastEvent, sessionIdentityMap } = runtime;
+  const resolveSession = (message) => resolveSessionWithPolicy(storage, {
+    channel: message.channel,
+    chatId: message.chatId,
+    userId: message.userId,
+    chatType: message.chatType,
+    threadId: message.threadId,
+    workspaceId: message.workspaceId
+  }, config.session, sessionIdentityMap);
+  const handler = async (message) => {
+    try {
+      const allowed = await isChannelAllowed(message.channel, message.chatId, message.userId);
+      if (!allowed) {
+        logger.debug("tring_message_rejected", {
+          channel: message.channel,
+          chatId: message.chatId,
+          userId: message.userId,
+          reason: "not_allowed"
+        });
+        return;
+      }
+      broadcastEvent("channel.message", {
+        channel: message.channel,
+        direction: "inbound",
+        chatId: message.chatId,
+        userId: message.userId,
+        text: message.text,
+        time: message.time
+      });
+      const session = await resolveSession(message);
+      const result = await runtime.runAgent({
+        providerId: tringConfig.providerId,
+        model: tringConfig.model,
+        system: tringConfig.system,
+        message: {
+          channel: message.channel,
+          chatId: message.chatId,
+          userId: message.userId,
+          chatType: message.chatType ?? "dm",
+          text: message.text,
+          time: message.time,
+          raw: message.raw
+        }
+      });
+      const reply = result.response.content;
+      if (!reply)
+        return;
+      const platform = message.channel;
+      await adapter.sendMessage(platform, message.chatId, reply);
+      broadcastEvent("channel.message", {
+        channel: message.channel,
+        direction: "outbound",
+        chatId: message.chatId,
+        userId: message.userId,
+        text: reply,
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: session.id
+      });
+    } catch (error) {
+      logger.error("tring_message_handler_error", {
+        error: error instanceof Error ? error.message : String(error),
+        channel: message.channel,
+        chatId: message.chatId
+      });
+    }
+  };
+  const adapter = new TringAdapter({
+    daemonUrl: tringConfig.daemonUrl ?? "http://localhost:8787",
+    tringBin: tringConfig.tringBin,
+    platforms: (tringConfig.platforms ?? ["whatsapp", "telegram", "signal"]).map((platform) => normalizeTringPlatform3(platform)).filter((platform) => Boolean(platform)),
+    pollIntervalMs: tringConfig.pollIntervalMs ?? 2e3,
+    autoStartDaemon: tringConfig.autoStartDaemon ?? true,
+    allowedChats: tringConfig.allowedChats
+  }, handler);
+  return adapter;
+}
+function normalizeTringPlatform3(platform) {
+  const normalized = platform.trim().toLowerCase();
+  if (normalized === "whispr")
+    return "signal";
+  if (normalized === "whatsapp" || normalized === "telegram" || normalized === "signal")
+    return normalized;
+  return void 0;
+}
+
+// apps/gateway/dist/channel/channel-autostart.js
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync, mkdirSync } from "node:fs";
+import { join as join3, dirname as dirname3 } from "node:path";
+var STATE_FILE_NAME = "channel-pairings.json";
+var STATE_VERSION = 1;
+var ChannelAutoStart = class {
+  stateFile;
+  logger;
+  states;
+  constructor(options) {
+    this.stateFile = join3(options.storageRoot, STATE_FILE_NAME);
+    this.logger = options.logger;
+    this.states = /* @__PURE__ */ new Map();
+  }
+  /** Load persisted pairing states from disk. */
+  load() {
+    if (!existsSync4(this.stateFile)) {
+      this.logger.info("channel_autostart_no_state_file", {
+        path: this.stateFile
+      });
+      return;
+    }
+    try {
+      const raw = readFileSync3(this.stateFile, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!isPersistedState(parsed)) {
+        this.logger.warn("channel_autostart_invalid_state", {
+          path: this.stateFile
+        });
+        return;
+      }
+      for (const entry of parsed.channels) {
+        this.states.set(entry.channel, entry);
+      }
+      this.logger.info("channel_autostart_loaded", {
+        count: this.states.size,
+        channels: [...this.states.keys()]
+      });
+    } catch (err) {
+      this.logger.warn("channel_autostart_load_error", {
+        error: err instanceof Error ? err.message : String(err),
+        path: this.stateFile
+      });
+    }
+  }
+  /** Save current pairing states to disk. */
+  save() {
+    const data2 = {
+      version: STATE_VERSION,
+      channels: [...this.states.values()]
+    };
+    try {
+      const dir = dirname3(this.stateFile);
+      if (!existsSync4(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(this.stateFile, JSON.stringify(data2, null, 2), "utf-8");
+      this.logger.info("channel_autostart_saved", {
+        count: this.states.size,
+        path: this.stateFile
+      });
+    } catch (err) {
+      this.logger.warn("channel_autostart_save_error", {
+        error: err instanceof Error ? err.message : String(err),
+        path: this.stateFile
+      });
+    }
+  }
+  /** Mark a channel as paired (or unpaired). */
+  setPaired(channel, paired, data2) {
+    const existing = this.states.get(channel);
+    const state = {
+      channel,
+      paired,
+      pairingData: data2 ?? existing?.pairingData,
+      lastActive: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.states.set(channel, state);
+    this.logger.info("channel_autostart_set_paired", {
+      channel,
+      paired,
+      hasData: data2 !== void 0
+    });
+  }
+  /** Check if a channel was previously paired. */
+  isPaired(channel) {
+    return this.states.get(channel)?.paired === true;
+  }
+  /** Get all channels currently marked as paired. */
+  getPairedChannels() {
+    return [...this.states.values()].filter((s) => s.paired);
+  }
+  /** Update the lastActive timestamp for a channel. */
+  touch(channel) {
+    const existing = this.states.get(channel);
+    if (existing) {
+      existing.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+      this.states.set(channel, existing);
+    }
+  }
+  /** Get pairing data for a channel (e.g., tokens, config). */
+  getPairingData(channel) {
+    return this.states.get(channel)?.pairingData;
+  }
+};
+function isPersistedState(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  if (typeof obj["version"] !== "number")
+    return false;
+  if (!Array.isArray(obj["channels"]))
+    return false;
+  return obj["channels"].every((c) => typeof c === "object" && c !== null && typeof c["channel"] === "string" && typeof c["paired"] === "boolean");
+}
+
 // apps/gateway/dist/gateway/restart-notice.js
 import fs46 from "node:fs";
 import path47 from "node:path";
@@ -66436,7 +67964,7 @@ async function maybeBootstrapSmritiDev(params) {
 
 // apps/gateway/dist/gateway/start-runtime-surface.js
 async function startRuntimeSurface(params) {
-  const { state, repoRoot, methods, logger, runtime, idempotency, storage, providers, config, channelPairingStore, channelPairingTtlSeconds, cleanupPairings: cleanupPairings2, isChannelAllowed, sendChannelMessage, broadcastEvent, gwEnv, artifactsRoot, isValidPairingCode: isValidPairingCode2, handleMemoryCommand, handleForgetCommand, createToolApprovalRequest, guardToolExecution: guardToolExecution2, inferProviderFromModel: inferProviderFromModel2, providerModelAliasMap, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, listProviderModels, formatSafeErrorMessage: formatSafeErrorMessage2, updateWeatherDefaults, telegramAdapterRef, twitterAdapterRef, whatsappAdapterRef, imessageAdapterRef, proactiveManager, storageRoot, smritiClient, profile, smritiSource, smritiAutoMemoryEnabled, smritiAutoMemoryReady, smritiEnabled, smritiApiKey, smritiAutoMemoryRoot, inboxWorker, runtimeServices, flushSmritiMemoryOutbox, clearSessionResetListener, chitraguptaBridge, mcpManager } = params;
+  const { state, repoRoot, methods, logger, runtime, idempotency, storage, providers, config, channelPairingStore, channelPairingTtlSeconds, cleanupPairings: cleanupPairings2, isChannelAllowed, sendChannelMessage, broadcastEvent, gwEnv, artifactsRoot, isValidPairingCode: isValidPairingCode2, handleMemoryCommand, handleForgetCommand, createToolApprovalRequest, guardToolExecution: guardToolExecution2, inferProviderFromModel: inferProviderFromModel2, providerModelAliasMap, resolveModelAlias: resolveModelAlias2, normalizeModelId: normalizeModelId2, listProviderModels, formatSafeErrorMessage: formatSafeErrorMessage2, updateWeatherDefaults, telegramAdapterRef, twitterAdapterRef, whatsappAdapterRef, imessageAdapterRef, tringAdapterRef, proactiveManager, storageRoot, smritiClient, profile, smritiSource, smritiAutoMemoryEnabled, smritiAutoMemoryReady, smritiEnabled, smritiApiKey, smritiAutoMemoryRoot, inboxWorker, runtimeServices, flushSmritiMemoryOutbox, clearSessionResetListener, chitraguptaBridge, mcpManager } = params;
   const server = createHttpServer(state, repoRoot, methods, logger, {
     storage,
     storageConfig: config.storage,
@@ -66458,6 +67986,17 @@ async function startRuntimeSurface(params) {
   server.listen(config.gateway.port, config.gateway.host, () => {
     logger.info("gateway_listening", { host: config.gateway.host, port: config.gateway.port });
   });
+  const autoStart = new ChannelAutoStart({ storageRoot, logger });
+  autoStart.load();
+  for (const state2 of autoStart.getPairedChannels()) {
+    const channelKey = state2.channel;
+    if (!config.channels[channelKey]?.enabled) {
+      logger.info("channel_auto_available", {
+        channel: state2.channel,
+        lastActive: state2.lastActive
+      });
+    }
+  }
   if (config.channels.telegram.enabled) {
     const geoConfig = {
       geoBaseUrl: gwEnv.weather.geoBaseUrl ?? "https://geocoding-api.open-meteo.com/v1",
@@ -66492,6 +68031,8 @@ async function startRuntimeSurface(params) {
     });
     telegramAdapterRef.set(adapter);
     adapter.start();
+    autoStart.setPaired("telegram", true);
+    autoStart.save();
     logger.info("telegram_adapter_started", { pollIntervalMs: config.channels.telegram.pollIntervalMs });
   }
   if (config.channels.twitter.enabled) {
@@ -66503,6 +68044,8 @@ async function startRuntimeSurface(params) {
     });
     twitterAdapterRef.set(twitterAdapter);
     twitterAdapter.start();
+    autoStart.setPaired("twitter", true);
+    autoStart.save();
     logger.info("twitter_adapter_started", {
       pollIntervalMs: config.channels.twitter.pollIntervalMs,
       monitorMentions: config.channels.twitter.monitorMentions
@@ -66517,6 +68060,8 @@ async function startRuntimeSurface(params) {
     });
     whatsappAdapterRef.set(waAdapter);
     waAdapter.start();
+    autoStart.setPaired("whatsapp", true);
+    autoStart.save();
     logger.info("whatsapp_adapter_started", { webhookPort: config.channels.whatsapp.webhookPort });
   }
   if (config.channels.imessage.enabled) {
@@ -66528,11 +68073,32 @@ async function startRuntimeSurface(params) {
     });
     imessageAdapterRef.set(imAdapter);
     imAdapter.start();
+    autoStart.setPaired("imessage", true);
+    autoStart.save();
     logger.info("imessage_adapter_started", { pollIntervalMs: config.channels.imessage.pollIntervalMs });
   }
+  if (config.channels.tring.enabled) {
+    const tAdapter = setupTring({
+      runtime,
+      tringConfig: config.channels.tring,
+      isChannelAllowed,
+      formatSafeErrorMessage: formatSafeErrorMessage2
+    });
+    tringAdapterRef.set(tAdapter);
+    tAdapter.start();
+    autoStart.setPaired("tring", true);
+    autoStart.save();
+    logger.info("tring_adapter_started", {
+      platforms: config.channels.tring.platforms,
+      pollIntervalMs: config.channels.tring.pollIntervalMs
+    });
+  }
   proactiveManager.registerChannel("hub", createHubDelivery(broadcastEvent));
-  if (config.channels.telegram.enabled && telegramAdapterRef.get()) {
-    const allowedChats = config.channels.telegram.allowedChats ?? [];
+  const tringPlatforms = (config.channels.tring.platforms ?? []).map((platform) => normalizeTringPlatform4(platform));
+  const telegramViaTring = config.channels.tring.enabled && tringAdapterRef.get() && tringPlatforms.includes("telegram");
+  const whatsappViaTring = config.channels.tring.enabled && tringAdapterRef.get() && tringPlatforms.includes("whatsapp");
+  if (config.channels.telegram.enabled && telegramAdapterRef.get() || telegramViaTring) {
+    const allowedChats = config.channels.telegram.enabled ? config.channels.telegram.allowedChats ?? [] : config.channels.tring.allowedChats ?? [];
     proactiveManager.registerChannel("telegram", createTelegramDelivery((chatId, text) => sendChannelMessage("telegram", chatId, text), () => allowedChats));
     logger.info("proactive_telegram_registered", { chatCount: allowedChats.length });
   }
@@ -66541,8 +68107,8 @@ async function startRuntimeSurface(params) {
     proactiveManager.registerChannel("twitter", createTwitterDelivery((userId, text) => sendChannelMessage("twitter", userId, text), () => allowedUsers));
     logger.info("proactive_twitter_registered", { userCount: allowedUsers.length });
   }
-  if (config.channels.whatsapp.enabled && whatsappAdapterRef.get()) {
-    const allowedNumbers = config.channels.whatsapp.allowedNumbers ?? [];
+  if (config.channels.whatsapp.enabled && whatsappAdapterRef.get() || whatsappViaTring) {
+    const allowedNumbers = config.channels.whatsapp.enabled ? config.channels.whatsapp.allowedNumbers ?? [] : config.channels.tring.allowedChats ?? [];
     proactiveManager.registerChannel("whatsapp", createWhatsAppDelivery((to, text) => sendChannelMessage("whatsapp", to, text), () => allowedNumbers));
     logger.info("proactive_whatsapp_registered", { numberCount: allowedNumbers.length });
   }
@@ -66595,6 +68161,9 @@ async function startRuntimeSurface(params) {
     const imAdapter = imessageAdapterRef.get();
     if (imAdapter)
       imAdapter.stop?.();
+    const trAdapter = tringAdapterRef.get();
+    if (trAdapter)
+      trAdapter.stop?.();
     mcpManager.stopAll?.();
     wss.close();
     server.close(() => {
@@ -66606,6 +68175,12 @@ async function startRuntimeSurface(params) {
   process.on("SIGTERM", shutdown);
   logger.info("gateway_started", { uptimeMs: Date.now() - state.startedAt });
 }
+function normalizeTringPlatform4(platform) {
+  const normalized = platform.trim().toLowerCase();
+  if (normalized === "whispr")
+    return "signal";
+  return normalized;
+}
 
 // apps/gateway/dist/rpc/methods/cores.js
 function createCoreMethods(ctx) {
@@ -69920,11 +71495,11 @@ function createOnboardingMethods(_ctx) {
         const fs48 = await import("node:fs");
         const os12 = await import("node:os");
         const path52 = await import("node:path");
-        const { execSync } = await import("node:child_process");
+        const { execSync: execSync2 } = await import("node:child_process");
         let codexInstalled = false;
         let codexLoggedIn = false;
         try {
-          execSync("which codex", { encoding: "utf-8", stdio: "pipe" });
+          execSync2("which codex", { encoding: "utf-8", stdio: "pipe" });
           codexInstalled = true;
           const codexAuthPath = path52.default.join(process.env.CODEX_HOME ?? path52.default.join(os12.default.homedir(), ".codex"), "auth.json");
           if (fs48.default.existsSync(codexAuthPath)) {
@@ -69935,7 +71510,7 @@ function createOnboardingMethods(_ctx) {
         let claudeInstalled = false;
         let claudeLoggedIn = false;
         try {
-          execSync("which claude", { encoding: "utf-8", stdio: "pipe" });
+          execSync2("which claude", { encoding: "utf-8", stdio: "pipe" });
           claudeInstalled = true;
           const claudeCredPath = path52.default.join(os12.default.homedir(), ".claude", ".credentials.json");
           if (fs48.default.existsSync(claudeCredPath)) {
@@ -70355,7 +71930,7 @@ function buildGatewayMethods(input) {
 // apps/gateway/dist/gateway/start.js
 async function startGateway() {
   const core = await setupGatewayCore();
-  let { configPath, config, repoRoot, storageRoot, artifactsRoot, soulPrompt, logger, state, idempotency, providers, providerModelAliasMap, lastAnthropicCallAt, sessionIdentityMap, listProviderModels, storage, profile, getProfile, updateProfile, memoryAllowed, memoryManager, gwEnv, smritiConfig, smritiEnabled, smritiBaseUrl, smritiApiKey, smritiPrefix, smritiOwner, smritiVectorProvider, smritiVectorFallbacks, smritiEmbeddingProviders, smritiRetrieveEnabled, smritiRetrieveLimit, smritiSource, smritiAutoMemoryEnabled, smritiAutoMemoryRoot, smritiAutoMemoryReady, smritiClient, smritiHelpers, toolRegistry, toolPolicy, loadToolPolicyFromFile, mcpManager, guardian, connections, connectionAuth, pendingChallenges, pairingStore, channelPairingStore, deviceActivity, smritiAutoMemorySessions, channelPairingTtlSeconds, telegramAdapterRef, twitterAdapterRef, whatsappAdapterRef, imessageAdapterRef, skillManifestsRef, broadcastEvent, getProvider, sendChannelMessage, isChannelAllowed, runTool, createToolApprovalRequest, executeApprovedTool, handleMemoryCommand, handleForgetCommand, updateWeatherDefaults, pairingStepSeconds, cleanupPairings: cleanupPairings2, isValidPairingCode: isValidPairingCode2 } = core;
+  let { configPath, config, repoRoot, storageRoot, artifactsRoot, soulPrompt, logger, state, idempotency, providers, providerModelAliasMap, lastAnthropicCallAt, sessionIdentityMap, listProviderModels, storage, profile, getProfile, updateProfile, memoryAllowed, memoryManager, gwEnv, smritiConfig, smritiEnabled, smritiBaseUrl, smritiApiKey, smritiPrefix, smritiOwner, smritiVectorProvider, smritiVectorFallbacks, smritiEmbeddingProviders, smritiRetrieveEnabled, smritiRetrieveLimit, smritiSource, smritiAutoMemoryEnabled, smritiAutoMemoryRoot, smritiAutoMemoryReady, smritiClient, smritiHelpers, toolRegistry, toolPolicy, loadToolPolicyFromFile, mcpManager, guardian, connections, connectionAuth, pendingChallenges, pairingStore, channelPairingStore, deviceActivity, smritiAutoMemorySessions, channelPairingTtlSeconds, telegramAdapterRef, twitterAdapterRef, whatsappAdapterRef, imessageAdapterRef, tringAdapterRef, skillManifestsRef, broadcastEvent, getProvider, sendChannelMessage, isChannelAllowed, runTool, createToolApprovalRequest, executeApprovedTool, handleMemoryCommand, handleForgetCommand, updateWeatherDefaults, pairingStepSeconds, cleanupPairings: cleanupPairings2, isValidPairingCode: isValidPairingCode2 } = core;
   const instanceLock = acquireGatewayInstanceLock({
     rootDir: storageRoot,
     host: config.gateway.host,
@@ -70384,6 +71959,20 @@ async function startGateway() {
     logger,
     enableAutoLearn: config.learnings?.autoLearn ?? false
   });
+  if (chitraguptaBridge) {
+    const currentTools = toolRegistry.list();
+    const registered = chitraguptaBridge.registerTools(currentTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      tags: tool.tags,
+      aliases: tool.aliases
+    })));
+    logger.info("chitragupta_tools_registered", {
+      totalTools: currentTools.length,
+      registeredTools: registered
+    });
+  }
   setSessionResetListener((session) => {
     chitraguptaBridge?.onSessionEnd(session.id);
   });
@@ -70647,6 +72236,7 @@ async function startGateway() {
     twitterAdapterRef,
     whatsappAdapterRef,
     imessageAdapterRef,
+    tringAdapterRef,
     proactiveManager,
     storageRoot,
     smritiClient,