@suveren/gateway 0.15.0 → 0.16.1

package/dist/mcp-server/http.mjs

@@ -2270,14 +2270,26 @@ function formatConsumptionFull(entries) {
 }
 
 // src/lib/context-loader.ts
-import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync11, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, renameSync as renameSync3 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join11 } from "path";
+import { join as join11, dirname as dirname9 } from "path";
 var DEFAULT_DIR7 = process.env.SUVEREN_DATA_DIR ?? join11(homedir7(), ".suveren");
+var CONTEXT_MAX_BYTES = 16 * 1024;
+function contextFilePath(dataDir2) {
+  return join11(dataDir2 ?? DEFAULT_DIR7, "context.md");
+}
+function writeContextFile(content, dataDir2) {
+  const bytes = Buffer.byteLength(content, "utf-8");
+  if (bytes > CONTEXT_MAX_BYTES) throw new Error(`the brief is ${bytes} bytes; the limit is ${CONTEXT_MAX_BYTES}.`);
+  const filePath = contextFilePath(dataDir2);
+  mkdirSync9(dirname9(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  writeFileSync9(tmpPath, content, "utf-8");
+  renameSync3(tmpPath, filePath);
+}
 var BRIEF_MAX_CHARS = 16 * 1024;
 function readContextFile(dataDir2) {
-  const dir = dataDir2 ?? DEFAULT_DIR7;
-  const filePath = join11(dir, "context.md");
+  const filePath = contextFilePath(dataDir2);
   if (!existsSync11(filePath)) return null;
   try {
     const content = readFileSync12(filePath, "utf-8").trim();
@@ -2843,68 +2855,6 @@ import { getProfile as getProfile2, ContentBindingError, boundActionTypes as bou
 import { readFile } from "fs/promises";
 import { extname } from "path";
 import { randomUUID } from "crypto";
-
-// src/lib/manifest-loader.ts
-import { readFileSync as readFileSync13, existsSync as existsSync12 } from "fs";
-import { join as join12, resolve } from "path";
-var EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function isExactSemver(value) {
-  return typeof value === "string" && EXACT_SEMVER_RE.test(value);
-}
-function invalidNpmPinReason(manifest) {
-  if (!manifest.npmPackage) return null;
-  if (manifest.npmVersion === void 0) {
-    return `npmPackage "${manifest.npmPackage}" is set but npmVersion is missing \u2014 every connector manifest must pin an exact tested version`;
-  }
-  if (!isExactSemver(manifest.npmVersion)) {
-    return `npmVersion ${JSON.stringify(manifest.npmVersion)} for "${manifest.npmPackage}" is not an exact semver (e.g. "1.2.3") \u2014 ranges, dist-tags like "latest", git specs, URLs, and file paths are not allowed`;
-  }
-  return null;
-}
-var manifests = /* @__PURE__ */ new Map();
-function loadManifests(integrationsDir) {
-  const dir = resolve(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join12(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
-  );
-  const indexPath = join12(dir, "index.json");
-  if (!existsSync12(indexPath)) {
-    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
-    return 0;
-  }
-  let index;
-  try {
-    index = JSON.parse(readFileSync13(indexPath, "utf-8"));
-  } catch (err) {
-    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
-    return 0;
-  }
-  let loaded = 0;
-  for (const [id, relativePath] of Object.entries(index.integrations)) {
-    const manifestPath = join12(dir, relativePath);
-    try {
-      const manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
-      const pinReason = invalidNpmPinReason(manifest);
-      if (pinReason) {
-        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${pinReason}`);
-        continue;
-      }
-      manifests.set(id, manifest);
-      loaded++;
-    } catch (err) {
-      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
-    }
-  }
-  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
-  return loaded;
-}
-function getManifest(id) {
-  return manifests.get(id);
-}
-function getAllManifests() {
-  return Array.from(manifests.values());
-}
-
-// src/lib/tool-proxy.ts
 var IMAGE_MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -3021,7 +2971,7 @@ function denyRead(state2, tool, reason, detail, target) {
   return { content: [{ type: "text", text: `Read blocked by Gatekeeper: ${detail}` }], isError: true };
 }
 function createGatedToolHandler(tool, integrationManager2, state2) {
-  if (isSimulationMode() && !manifestIsSimulated(getManifest(tool.integrationId))) {
+  if (isSimulationMode() && !integrationManager2.isSimulationSafe(tool.integrationId)) {
     return async () => ({
       content: [{
         type: "text",
@@ -3031,7 +2981,13 @@ function createGatedToolHandler(tool, integrationManager2, state2) {
     });
   }
   const gated = createGatedToolHandlerInner(tool, integrationManager2, state2);
-  const inner = async (args) => gated(normalizeIncomingArgs(tool, args));
+  const gateable = !!tool.gating?.profile && tool.gating.category !== "disabled";
+  const inner = async (args) => {
+    const normalized = normalizeIncomingArgs(tool, args);
+    const refusal = gateable ? integrationManager2.precheckBuiltin?.(tool, normalized) : null;
+    if (refusal) return { content: [{ type: "text", text: refusal }], isError: true };
+    return gated(normalized);
+  };
   const blocked = tool.gating?.blockedArgs ?? [];
   if (blocked.length === 0) return inner;
   return async (args) => {
@@ -4555,16 +4511,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync13 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync12 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname9, join as join13 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join13(homedir8(), ".suveren");
+import { dirname as dirname10, join as join12 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join12(homedir8(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir2) {
     const dir = dataDir2 ?? DEFAULT_DATA_DIR;
-    this.filePath = join13(dir, "integrations.json");
+    this.filePath = join12(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -4595,12 +4551,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync13(this.filePath)) {
-      mkdirSync9(dirname9(this.filePath), { recursive: true });
+    if (!existsSync12(this.filePath)) {
+      mkdirSync10(dirname10(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync14(this.filePath, "utf-8");
+      const raw = readFileSync13(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -4629,20 +4585,80 @@ var IntegrationRegistry = class {
       version: 1,
       integrations: Array.from(this.integrations.values())
     };
-    mkdirSync9(dirname9(this.filePath), { recursive: true });
-    writeFileSync9(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+    mkdirSync10(dirname10(this.filePath), { recursive: true });
+    writeFileSync10(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
   }
 };
 
 // src/lib/integration-manager.ts
 import { homedir as homedir9 } from "os";
 import { join as join14, delimiter } from "path";
-import { existsSync as existsSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync15, rmSync } from "fs";
+import { existsSync as existsSync14, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync15, rmSync } from "fs";
 import { execFile } from "child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { getProfile as getProfile5 } from "@hap/core";
 
+// src/lib/manifest-loader.ts
+import { readFileSync as readFileSync14, existsSync as existsSync13 } from "fs";
+import { join as join13, resolve } from "path";
+var EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function isExactSemver(value) {
+  return typeof value === "string" && EXACT_SEMVER_RE.test(value);
+}
+function invalidNpmPinReason(manifest) {
+  if (!manifest.npmPackage) return null;
+  if (manifest.npmVersion === void 0) {
+    return `npmPackage "${manifest.npmPackage}" is set but npmVersion is missing \u2014 every connector manifest must pin an exact tested version`;
+  }
+  if (!isExactSemver(manifest.npmVersion)) {
+    return `npmVersion ${JSON.stringify(manifest.npmVersion)} for "${manifest.npmPackage}" is not an exact semver (e.g. "1.2.3") \u2014 ranges, dist-tags like "latest", git specs, URLs, and file paths are not allowed`;
+  }
+  return null;
+}
+var manifests = /* @__PURE__ */ new Map();
+function loadManifests(integrationsDir) {
+  const dir = resolve(
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join13(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+  );
+  const indexPath = join13(dir, "index.json");
+  if (!existsSync13(indexPath)) {
+    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync14(indexPath, "utf-8"));
+  } catch (err) {
+    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
+    return 0;
+  }
+  let loaded = 0;
+  for (const [id, relativePath] of Object.entries(index.integrations)) {
+    const manifestPath = join13(dir, relativePath);
+    try {
+      const manifest = JSON.parse(readFileSync14(manifestPath, "utf-8"));
+      const pinReason = invalidNpmPinReason(manifest);
+      if (pinReason) {
+        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${pinReason}`);
+        continue;
+      }
+      manifests.set(id, manifest);
+      loaded++;
+    } catch (err) {
+      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
+    }
+  }
+  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
+  return loaded;
+}
+function getManifest(id) {
+  return manifests.get(id);
+}
+function getAllManifests() {
+  return Array.from(manifests.values());
+}
+
 // src/lib/remote-auth-preflight.ts
 var AUTH_HEADER_RE = /^authorization:\s*(.+)$/i;
 function remotePreflightTarget(command, args) {
@@ -4730,11 +4746,11 @@ function buildPath() {
 }
 function ensureIntegrationsDir() {
   if (!existsSync14(INTEGRATIONS_DIR)) {
-    mkdirSync10(INTEGRATIONS_DIR, { recursive: true });
+    mkdirSync11(INTEGRATIONS_DIR, { recursive: true });
   }
   const pkgPath = join14(INTEGRATIONS_DIR, "package.json");
   if (!existsSync14(pkgPath)) {
-    writeFileSync10(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
+    writeFileSync11(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
   }
 }
 function readAgeOf(config) {
@@ -4762,6 +4778,8 @@ var IntegrationManager = class {
     this.serviceCredentials = serviceCredentials2;
   }
   running = /* @__PURE__ */ new Map();
+  /** In-process tool groups (see builtin-integration.ts) — kept apart from `running` on purpose. */
+  builtins = /* @__PURE__ */ new Map();
   onToolsChanged = null;
   /**
    * Called when a persisted config was migrated to the manifest's command/args
@@ -5190,9 +5208,92 @@ var IntegrationManager = class {
     this.onToolsChanged?.();
   }
   /**
-   * Proxy a tool call to a downstream MCP server.
+   * Register an in-process tool group (see builtin-integration.ts). Its tools are
+   * listed, gated and executed through the same path as a connector's; only the
+   * final call runs `handler` instead of a child MCP client. Refused when the id
+   * is unusable or already taken, so a built-in can never shadow a connector.
+   */
+  registerBuiltin(def) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(def.id) || def.id.includes("__")) {
+      throw new Error(`Built-in integration id "${def.id}" must be lowercase letters, digits and '-'.`);
+    }
+    if (this.builtins.has(def.id) || this.running.has(def.id) || getManifest(def.id)) {
+      throw new Error(`Built-in integration id "${def.id}" is already in use.`);
+    }
+    const names = /* @__PURE__ */ new Set();
+    const tools = def.tools.map((tool) => {
+      if (names.has(tool.name)) throw new Error(`Built-in "${def.id}": tool "${tool.name}" is declared twice.`);
+      names.add(tool.name);
+      const gating = this.resolveToolGating(def.profile, def.toolGating, tool.name);
+      return {
+        originalName: tool.name,
+        namespacedName: `${def.id}__${tool.name}`,
+        integrationId: def.id,
+        description: tool.description,
+        inputSchema: withoutBlockedArgs(tool.inputSchema, gating?.blockedArgs),
+        gating
+      };
+    });
+    this.builtins.set(def.id, { def, tools });
+    console.error(`[IntegrationManager] Built-in ${def.id}: ${tools.length} tool(s) under profile ${def.profile}`);
+    this.onToolsChanged?.();
+  }
+  /** The built-in groups, for the mandate picker — never part of the connector status list. */
+  getBuiltins() {
+    return Array.from(this.builtins.values()).map(({ def }) => ({
+      id: def.id,
+      name: def.name,
+      description: def.description ?? "",
+      profile: def.profile,
+      available: !def.simulationOnly || isSimulationMode()
+    }));
+  }
+  /** Whether `id` names a built-in (in-process) integration. */
+  isBuiltin(id) {
+    return this.builtins.has(id);
+  }
+  /**
+   * Whether `id` may run while simulation mode is on: a connector whose manifest
+   * carries the `simulation` marker, or a built-in that declares `simulation: true`.
+   */
+  isSimulationSafe(id) {
+    const builtin = this.builtins.get(id);
+    if (builtin) return builtin.def.simulation === true;
+    return manifestIsSimulated(getManifest(id));
+  }
+  /**
+   * The built-in's own refusal for this call, checked before the gate (no proposal,
+   * no ticket): `simulationOnly` outside simulation mode, then the tool's `validate`.
+   * Null for connector tools and for calls that may proceed.
+   */
+  precheckBuiltin(tool, args) {
+    const builtin = this.builtins.get(tool.integrationId);
+    if (!builtin) return null;
+    if (builtin.def.simulationOnly && !isSimulationMode()) {
+      return `Refused: "${tool.namespacedName}" is not available. No ticket was requested.`;
+    }
+    const def = builtin.def.tools.find((t) => t.name === tool.originalName);
+    const refusal = def?.validate?.(args);
+    return refusal ? `Refused: ${refusal} No ticket was requested.` : null;
+  }
+  /**
+   * Proxy a tool call to a downstream MCP server (or a built-in's handler).
    */
   async callTool(integrationId, toolName, args) {
+    const builtin = this.builtins.get(integrationId);
+    if (builtin) {
+      const tool = builtin.def.tools.find((t) => t.name === toolName);
+      if (!tool) {
+        return { content: [{ type: "text", text: `Tool "${integrationId}__${toolName}" does not exist.` }], isError: true };
+      }
+      try {
+        const result = await tool.handler(args);
+        return { content: result.content.map((c) => ({ type: c.type, text: c.text })), isError: result.isError };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Tool call failed: ${message}` }], isError: true };
+      }
+    }
     const entry = this.running.get(integrationId);
     if (!entry) {
       return {
@@ -5223,6 +5324,9 @@ var IntegrationManager = class {
     for (const entry of this.running.values()) {
       tools.push(...entry.tools);
     }
+    for (const entry of this.builtins.values()) {
+      tools.push(...entry.tools);
+    }
     return tools;
   }
   /**
@@ -5497,12 +5601,88 @@ function warnNoProfiles(reason) {
   );
 }
 
+// src/lib/builtin-integration.ts
+function builtinText(text) {
+  return { content: [{ type: "text", text }] };
+}
+
+// src/lib/builtins/setup.ts
+var DELEGATION_PROFILE = "github.com/humanagencyprotocol/hap-profiles/delegation@0.1";
+function briefRefusal(args) {
+  if (typeof args.content !== "string" || args.content.trim() === "") return "`content` must be the complete new brief (markdown text).";
+  const bytes = Buffer.byteLength(args.content, "utf-8");
+  if (bytes > CONTEXT_MAX_BYTES) return `the brief is ${bytes} bytes; the limit is ${CONTEXT_MAX_BYTES}. Shorten it.`;
+  return void 0;
+}
+function setupBuiltin(_deps) {
+  return {
+    id: "setup",
+    name: "Test setup",
+    description: "Your AI proposes its own setup for a test \u2014 for now its agent brief. Every proposal waits for your approval. Simulation mode only.",
+    profile: DELEGATION_PROFILE,
+    simulation: true,
+    simulationOnly: true,
+    toolGating: {
+      overrides: {
+        set_agent_brief: {
+          executionMapping: {},
+          staticExecution: { action_type: "brief" },
+          hideUnlessAuthorized: true
+        }
+      }
+    },
+    tools: [
+      {
+        name: "set_agent_brief",
+        description: "Simulation mode only: propose a new agent brief \u2014 the standing instructions every agent session starts with. `content` replaces the whole brief (markdown, at most 16 KB). A person approves or rejects the proposal; only after approval is the brief replaced, and it applies from the next session. Write the complete brief, not a change to the current one.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: "The complete new agent brief, in markdown (at most 16 KB)." },
+            receipt_id: {
+              type: "string",
+              description: "Authorization reference for this call, set by the governing gateway \u2014 agents do not set this."
+            }
+          },
+          required: ["content"]
+        },
+        validate: briefRefusal,
+        handler: async (args) => {
+          if (!isSimulationMode()) return { ...builtinText("Refused: not available outside simulation mode."), isError: true };
+          const refusal = briefRefusal(args);
+          if (refusal) return { ...builtinText(`Refused: ${refusal}`), isError: true };
+          writeContextFile(args.content);
+          return builtinText(
+            `Agent brief replaced (${Buffer.byteLength(args.content, "utf-8")} bytes). It applies from the next agent session.`
+          );
+        }
+      }
+    ]
+  };
+}
+
+// src/lib/builtins/index.ts
+var BUILTIN_FACTORIES = [setupBuiltin];
+function registerBuiltins(deps, factories = BUILTIN_FACTORIES) {
+  const registered = [];
+  for (const factory of factories) {
+    try {
+      const def = factory(deps);
+      deps.integrationManager.registerBuiltin(def);
+      registered.push(def.id);
+    } catch (err) {
+      console.error(`[Suveren MCP] Built-in tool group not registered: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return registered;
+}
+
 // bin/http.ts
 import { decodeAttestationBlob as decodeAttestationBlob3 } from "@hap/core";
 
 // src/lib/committed-executor.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readFileSync as readFileSync17, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname10, join as join16 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync12, readFileSync as readFileSync17, unlinkSync as unlinkSync6, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname11, join as join16 } from "path";
 var CommittedExecutor = class {
   constructor(run) {
     this.run = run;
@@ -5538,9 +5718,9 @@ var ExecutorLock = class {
     if (current && current.pid !== process.pid && isAlive(current.pid)) {
       return { held: false, holderPid: current.pid };
     }
-    mkdirSync11(dirname10(this.path), { recursive: true, mode: 448 });
+    mkdirSync12(dirname11(this.path), { recursive: true, mode: 448 });
     const lock = { pid: process.pid, startedAt: Math.floor(Date.now() / 1e3) };
-    writeFileSync11(this.path, JSON.stringify(lock), { mode: 384 });
+    writeFileSync12(this.path, JSON.stringify(lock), { mode: 384 });
     this.held = true;
     return { held: true };
   }
@@ -5585,8 +5765,8 @@ import { homedir as homedir10 } from "os";
 import { join as join18 } from "path";
 
 // src/lib/mcp-as-tracker.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname11, join as join17 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname12, join as join17 } from "path";
 function trackerPath(dataDir2) {
   return join17(dataDir2, "mcp-as-pairing.json");
 }
@@ -5602,8 +5782,8 @@ function readMcpPairedAsUrl(dataDir2) {
 }
 function writeMcpPairedAsUrl(dataDir2, asUrl) {
   const path = trackerPath(dataDir2);
-  mkdirSync12(dirname11(path), { recursive: true, mode: 448 });
-  writeFileSync12(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
+  mkdirSync13(dirname12(path), { recursive: true, mode: 448 });
+  writeFileSync13(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
 }
 
 // bin/http.ts
@@ -5965,7 +6145,10 @@ app.get("/health", (_req, res) => {
     activeSessions: activeSessions.size,
     storedGates: state.gateStore.getAll().length,
     serviceCredentials: Array.from(serviceCredentials.keys()),
-    integrations: integrationManager.getStatus(integrationRegistry.getAll())
+    integrations: integrationManager.getStatus(integrationRegistry.getAll()),
+    // The gateway's own tool groups (built-ins) — not connectors; the mandate
+    // picker offers them so a person can give a mandate for them.
+    builtins: integrationManager.getBuiltins()
   });
 });
 app.get("/internal/gate-content", internalOnly, (req, res) => {
@@ -6092,6 +6275,7 @@ app.listen(port, "0.0.0.0", () => {
   console.error(`[Suveren MCP]   SP server:  ${spUrl}`);
   profilesLoaded = loadProfiles();
   loadManifests();
+  registerBuiltins({ state, integrationManager });
   if (process.env.SUVEREN_DISABLE_AUTO_INTEGRATIONS !== "1" && integrationRegistry.getEnabled().length === 0) {
     const personalManifests = getAllManifests().filter((m) => m.personalDefault);
     for (const manifest of personalManifests) {