@suveren/gateway 0.2.0

package/dist/mcp-server/http.mjs

@@ -0,0 +1,2724 @@
+#!/usr/bin/env node
+
+// bin/http.ts
+import { randomUUID } from "crypto";
+import express from "express";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/lib/sp-client.ts
+var SPReceiptError = class extends Error {
+  constructor(message, statusCode, body) {
+    super(message);
+    this.statusCode = statusCode;
+    this.body = body;
+    this.name = "SPReceiptError";
+  }
+};
+var SPClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  sessionCookie = "";
+  apiKey = "";
+  setApiKey(key) {
+    this.apiKey = key;
+  }
+  setSessionCookie(cookie) {
+    this.sessionCookie = cookie;
+  }
+  async fetch(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...init?.headers
+    };
+    if (this.sessionCookie) {
+      headers["Cookie"] = this.sessionCookie;
+    }
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    return globalThis.fetch(url, {
+      ...init,
+      headers
+    });
+  }
+  /**
+   * Get SP public key.
+   */
+  async getPublicKey() {
+    const res = await this.fetch("/api/as/pubkey");
+    if (!res.ok) throw new Error(`SP pubkey request failed: ${res.status}`);
+    const data = await res.json();
+    return data.publicKey;
+  }
+  /**
+   * Get all attestations for a frame hash.
+   */
+  async getAttestations(frameHash) {
+    const res = await this.fetch(`/api/attestations?frame_hash=${encodeURIComponent(frameHash)}`);
+    if (!res.ok) throw new Error(`SP attestations request failed: ${res.status}`);
+    return res.json();
+  }
+  /**
+   * Get pending attestations for a domain.
+   */
+  async getPendingAttestations(domain) {
+    const res = await this.fetch(`/api/attestations/pending?domain=${encodeURIComponent(domain)}`);
+    if (!res.ok) throw new Error(`SP pending request failed: ${res.status}`);
+    return res.json();
+  }
+  /**
+   * Request a signed receipt from the SP.
+   *
+   * v0.4:
+   * - For automatic-mode attestations, this is the pre-flight check before
+   *   tool execution — the SP enforces bounds/limits and returns a signed
+   *   receipt on success.
+   * - For review-mode attestations, the gateway first submits a proposal,
+   *   waits for domain owners to commit, then calls postReceipt with the
+   *   `proposalId` (and the original `toolArgs`). The SP verifies the
+   *   proposal match, atomically transitions it to `executed`, and signs a
+   *   receipt bound to the proposal.
+   *
+   * Response envelope (v0.4):
+   *   { approved: true, receipt: {...} }                     — on success
+   *   { approved: false, errors: [{code, message, ...}] }    — on rejection
+   *
+   * Errors throw SPReceiptError with the structured `errors` array in `body`.
+   */
+  async postReceipt(data) {
+    const res = await this.fetch("/api/as/receipt", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok || body.approved === false) {
+      const errors = body.errors;
+      const first = errors?.[0];
+      const message = first?.message ?? first?.code ?? body.error ?? `SP receipt request failed: ${res.status}`;
+      throw new SPReceiptError(message, res.status, body);
+    }
+    return { receipt: body.receipt };
+  }
+  /**
+   * Submit a proposal for deferred commitment review.
+   * Phase 6: accepts optional pendingApprovers and createdBy for above-cap routing.
+   */
+  async submitProposal(data) {
+    const res = await this.fetch("/api/proposals", {
+      method: "POST",
+      body: JSON.stringify({
+        frame_hash: data.frameHash,
+        profile_id: data.profileId,
+        path: data.path,
+        pending_domains: data.pendingDomains,
+        tool: data.tool,
+        tool_args: data.toolArgs,
+        execution_context: data.executionContext,
+        // Phase 6
+        ...data.pendingApprovers && data.pendingApprovers.length > 0 ? { pending_approvers: data.pendingApprovers } : {},
+        ...data.createdBy ? { created_by: data.createdBy } : {}
+      })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error ?? `SP proposal submission failed: ${res.status}`);
+    }
+    return res.json();
+  }
+  /**
+   * Phase 6: Fetch frame metadata for an authority by its boundsHash / frameHash.
+   * Used to read aboveCap and approversFrozen at action time.
+   */
+  async getFrameMetadata(frameHash) {
+    const res = await this.fetch(`/api/as/frame/${encodeURIComponent(frameHash)}`);
+    if (res.status === 404) return null;
+    if (!res.ok) return null;
+    return res.json();
+  }
+  /**
+   * Get proposals that have been fully committed and are ready for execution.
+   */
+  async getCommittedProposals() {
+    const res = await this.fetch("/api/proposals?status=committed");
+    if (!res.ok) throw new Error(`SP committed proposals request failed: ${res.status}`);
+    const data = await res.json();
+    return data.proposals;
+  }
+  // NOTE: v0.3 used POST /api/proposals/{id}/resolve with action: 'executed'
+  // to mark a proposal as executed after the gateway ran the tool. In v0.4
+  // the committed→executed transition is atomic with receipt issuance, so
+  // this helper was removed. Use postReceipt({ proposalId }) instead.
+};
+
+// src/lib/attestation-cache.ts
+var AttestationCache = class {
+  constructor(spClient) {
+    this.spClient = spClient;
+  }
+  spPublicKey = null;
+  spPublicKeyFetchedAt = 0;
+  SP_PUBKEY_TTL = 300;
+  // 5 minutes
+  /** Cache of authorizations by path (e.g., "payment-routine") */
+  authorizations = /* @__PURE__ */ new Map();
+  lastSync = 0;
+  /**
+   * Get the SP public key, fetching from SP if not cached or expired.
+   */
+  async getPublicKey() {
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.spPublicKey && now - this.spPublicKeyFetchedAt < this.SP_PUBKEY_TTL) {
+      return this.spPublicKey;
+    }
+    this.spPublicKey = await this.spClient.getPublicKey();
+    this.spPublicKeyFetchedAt = now;
+    return this.spPublicKey;
+  }
+  /**
+   * Get a cached authorization by path. If not cached, returns null.
+   * Use syncAuthorization() to fetch from SP.
+   */
+  getAuthorization(path) {
+    const auth = this.authorizations.get(path);
+    if (!auth) return null;
+    const now = Math.floor(Date.now() / 1e3);
+    const hasValid = auth.attestations.some((a) => a.expiresAt > now);
+    if (!hasValid) {
+      this.authorizations.delete(path);
+      return null;
+    }
+    return auth;
+  }
+  /**
+   * Fetch attestation data from SP for a frame hash and cache it.
+   */
+  async syncAuthorization(frameHash) {
+    const result = await this.spClient.getAttestations(frameHash);
+    if (!result.profile_id || !result.frame) return null;
+    const storageHash = result.frame_hash ?? result.bounds_hash;
+    const bounds = result.bounds ?? result.frame;
+    const auth = {
+      frameHash: storageHash,
+      boundsHash: result.bounds_hash,
+      // content fingerprint (undefined for pre-v0.4 records)
+      contextHash: result.context_hash,
+      profileId: result.profile_id,
+      path: result.path ?? result.profile_id,
+      frame: bounds,
+      // compat alias
+      bounds: result.bounds,
+      // v0.4 (undefined for v0.3)
+      attestations: result.attestations.map((a) => ({
+        domain: a.domain,
+        blob: a.blob,
+        expiresAt: a.expires_at
+      })),
+      requiredDomains: result.required_domains ?? [],
+      attestedDomains: result.attested_domains ?? [],
+      deferredCommitmentDomains: result.deferred_commitment_domains ?? [],
+      complete: result.complete
+    };
+    this.authorizations.set(auth.path, auth);
+    return auth;
+  }
+  /**
+   * Get all cached authorizations (both active and pending).
+   */
+  getAllAuthorizations() {
+    const now = Math.floor(Date.now() / 1e3);
+    const results = [];
+    for (const [path, auth] of this.authorizations) {
+      const hasValid = auth.attestations.some((a) => a.expiresAt > now);
+      if (hasValid) {
+        results.push(auth);
+      } else {
+        this.authorizations.delete(path);
+      }
+    }
+    return results;
+  }
+  /**
+   * Fetch pending attestations from SP for a domain.
+   */
+  async getPendingAttestations(domain) {
+    return this.spClient.getPendingAttestations(domain);
+  }
+  /**
+   * Cache an authorization directly (e.g., from SP response after creation).
+   */
+  cacheAuthorization(auth) {
+    this.authorizations.set(auth.path, auth);
+  }
+  /**
+   * Remove a cached authorization by path. Called when the SP reports the
+   * attestation has been revoked, so subsequent list calls reflect reality.
+   */
+  invalidate(path) {
+    this.authorizations.delete(path);
+  }
+};
+
+// src/lib/gate-store.ts
+import { mkdirSync, readFileSync, writeFileSync, existsSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+var DEFAULT_DIR = process.env.SUVEREN_DATA_DIR ?? join(homedir(), ".suveren");
+var GateStore = class {
+  entries = /* @__PURE__ */ new Map();
+  baseDir;
+  vaultKey = null;
+  constructor(filePath) {
+    if (filePath && filePath.endsWith(".json")) {
+      this.baseDir = dirname(filePath);
+    } else {
+      this.baseDir = filePath ?? DEFAULT_DIR;
+    }
+    this.loadPlaintext();
+  }
+  /**
+   * Set the vault key for encryption. Triggers migration from plaintext if needed.
+   */
+  setVaultKey(key) {
+    this.vaultKey = key;
+    if (existsSync(this.encryptedFilePath)) {
+      this.loadEncrypted();
+    } else if (this.entries.size > 0) {
+      this.persistEncrypted();
+      if (existsSync(this.plaintextFilePath)) {
+        try {
+          unlinkSync(this.plaintextFilePath);
+        } catch {
+        }
+      }
+    }
+  }
+  set(path, entry) {
+    this.entries.set(path, entry);
+    this.persist();
+  }
+  get(path) {
+    return this.entries.get(path) ?? null;
+  }
+  getAll() {
+    return Array.from(this.entries.values());
+  }
+  delete(path) {
+    this.entries.delete(path);
+    this.persist();
+  }
+  // ─── Encryption helpers ─────────────────────────────────────────────────
+  encrypt(plaintext) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", this.vaultKey, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      iv: iv.toString("hex"),
+      ciphertext: encrypted.toString("hex"),
+      tag: tag.toString("hex")
+    };
+  }
+  decrypt(blob) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const decipher = createDecipheriv(
+      "aes-256-gcm",
+      this.vaultKey,
+      Buffer.from(blob.iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+    const decrypted = Buffer.concat([
+      decipher.update(Buffer.from(blob.ciphertext, "hex")),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+  }
+  // ─── File paths ─────────────────────────────────────────────────────────
+  get plaintextFilePath() {
+    return join(this.baseDir, "gates.json");
+  }
+  get encryptedFilePath() {
+    return join(this.baseDir, "gates.enc.json");
+  }
+  // ─── Load / Persist ─────────────────────────────────────────────────────
+  loadPlaintext() {
+    if (!existsSync(this.plaintextFilePath)) {
+      mkdirSync(this.baseDir, { recursive: true });
+      return;
+    }
+    try {
+      const raw = readFileSync(this.plaintextFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      this.entries = new Map(Object.entries(data.entries));
+    } catch {
+      console.error(`[GateStore] Could not parse ${this.plaintextFilePath}, starting fresh`);
+      this.entries = /* @__PURE__ */ new Map();
+    }
+  }
+  loadEncrypted() {
+    if (!existsSync(this.encryptedFilePath)) return;
+    try {
+      const raw = readFileSync(this.encryptedFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      this.entries = /* @__PURE__ */ new Map();
+      for (const [key, blob] of Object.entries(data.entries)) {
+        const entry = JSON.parse(this.decrypt(blob));
+        this.entries.set(key, entry);
+      }
+    } catch (err) {
+      console.error(`[GateStore] Could not decrypt ${this.encryptedFilePath}:`, err);
+      this.entries = /* @__PURE__ */ new Map();
+    }
+  }
+  persist() {
+    if (this.vaultKey) {
+      this.persistEncrypted();
+    } else {
+      this.persistPlaintext();
+    }
+  }
+  persistPlaintext() {
+    const data = {
+      version: 1,
+      entries: Object.fromEntries(this.entries)
+    };
+    mkdirSync(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+  persistEncrypted() {
+    const data = {
+      version: 1,
+      entries: {}
+    };
+    for (const [key, entry] of this.entries) {
+      data.entries[key] = this.encrypt(JSON.stringify(entry));
+    }
+    mkdirSync(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+};
+
+// src/lib/execution-log.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2 } from "crypto";
+var DEFAULT_DIR2 = process.env.SUVEREN_DATA_DIR ?? join2(homedir2(), ".suveren");
+var MAX_AGE_SECONDS = 31 * 24 * 60 * 60;
+var ExecutionLog = class {
+  entries = [];
+  baseDir;
+  vaultKey = null;
+  constructor(filePath) {
+    if (filePath && filePath.endsWith(".json")) {
+      this.baseDir = dirname2(filePath);
+    } else {
+      this.baseDir = filePath ?? DEFAULT_DIR2;
+    }
+    this.loadPlaintext();
+  }
+  /**
+   * Set the vault key for encryption. Triggers migration from plaintext if needed.
+   */
+  setVaultKey(key) {
+    this.vaultKey = key;
+    if (existsSync2(this.encryptedFilePath)) {
+      this.loadEncrypted();
+    } else if (this.entries.length > 0) {
+      this.persistEncrypted();
+      if (existsSync2(this.plaintextFilePath)) {
+        try {
+          unlinkSync2(this.plaintextFilePath);
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Record an approved execution.
+   */
+  record(entry) {
+    this.entries.push(entry);
+    this.prune();
+    this.persist();
+  }
+  /**
+   * Sum a field's values within a time window for a given profile and path.
+   *
+   * @param profileId - The profile ID to filter by
+   * @param path - The execution path to filter by
+   * @param field - The execution field to sum ("_count" for plain counting)
+   * @param window - Time window (daily, weekly, monthly)
+   * @param now - Current timestamp in seconds (for testing)
+   */
+  sumByWindow(profileId, path, field, window, now = Math.floor(Date.now() / 1e3)) {
+    const cutoff = windowCutoff(window, now);
+    let total = 0;
+    for (const entry of this.entries) {
+      if (entry.profileId !== profileId) continue;
+      if (entry.path !== path) continue;
+      if (entry.timestamp < cutoff) continue;
+      if (field === "_count") {
+        total += 1;
+      } else {
+        const val = entry.execution[field];
+        if (typeof val === "number") {
+          total += val;
+        } else if (val !== void 0) {
+          total += Number(val) || 0;
+        }
+      }
+    }
+    return total;
+  }
+  /**
+   * Get all entries (for debugging/inspection).
+   */
+  getAll() {
+    return [...this.entries];
+  }
+  /**
+   * Get entry count.
+   */
+  get size() {
+    return this.entries.length;
+  }
+  // ─── Pruning ────────────────────────────────────────────────────────────
+  prune(now = Math.floor(Date.now() / 1e3)) {
+    const cutoff = now - MAX_AGE_SECONDS;
+    const before = this.entries.length;
+    this.entries = this.entries.filter((e) => e.timestamp >= cutoff);
+    if (this.entries.length < before) {
+      console.log(`[ExecutionLog] Pruned ${before - this.entries.length} expired entries`);
+    }
+  }
+  // ─── Encryption helpers ─────────────────────────────────────────────────
+  encrypt(plaintext) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const iv = randomBytes2(12);
+    const cipher = createCipheriv2("aes-256-gcm", this.vaultKey, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      iv: iv.toString("hex"),
+      ciphertext: encrypted.toString("hex"),
+      tag: tag.toString("hex")
+    };
+  }
+  decrypt(blob) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const decipher = createDecipheriv2(
+      "aes-256-gcm",
+      this.vaultKey,
+      Buffer.from(blob.iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+    const decrypted = Buffer.concat([
+      decipher.update(Buffer.from(blob.ciphertext, "hex")),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+  }
+  // ─── File paths ─────────────────────────────────────────────────────────
+  get plaintextFilePath() {
+    return join2(this.baseDir, "execution-log.json");
+  }
+  get encryptedFilePath() {
+    return join2(this.baseDir, "execution-log.enc.json");
+  }
+  // ─── Load / Persist ─────────────────────────────────────────────────────
+  loadPlaintext() {
+    if (!existsSync2(this.plaintextFilePath)) {
+      mkdirSync2(this.baseDir, { recursive: true });
+      return;
+    }
+    try {
+      const raw = readFileSync2(this.plaintextFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      this.entries = data.entries;
+      this.prune();
+    } catch {
+      console.error(`[ExecutionLog] Could not parse ${this.plaintextFilePath}, starting fresh`);
+      this.entries = [];
+    }
+  }
+  loadEncrypted() {
+    if (!existsSync2(this.encryptedFilePath)) return;
+    try {
+      const raw = readFileSync2(this.encryptedFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      const decrypted = this.decrypt(data.blob);
+      const logFile = JSON.parse(decrypted);
+      this.entries = logFile.entries;
+      this.prune();
+    } catch (err) {
+      console.error(`[ExecutionLog] Could not decrypt ${this.encryptedFilePath}:`, err);
+      this.entries = [];
+    }
+  }
+  persist() {
+    if (this.vaultKey) {
+      this.persistEncrypted();
+    } else {
+      this.persistPlaintext();
+    }
+  }
+  persistPlaintext() {
+    const data = { version: 1, entries: this.entries };
+    mkdirSync2(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync2(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+  persistEncrypted() {
+    const logFile = { version: 1, entries: this.entries };
+    const data = {
+      version: 1,
+      blob: this.encrypt(JSON.stringify(logFile))
+    };
+    mkdirSync2(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync2(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+};
+function windowCutoff(window, now) {
+  switch (window) {
+    case "daily":
+      return now - 24 * 60 * 60;
+    case "weekly":
+      return now - 7 * 24 * 60 * 60;
+    case "monthly":
+      return now - 30 * 24 * 60 * 60;
+  }
+}
+
+// src/lib/gatekeeper.ts
+import { verify } from "@hap/core";
+var MCPGatekeeper = class {
+  constructor(cache, executionLog) {
+    this.cache = cache;
+    this.executionLog = executionLog;
+  }
+  /**
+   * Verify an execution request against a cached authorization.
+   *
+   * @param authorizationPath - The execution path (e.g., "payment-routine")
+   * @param execution - The agent's execution values
+   * @param override - Optional v0.4 fields (bounds, context) from the enriched auth / gate store,
+   *                   used when the context is not present on the SP-cached auth itself.
+   * @returns Gatekeeper result + the authorization if found
+   */
+  async verifyExecution(authorizationPath, execution, override) {
+    const auth = this.cache.getAuthorization(authorizationPath);
+    if (!auth) {
+      return {
+        result: {
+          approved: false,
+          errors: [{
+            code: "DOMAIN_NOT_COVERED",
+            message: `No active authorization for "${authorizationPath}". A decision owner must grant authority via the Authority UI.`
+          }]
+        },
+        authorization: null
+      };
+    }
+    if (!auth.complete) {
+      const missing = auth.requiredDomains.filter((d) => !auth.attestedDomains.includes(d));
+      return {
+        result: {
+          approved: false,
+          errors: [{
+            code: "DOMAIN_NOT_COVERED",
+            message: `Authorization "${authorizationPath}" is pending. Missing domains: ${missing.join(", ")}`
+          }]
+        },
+        authorization: auth
+      };
+    }
+    const publicKeyHex = await this.cache.getPublicKey();
+    const resolvedBounds = override?.bounds ?? auth.bounds ?? auth.frame;
+    const resolvedContext = override?.context ?? auth.context;
+    const frame = { ...resolvedBounds, profile: auth.profileId };
+    const request = {
+      frame,
+      attestations: auth.attestations.map((a) => a.blob),
+      execution,
+      context: resolvedContext
+    };
+    const result = await verify(request, publicKeyHex, void 0, this.executionLog);
+    return { result, authorization: auth };
+  }
+};
+
+// src/lib/shared-state.ts
+var SharedState = class {
+  spClient;
+  cache;
+  gateStore;
+  executionLog;
+  gatekeeper;
+  constructor(spUrl2, gateStorePath) {
+    this.spClient = new SPClient(spUrl2);
+    this.cache = new AttestationCache(this.spClient);
+    this.gateStore = new GateStore(gateStorePath);
+    this.executionLog = new ExecutionLog(gateStorePath);
+    this.gatekeeper = new MCPGatekeeper(this.cache, this.executionLog);
+  }
+  setGateContent(path, frameHash, profileId, content, opts) {
+    this.gateStore.set(path, {
+      frameHash,
+      boundsHash: opts?.boundsHash,
+      contextHash: opts?.contextHash,
+      path,
+      profileId,
+      gateContent: content,
+      context: opts?.context,
+      storedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  getGateContent(path) {
+    return this.gateStore.get(path);
+  }
+  /**
+   * Join active+complete cached authorizations with gate content from the GateStore.
+   * v0.4: also merges context/contextHash from gate store if not present on cached auth.
+   */
+  getEnrichedAuthorizations() {
+    const authorizations = this.cache.getAllAuthorizations();
+    return authorizations.map((auth) => {
+      const gateEntry = this.gateStore.get(auth.path) ?? this.gateStore.get(auth.profileId) ?? (auth.boundsHash ? this.gateStore.get(auth.boundsHash) : null) ?? (auth.frameHash ? this.gateStore.get(auth.frameHash) : null) ?? this.gateStore.getAll().find((g) => g.profileId === auth.profileId) ?? null;
+      return {
+        ...auth,
+        gateContent: gateEntry?.gateContent ?? null,
+        context: auth.context ?? gateEntry?.context,
+        contextHash: auth.contextHash ?? gateEntry?.contextHash
+      };
+    }).filter((auth) => auth.gateContent !== null);
+  }
+};
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/lib/mandate-brief.ts
+import { getProfile } from "@hap/core";
+
+// src/lib/consumption.ts
+function getConsumptionState(auth, executionLog, profile) {
+  if (!profile?.boundsSchema?.fields) return [];
+  const entries = [];
+  const now = Math.floor(Date.now() / 1e3);
+  for (const [fieldName, rawFieldDef] of Object.entries(profile.boundsSchema.fields)) {
+    if (fieldName === "profile" || fieldName === "path") continue;
+    const fieldDef = rawFieldDef;
+    const bt = fieldDef.boundType;
+    if (!bt) continue;
+    if (bt.kind !== "cumulative_sum" && bt.kind !== "cumulative_count") continue;
+    const boundValue = auth.frame[fieldName];
+    const limit = typeof boundValue === "number" ? boundValue : null;
+    const cumulativeField = bt.kind === "cumulative_count" ? "_count" : bt.of;
+    const current = executionLog.sumByWindow(
+      auth.profileId,
+      auth.path,
+      cumulativeField,
+      bt.window,
+      now
+    );
+    entries.push({
+      label: fieldDef.description ?? fieldName,
+      current,
+      limit,
+      window: bt.window,
+      field: fieldName,
+      kind: bt.kind === "cumulative_sum" ? "sum" : "count",
+      of: bt.kind === "cumulative_sum" ? bt.of : void 0
+    });
+  }
+  return entries;
+}
+var CURRENCY_SUM_FIELDS = /* @__PURE__ */ new Set(["amount", "spend"]);
+function formatConsumptionCompact(entries) {
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const entry of entries) {
+    if (entry.limit === null) continue;
+    if (entry.kind === "sum") {
+      const prefix = entry.of && CURRENCY_SUM_FIELDS.has(entry.of) ? "$" : "";
+      parts.push(`${prefix}${entry.current}/${prefix}${entry.limit} ${entry.window}`);
+    } else {
+      parts.push(`${entry.current}/${entry.limit} ${entry.window}`);
+    }
+  }
+  return parts.join(", ");
+}
+function formatConsumptionFull(entries) {
+  if (entries.length === 0) return "";
+  const lines = [];
+  for (const entry of entries) {
+    const limitStr = entry.limit !== null ? String(entry.limit) : "unlimited";
+    const label = `${entry.label}:`;
+    lines.push(`    ${label.padEnd(30)} ${entry.current} / ${limitStr}`);
+  }
+  return lines.join("\n");
+}
+
+// src/lib/context-loader.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var DEFAULT_DIR3 = process.env.SUVEREN_DATA_DIR ?? join3(homedir3(), ".suveren");
+var BRIEF_MAX_CHARS = 1e3;
+function readContextFile(dataDir) {
+  const dir = dataDir ?? DEFAULT_DIR3;
+  const filePath = join3(dir, "context.md");
+  if (!existsSync3(filePath)) return null;
+  try {
+    const content = readFileSync3(filePath, "utf-8").trim();
+    return content || null;
+  } catch {
+    return null;
+  }
+}
+function getContextForBrief(dataDir) {
+  const full = readContextFile(dataDir);
+  if (!full) return { brief: null, truncated: false };
+  if (full.length <= BRIEF_MAX_CHARS) {
+    return { brief: full, truncated: false };
+  }
+  const truncated = full.slice(0, BRIEF_MAX_CHARS) + "\n... (truncated \u2014 call list-authorizations for full context)";
+  return { brief: truncated, truncated: true };
+}
+
+// src/lib/mandate-brief.ts
+function shortProfileName(profileId) {
+  const withoutVersion = profileId.replace(/@.*$/, "");
+  const parts = withoutVersion.split("/");
+  return parts[parts.length - 1];
+}
+function countToolsByGating(profileId, integrationManager2) {
+  if (!integrationManager2) return { gated: 0, readOnly: 0 };
+  const allTools = integrationManager2.getAllTools();
+  let gated = 0;
+  let readOnly = 0;
+  for (const tool of allTools) {
+    if (!tool.gating || !tool.gating.profile) {
+      readOnly++;
+    } else if (tool.gating.profile === profileId || tool.gating.profile === shortProfileName(profileId)) {
+      if (tool.gating.staticExecution?.action_type === "read" && Object.keys(tool.gating.executionMapping ?? {}).length === 0) {
+        readOnly++;
+      } else {
+        gated++;
+      }
+    }
+  }
+  return { gated, readOnly };
+}
+function buildMandateBrief(opts) {
+  const { authorizations, executionLog, integrationManager: integrationManager2, contextDir } = opts;
+  const lines = [
+    "You are an agent operating under the Human Agency Protocol (HAP).",
+    "You have bounded authorities granted by human decision owners.",
+    "You MUST stay within these bounds \u2014 the Gatekeeper will reject actions that exceed them."
+  ];
+  const { brief: contextBrief } = getContextForBrief(contextDir);
+  if (contextBrief) {
+    lines.push("");
+    lines.push("=== CONTEXT ===");
+    lines.push("");
+    lines.push(contextBrief);
+  }
+  const active = authorizations.filter((a) => a.complete);
+  const pending = authorizations.filter((a) => !a.complete);
+  const now = Math.floor(Date.now() / 1e3);
+  if (active.length > 0) {
+    lines.push("");
+    lines.push("=== ACTIVE AUTHORITIES ===");
+    lines.push("");
+    for (const auth of active) {
+      const earliestExpiry = Math.min(...auth.attestations.map((a) => a.expiresAt));
+      const remainingMin = Math.max(0, Math.round((earliestExpiry - now) / 60));
+      const shortName = shortProfileName(auth.profileId);
+      const version = auth.profileId.match(/@(.+)$/)?.[1] ?? "";
+      const shortId = version ? `${shortName}@${version}` : shortName;
+      const boundsDesc = Object.entries(auth.frame).filter(([key]) => key !== "profile" && key !== "path").map(([key, value]) => `${key}:${value}`).join(" \xB7 ");
+      const parts = [];
+      if (boundsDesc) parts.push(boundsDesc);
+      if (executionLog) {
+        const profile = getProfile(auth.profileId) ?? getProfile(shortName);
+        const consumption = getConsumptionState(auth, executionLog, profile);
+        const compact = formatConsumptionCompact(consumption);
+        if (compact) parts.push(compact);
+      }
+      const { gated, readOnly } = countToolsByGating(auth.profileId, integrationManager2);
+      if (gated > 0 || readOnly > 0) parts.push(`${gated} gated tools`);
+      parts.push(`${remainingMin} min remaining`);
+      lines.push(`[${shortId}] ${parts.join(" \xB7 ")}`);
+      lines.push(`  \u2192 list-authorizations(domain: "${shortName}") for intent & details`);
+      lines.push("");
+    }
+  }
+  if (pending.length > 0) {
+    lines.push("=== PENDING (awaiting attestations) ===");
+    lines.push("");
+    for (const auth of pending) {
+      const missing = auth.requiredDomains.filter((d) => !auth.attestedDomains.includes(d));
+      lines.push(`[${auth.path}] ${auth.profileId} \u2014 needs: ${missing.join(", ")}`);
+    }
+    lines.push("");
+  }
+  lines.push("When you receive a task, call list-authorizations(domain) to load full details for the relevant domain.");
+  return lines.join("\n");
+}
+
+// src/tools/authorizations.ts
+import { getProfile as getProfile2 } from "@hap/core";
+
+// src/lib/tool-proxy.ts
+import { readFile } from "fs/promises";
+import { extname } from "path";
+var IMAGE_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif"
+};
+var MAX_PREVIEW_BYTES = 1 * 1024 * 1024;
+async function attachImagePreview(args) {
+  const imagePath = typeof args.imagePath === "string" ? args.imagePath : null;
+  if (!imagePath) return args;
+  if (args._imagePreview) return args;
+  try {
+    const mime = IMAGE_MIME[extname(imagePath).toLowerCase()];
+    if (!mime) return args;
+    const buf = await readFile(imagePath);
+    if (buf.byteLength > MAX_PREVIEW_BYTES) return args;
+    return { ...args, _imagePreview: `data:${mime};base64,${buf.toString("base64")}` };
+  } catch {
+    return args;
+  }
+}
+function applyMapping(m, value, execution) {
+  if (m.divisor) {
+    const numValue = typeof value === "number" ? value : Number(value);
+    execution[m.field] = numValue / m.divisor;
+    return;
+  }
+  const coerce = (v) => {
+    if (typeof v === "object" && v !== null && "email" in v) {
+      return String(v.email);
+    }
+    return String(v);
+  };
+  const arr = Array.isArray(value) ? value.map(coerce) : [coerce(value)];
+  switch (m.transform) {
+    case "length":
+      execution[m.field] = arr.length;
+      break;
+    case "join":
+      execution[m.field] = arr.join(",");
+      break;
+    case "join_domains": {
+      const domains = [...new Set(arr.map((email) => {
+        const at = email.lastIndexOf("@");
+        return at >= 0 ? email.substring(at + 1).toLowerCase() : email.toLowerCase();
+      }))].sort();
+      execution[m.field] = domains.join(",");
+      break;
+    }
+    default:
+      execution[m.field] = typeof value === "number" ? value : String(value);
+  }
+}
+function profileMatches(profileId, shortName) {
+  return profileId === shortName || profileId.includes("/" + shortName + "@") || profileId.endsWith("/" + shortName);
+}
+function createGatedToolHandler(tool, integrationManager2, state2) {
+  if (!tool.gating || !tool.gating.profile) {
+    return async () => {
+      return {
+        content: [{
+          type: "text",
+          text: `Tool "${tool.namespacedName}" has no gating configuration. All tools require authorization.`
+        }],
+        isError: true
+      };
+    };
+  }
+  const { profile, executionMapping, staticExecution, category } = tool.gating;
+  if (category === "read") {
+    return async (args) => {
+      const auths = state2.getEnrichedAuthorizations();
+      const matchingAuths = auths.filter(
+        (a) => a.complete && profileMatches(a.profileId, profile)
+      );
+      if (matchingAuths.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No active authorization matching profile "${profile}". A decision owner must grant authority via the Authority UI before this tool can be used.`
+          }],
+          isError: true
+        };
+      }
+      return integrationManager2.callTool(tool.integrationId, tool.originalName, args);
+    };
+  }
+  return async (args) => {
+    const execution = { ...staticExecution };
+    for (const [argName, mapping] of Object.entries(executionMapping)) {
+      const value = args[argName];
+      if (value !== void 0 && value !== null) {
+        if (typeof mapping === "string") {
+          execution[mapping] = typeof value === "number" ? value : String(value);
+        } else if (Array.isArray(mapping)) {
+          for (const m of mapping) applyMapping(m, value, execution);
+        } else if ("divisor" in mapping) {
+          const numValue = typeof value === "number" ? value : Number(value);
+          execution[mapping.field] = numValue / mapping.divisor;
+        } else if ("transform" in mapping) {
+          applyMapping(mapping, value, execution);
+        }
+      }
+    }
+    const auths = state2.getEnrichedAuthorizations();
+    const matchingAuths = auths.filter(
+      (a) => a.complete && profileMatches(a.profileId, profile)
+    );
+    if (matchingAuths.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: `No active authorization matching profile "${profile}". A decision owner must grant authority via the Authority UI before this tool can be used.`
+        }],
+        isError: true
+      };
+    }
+    const errors = [];
+    for (const auth of matchingAuths) {
+      const { result } = await state2.gatekeeper.verifyExecution(auth.path, execution, {
+        bounds: auth.bounds,
+        context: auth.context
+      });
+      if (!result.approved) {
+      }
+      if (result.approved) {
+        const authHash = auth.frameHash ?? auth.boundsHash;
+        if ((auth.deferredCommitmentDomains ?? []).length > 0) {
+          try {
+            const enrichedArgs = await attachImagePreview(args);
+            const { proposal } = await state2.spClient.submitProposal({
+              frameHash: authHash,
+              profileId: auth.profileId,
+              path: auth.path,
+              pendingDomains: auth.deferredCommitmentDomains,
+              tool: tool.namespacedName,
+              toolArgs: enrichedArgs,
+              executionContext: { ...execution }
+            });
+            return {
+              content: [{
+                type: "text",
+                text: `Awaiting commitment from domain${auth.deferredCommitmentDomains.length > 1 ? "s" : ""} "${auth.deferredCommitmentDomains.join('", "')}" for tool ${tool.originalName}.
+Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposal_id: "${proposal.id}").`
+              }]
+            };
+          } catch (err) {
+            return {
+              content: [{ type: "text", text: `Failed to submit proposal: ${err instanceof Error ? err.message : String(err)}` }],
+              isError: true
+            };
+          }
+        }
+        try {
+          const actionType = typeof execution.action_type === "string" ? execution.action_type : void 0;
+          if (!actionType) {
+            console.error(
+              `[Suveren MCP] Warning: tool ${tool.namespacedName} has no action_type in staticExecution. Bounds check may be skipped. Fix the integration manifest.`
+            );
+          }
+          await state2.spClient.postReceipt({
+            attestationHash: authHash,
+            profileId: auth.profileId,
+            path: auth.path,
+            action: tool.namespacedName,
+            actionType,
+            executionContext: { ...execution },
+            amount: typeof execution.amount === "number" ? execution.amount : void 0
+          });
+        } catch (err) {
+          if (err instanceof SPReceiptError && err.statusCode === 409) {
+            const spBody = err.body;
+            let pendingApprovers = spBody.approvers ?? [];
+            if (pendingApprovers.length === 0) {
+              try {
+                const frameMeta = await state2.spClient.getFrameMetadata(authHash);
+                if (frameMeta?.approversFrozen) {
+                  pendingApprovers = frameMeta.approversFrozen;
+                }
+                if (frameMeta?.createdBy) {
+                  pendingApprovers = [frameMeta.createdBy, ...pendingApprovers];
+                }
+              } catch {
+              }
+            } else {
+              try {
+                const frameMeta = await state2.spClient.getFrameMetadata(authHash);
+                if (frameMeta?.createdBy) {
+                  pendingApprovers = [frameMeta.createdBy, ...pendingApprovers];
+                }
+              } catch {
+              }
+            }
+            const uniqueApprovers = [...new Set(pendingApprovers)];
+            try {
+              const enrichedArgs = await attachImagePreview(args);
+              const { proposal } = await state2.spClient.submitProposal({
+                frameHash: authHash,
+                profileId: auth.profileId,
+                path: auth.path,
+                pendingDomains: [],
+                tool: tool.namespacedName,
+                toolArgs: enrichedArgs,
+                executionContext: { ...execution },
+                pendingApprovers: uniqueApprovers
+              });
+              return {
+                content: [{
+                  type: "text",
+                  text: `Action exceeds team cap. Approval required from ${uniqueApprovers.length} reviewer(s).
+Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
+                }]
+              };
+            } catch (proposalErr) {
+              return {
+                content: [{ type: "text", text: `Failed to submit approval proposal: ${proposalErr instanceof Error ? proposalErr.message : String(proposalErr)}` }],
+                isError: true
+              };
+            }
+          }
+          if (err instanceof SPReceiptError && err.statusCode === 422) {
+            return {
+              content: [{ type: "text", text: `Action blocked: ${err.message} (hard team ceiling \u2014 contact the team admin)` }],
+              isError: true
+            };
+          }
+          if (err instanceof SPReceiptError && err.statusCode === 403) {
+            if (/revoked/i.test(err.message)) {
+              state2.cache.invalidate(auth.path);
+            }
+            return {
+              content: [{ type: "text", text: `Blocked by SP: ${err.message}` }],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: `SP unavailable \u2014 tool call blocked. ${err instanceof Error ? err.message : ""}` }],
+            isError: true
+          };
+        }
+        state2.executionLog.record({
+          profileId: auth.profileId,
+          path: auth.path,
+          execution: { ...execution },
+          timestamp: Math.floor(Date.now() / 1e3)
+        });
+        return integrationManager2.callTool(tool.integrationId, tool.originalName, args);
+      }
+      const reasons = result.errors.map((e) => {
+        if (e.code === "BOUND_EXCEEDED") {
+          return `${auth.path}: ${e.field}: ${e.message}`;
+        }
+        return `${auth.path}: ${e.message}`;
+      });
+      errors.push(...reasons);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `Tool call rejected by Gatekeeper. Tried ${matchingAuths.length} authorization(s):
+` + errors.map((e) => `  - ${e}`).join("\n")
+      }],
+      isError: true
+    };
+  };
+}
+function buildProxiedToolDescription(tool, state2) {
+  if (!tool.gating || !tool.gating.profile) {
+    return `[Suveren: no gating config] ${tool.description}`;
+  }
+  const profile = tool.gating.profile;
+  const auths = state2.getEnrichedAuthorizations();
+  const hasAuth = auths.some(
+    (a) => a.complete && profileMatches(a.profileId, profile)
+  );
+  if (!hasAuth) {
+    return `[Suveren: ${profile} \u2014 no active authorization] ${tool.description}`;
+  }
+  if (tool.gating.category === "read") {
+    return `[Suveren: ${profile} \u2014 read] ${tool.description}`;
+  }
+  const parts = [];
+  if (tool.gating.staticExecution?.action_type) {
+    parts.push(String(tool.gating.staticExecution.action_type));
+  }
+  const mappedFields = Object.values(tool.gating.executionMapping ?? {}).flatMap(
+    (m) => typeof m === "string" ? [m] : Array.isArray(m) ? m.map((e) => e.field) : [m.field]
+  );
+  if (mappedFields.length > 0) {
+    parts.push(`${mappedFields.join(", ")} checked`);
+  }
+  const tag = parts.length > 0 ? parts.join(", ") : "gated";
+  return `[Suveren: ${profile} \u2014 ${tag}] ${tool.description}`;
+}
+
+// src/tools/authorizations.ts
+function shortProfileName2(profileId) {
+  const withoutVersion = profileId.replace(/@.*$/, "");
+  const parts = withoutVersion.split("/");
+  return parts[parts.length - 1];
+}
+function buildCapabilityMap(profileId, toolGating, integrationManager2) {
+  if (!integrationManager2 || !toolGating) return "";
+  const allTools = integrationManager2.getAllTools();
+  const shortName = shortProfileName2(profileId);
+  const gated = [];
+  const readOnly = [];
+  const defaultGated = [];
+  for (const tool of allTools) {
+    if (!tool.gating || !tool.gating.profile) {
+      continue;
+    }
+    if (!profileMatches(tool.gating.profile, shortName) && tool.gating.profile !== profileId) {
+      continue;
+    }
+    const overrides = toolGating.overrides ?? {};
+    const override = overrides[tool.originalName];
+    if (override === null) {
+      readOnly.push(tool.originalName);
+    } else if (override !== void 0) {
+      const mappingDesc = Object.entries(override.executionMapping ?? {}).map(([arg, mapping]) => {
+        if (typeof mapping === "string") return `${mapping} from ${arg}`;
+        return `${mapping.field} from ${arg} (/${mapping.divisor})`;
+      }).join(", ");
+      const actionType = override.staticExecution?.action_type ?? "unknown";
+      gated.push(`      - ${tool.originalName}: ${actionType}${mappingDesc ? `, ${mappingDesc}` : ""}`);
+    } else {
+      const defaultAction = toolGating.default.staticExecution?.action_type;
+      if (defaultAction === "read" && Object.keys(toolGating.default.executionMapping ?? {}).length === 0) {
+        defaultGated.push(tool.originalName);
+      } else {
+        gated.push(`      - ${tool.originalName}: ${defaultAction ?? "default"} (default gating)`);
+      }
+    }
+  }
+  const lines = [];
+  lines.push("  Capability Map:");
+  if (gated.length > 0) {
+    lines.push("    Gated (checked per call):");
+    lines.push(...gated);
+  }
+  if (readOnly.length > 0) {
+    lines.push(`    Read-only (no authorization needed): ${readOnly.join(", ")}`);
+  }
+  if (defaultGated.length > 0) {
+    lines.push(`    Default-gated (action_type: ${toolGating.default.staticExecution?.action_type ?? "read"}): ${defaultGated.join(", ")}`);
+  }
+  if (gated.length === 0 && readOnly.length === 0 && defaultGated.length === 0) {
+    lines.push("    No tools discovered for this profile.");
+  }
+  return lines.join("\n");
+}
+function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
+  return async (args) => {
+    const authorizations = state2.getEnrichedAuthorizations();
+    const now = Math.floor(Date.now() / 1e3);
+    const domain = args?.domain;
+    if (authorizations.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: "No active authorizations. A decision owner must grant authority via the Authority UI."
+        }]
+      };
+    }
+    if (domain) {
+      const matching = authorizations.filter((auth) => {
+        const shortName = shortProfileName2(auth.profileId);
+        return shortName === domain || profileMatches(auth.profileId, domain);
+      });
+      if (matching.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No authorizations found for domain "${domain}". Active domains: ${[...new Set(authorizations.map((a) => shortProfileName2(a.profileId)))].join(", ")}`
+          }]
+        };
+      }
+      const output2 = [];
+      for (const auth of matching) {
+        const earliestExpiry = Math.min(...auth.attestations.map((a) => a.expiresAt));
+        const remainingMin = Math.max(0, Math.round((earliestExpiry - now) / 60));
+        const boundsDesc = Object.entries(auth.frame).filter(([key]) => key !== "profile" && key !== "path").map(([key, value]) => `${key}: ${value}`).join(", ");
+        const statusLabel = auth.complete ? "" : " (PENDING)";
+        output2.push(`[${auth.path}] ${auth.profileId} (${remainingMin} min remaining)${statusLabel}`);
+        output2.push("");
+        output2.push(`  Bounds: ${boundsDesc}`);
+        const shortName = shortProfileName2(auth.profileId);
+        const profile = getProfile2(auth.profileId) ?? getProfile2(shortName);
+        if (profile) {
+          const consumption = getConsumptionState(auth, state2.executionLog, profile);
+          const consumptionText = formatConsumptionFull(consumption);
+          if (consumptionText) {
+            output2.push("");
+            output2.push("  Usage:");
+            output2.push(consumptionText);
+          }
+        }
+        if (auth.context) {
+          const contextEntries = Object.entries(auth.context).filter(([, v]) => v !== "" && v !== void 0);
+          if (contextEntries.length > 0) {
+            output2.push("");
+            output2.push("  Scope:");
+            for (const [k, v] of contextEntries) {
+              output2.push(`    ${k}: ${v}`);
+            }
+          }
+        }
+        if (auth.gateContent?.intent) {
+          output2.push("");
+          output2.push(`  Intent: ${auth.gateContent.intent}`);
+        }
+        if (!auth.complete) {
+          const missing = auth.requiredDomains.filter((d) => !auth.attestedDomains.includes(d));
+          output2.push("");
+          output2.push(`  Missing attestations: ${missing.join(", ")}`);
+        }
+        if (profile && integrationManager2) {
+          output2.push("");
+          output2.push(buildCapabilityMap(auth.profileId, profile.toolGating, integrationManager2));
+        }
+        output2.push("");
+      }
+      return {
+        content: [{
+          type: "text",
+          text: output2.join("\n")
+        }]
+      };
+    }
+    const active = [];
+    const pending = [];
+    const context = readContextFile(contextDir);
+    for (const auth of authorizations) {
+      const earliestExpiry = Math.min(...auth.attestations.map((a) => a.expiresAt));
+      const remainingMin = Math.max(0, Math.round((earliestExpiry - now) / 60));
+      const boundsDesc = Object.entries(auth.frame).filter(([key]) => key !== "profile" && key !== "path").map(([key, value]) => `${key}: ${value}`).join(", ");
+      if (auth.complete) {
+        const lines = [`  [${auth.path}] ${auth.profileId} \u2014 ${remainingMin} min remaining`];
+        lines.push(`    Bounds: ${boundsDesc}`);
+        const shortName = shortProfileName2(auth.profileId);
+        const profile = getProfile2(auth.profileId) ?? getProfile2(shortName);
+        if (profile) {
+          const consumption = getConsumptionState(auth, state2.executionLog, profile);
+          const compact = formatConsumptionCompact(consumption);
+          if (compact) {
+            lines.push(`    Usage: ${compact}`);
+          }
+        }
+        lines.push(`    Call list-authorizations(domain: "${shortProfileName2(auth.profileId)}") for full details`);
+        active.push(lines.join("\n"));
+      } else {
+        const missing = auth.requiredDomains.filter((d) => !auth.attestedDomains.includes(d));
+        pending.push(
+          `  ${auth.path}: ${boundsDesc} \u2014 needs ${missing.join(", ")} attestation, ${remainingMin} min remaining`
+        );
+      }
+    }
+    const output = [];
+    if (context) {
+      output.push("=== CONTEXT ===");
+      output.push(context);
+      output.push("");
+    }
+    if (active.length > 0) {
+      output.push("Active authorizations:");
+      output.push(...active);
+    }
+    if (pending.length > 0) {
+      if (output.length > 0) output.push("");
+      output.push("Pending (missing owners):");
+      output.push(...pending);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: output.join("\n")
+      }]
+    };
+  };
+}
+
+// src/tools/pending.ts
+function checkPendingHandler(cache) {
+  return async (args) => {
+    const { domain } = args;
+    try {
+      const pending = await cache.getPendingAttestations(domain);
+      if (pending.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `No pending attestations for domain "${domain}".`
+          }]
+        };
+      }
+      const lines = [`Pending attestations needing your domain (${domain}):`];
+      for (const item of pending) {
+        const boundsDesc = Object.entries(item.frame).filter(([key]) => key !== "profile" && key !== "path").map(([key, value]) => `${key}: ${value}`).join(", ");
+        const attested = item.attested_domains.join(", ");
+        const missing = item.missing_domains.join(", ");
+        const remaining = item.remaining_seconds ? `${Math.round(item.remaining_seconds / 60)} min remaining` : "unknown";
+        lines.push(
+          `  ${item.profile_id} / ${item.path}: ${boundsDesc}
+    Attested: ${attested} | Missing: ${missing} | ${remaining}`
+        );
+      }
+      return {
+        content: [{
+          type: "text",
+          text: lines.join("\n")
+        }]
+      };
+    } catch (error) {
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to check pending attestations: ${error}`
+        }],
+        isError: true
+      };
+    }
+  };
+}
+
+// src/tools/integrations.ts
+function shortProfileName3(profileId) {
+  const withoutVersion = profileId.replace(/@.*$/, "");
+  const parts = withoutVersion.split("/");
+  return parts[parts.length - 1];
+}
+function listIntegrationsHandler(state2, integrationManager2) {
+  return async () => {
+    if (!integrationManager2) {
+      return { content: [{ type: "text", text: "No integration manager available." }] };
+    }
+    const auths = state2.getEnrichedAuthorizations();
+    const statuses = integrationManager2.getStatus();
+    const integrations = statuses.filter((s) => s.running).map((s) => {
+      const tools = integrationManager2.getAllTools().filter((t) => t.integrationId === s.id);
+      const profile = tools[0]?.gating?.profile ?? null;
+      const matchingAuths = profile ? auths.filter((a) => a.complete && profileMatches(a.profileId, profile)) : [];
+      let status;
+      if (matchingAuths.length > 0) {
+        const soonestExpiry = Math.min(
+          ...matchingAuths.flatMap(
+            (a) => a.attestations.map((att) => att.expires_at)
+          )
+        );
+        const remainingMs = soonestExpiry * 1e3 - Date.now();
+        const remainingMin = Math.ceil(remainingMs / 6e4);
+        status = `authorized (${matchingAuths.length} path${matchingAuths.length > 1 ? "s" : ""}, ${remainingMin} min remaining)`;
+      } else {
+        const allProfileAuths = profile ? auths.filter((a) => profileMatches(a.profileId, profile)) : [];
+        status = allProfileAuths.length > 0 ? "expired" : "no authorization";
+      }
+      return {
+        id: s.id,
+        profile: profile ? shortProfileName3(profile) : null,
+        status
+      };
+    });
+    const text = integrations.length === 0 ? "No integrations running." : integrations.map(
+      (i) => `${i.id} [${i.profile ?? "ungated"}] \u2014 ${i.status}`
+    ).join("\n");
+    return {
+      content: [{ type: "text", text }]
+    };
+  };
+}
+
+// src/tools/commitments.ts
+async function executeCommitted(proposal, state2, integrationManager2) {
+  if (!integrationManager2) {
+    return { text: `Proposal ${proposal.id} committed but integration manager unavailable for execution.`, isError: true };
+  }
+  const sep = proposal.tool.indexOf("__");
+  if (sep < 0) {
+    return { text: `Proposal ${proposal.id} has invalid tool name: ${proposal.tool}`, isError: true };
+  }
+  const integrationId = proposal.tool.slice(0, sep);
+  const toolName = proposal.tool.slice(sep + 2);
+  const proposalActionType = typeof proposal.executionContext.action_type === "string" ? proposal.executionContext.action_type : void 0;
+  if (!proposalActionType) {
+    console.error(
+      `[Suveren MCP] Warning: proposal ${proposal.id} has no action_type in executionContext. Bounds check may be skipped. Fix the integration manifest for ${proposal.tool}.`
+    );
+  }
+  try {
+    await state2.spClient.postReceipt({
+      attestationHash: proposal.frameHash,
+      profileId: proposal.profileId,
+      path: proposal.path,
+      action: proposal.tool,
+      actionType: proposalActionType,
+      executionContext: proposal.executionContext,
+      amount: typeof proposal.executionContext.amount === "number" ? proposal.executionContext.amount : void 0,
+      proposalId: proposal.id,
+      toolArgs: proposal.toolArgs
+    });
+  } catch (err) {
+    if (err instanceof SPReceiptError) {
+      const code = err.body.errors?.[0]?.code;
+      if (code === "PROPOSAL_ALREADY_EXECUTED") {
+        return {
+          text: `Proposal ${proposal.id} has already been executed by another request.`
+        };
+      }
+      return {
+        text: `Proposal ${proposal.id}: SP rejected receipt \u2014 ${err.message}`,
+        isError: true
+      };
+    }
+    return {
+      text: `Proposal ${proposal.id}: receipt request failed \u2014 ${err instanceof Error ? err.message : String(err)}`,
+      isError: true
+    };
+  }
+  try {
+    const result = await integrationManager2.callTool(integrationId, toolName, proposal.toolArgs);
+    const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
+    return { text: `Proposal ${proposal.id} committed and executed.
+Result: ${resultText}` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      text: `Proposal ${proposal.id} receipt issued but tool execution failed: ${msg}`,
+      isError: true
+    };
+  }
+}
+function checkPendingCommitmentsHandler(state2, integrationManager2) {
+  return async (args) => {
+    try {
+      if (args.proposal_id) {
+        const committed2 = await state2.spClient.getCommittedProposals();
+        const match = committed2.find((p) => p.id === args.proposal_id);
+        if (match) {
+          if (match.status === "executed" && match.executionResult) {
+            return {
+              content: [{
+                type: "text",
+                text: `Proposal ${match.id} committed and executed.
+Result: ${JSON.stringify(match.executionResult, null, 2)}`
+              }]
+            };
+          }
+          if (match.status === "committed") {
+            const { text, isError } = await executeCommitted(match, state2, integrationManager2);
+            return {
+              content: [{ type: "text", text }],
+              ...isError ? { isError: true } : {}
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `Proposal ${match.id}: status=${match.status}, committed by: [${Object.keys(match.committedBy).join(", ")}], remaining: [${match.pendingDomains.filter((d) => !(d in match.committedBy)).join(", ")}]`
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Proposal ${args.proposal_id} is still pending or not found. Domain owners have not yet committed.`
+          }]
+        };
+      }
+      const committed = await state2.spClient.getCommittedProposals();
+      if (committed.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No pending commitments. All proposals are either still awaiting domain owner review, expired, or already executed."
+          }]
+        };
+      }
+      const lines = committed.map(
+        (p) => `${p.id}: tool=${p.tool}, status=${p.status}, committed=[${Object.keys(p.committedBy).join(",")}]`
+      );
+      return {
+        content: [{
+          type: "text",
+          text: `Proposals with commitments:
+${lines.join("\n")}`
+        }]
+      };
+    } catch (err) {
+      return {
+        content: [{
+          type: "text",
+          text: `Failed to check commitments: ${err instanceof Error ? err.message : String(err)}`
+        }],
+        isError: true
+      };
+    }
+  };
+}
+
+// src/index.ts
+function jsonSchemaToZodShape(schema) {
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    let zodType;
+    switch (prop.type) {
+      case "string":
+        if (prop.enum && Array.isArray(prop.enum)) {
+          zodType = z.enum(prop.enum);
+        } else {
+          zodType = z.string();
+        }
+        break;
+      case "number":
+      case "integer":
+        zodType = z.number();
+        break;
+      case "boolean":
+        zodType = z.boolean();
+        break;
+      case "array":
+        zodType = z.array(z.unknown());
+        break;
+      case "object":
+        zodType = z.record(z.unknown());
+        break;
+      default:
+        zodType = z.unknown();
+        break;
+    }
+    if (typeof prop.description === "string") {
+      zodType = zodType.describe(prop.description);
+    }
+    shape[key] = required.has(key) ? zodType : zodType.optional();
+  }
+  return shape;
+}
+function createMcpServer(state2, integrationManager2) {
+  const { cache } = state2;
+  const enriched = state2.getEnrichedAuthorizations();
+  const instructions = buildMandateBrief({
+    authorizations: enriched,
+    executionLog: state2.executionLog,
+    integrationManager: integrationManager2
+  });
+  const server = new McpServer(
+    { name: "suveren-gateway", version: "0.1.0" },
+    { instructions }
+  );
+  server.registerTool(
+    "list-authorizations",
+    {
+      description: 'List what you are currently authorized to do. Call with no arguments for a compact overview, or with a domain (e.g., "charge") for full details including consumption, bounds, and capability map.',
+      inputSchema: {
+        domain: z.string().optional().describe('Profile domain to show full details for (e.g., "charge", "deploy"). Omit for compact overview.')
+      }
+    },
+    listAuthorizationsHandler(state2, integrationManager2)
+  );
+  server.registerTool(
+    "check-pending-attestations",
+    {
+      description: "Check if any attestations are waiting for your owner's approval.",
+      inputSchema: {
+        domain: z.string().describe(`The owner's domain (e.g., "compliance")`)
+      }
+    },
+    checkPendingHandler(cache)
+  );
+  server.registerTool(
+    "list-integrations",
+    {
+      description: "List all running integrations and their authorization status. Returns a compact overview \u2014 use list-authorizations(domain) for full details on a specific profile.",
+      inputSchema: {}
+    },
+    listIntegrationsHandler(state2, integrationManager2)
+  );
+  server.registerTool(
+    "check-pending-commitments",
+    {
+      description: "Check status of pending proposals awaiting domain owner commitment. Call with a proposal_id to check a specific proposal, or without to see all.",
+      inputSchema: {
+        proposal_id: z.string().optional().describe("Specific proposal ID to check. Omit to see all.")
+      }
+    },
+    checkPendingCommitmentsHandler(state2, integrationManager2)
+  );
+  const proxiedTools = /* @__PURE__ */ new Map();
+  function registerProxiedTools() {
+    if (!integrationManager2) {
+      console.error("[MCP] registerProxiedTools: no integrationManager");
+      return;
+    }
+    const allTools = integrationManager2.getAllTools();
+    for (const [name] of proxiedTools) {
+      if (!allTools.some((t) => t.namespacedName === name)) {
+        const entry = proxiedTools.get(name);
+        entry?.registered.remove();
+        proxiedTools.delete(name);
+      }
+    }
+    for (const tool of allTools) {
+      if (proxiedTools.has(tool.namespacedName)) continue;
+      const handler = createGatedToolHandler(tool, integrationManager2, state2);
+      const zodShape = jsonSchemaToZodShape(tool.inputSchema);
+      const description = buildProxiedToolDescription(tool, state2);
+      try {
+        const registered = server.registerTool(
+          tool.namespacedName,
+          {
+            description,
+            ...Object.keys(zodShape).length > 0 ? { inputSchema: zodShape } : {}
+          },
+          handler
+        );
+        proxiedTools.set(tool.namespacedName, { tool, registered });
+      } catch (err) {
+        console.error(`[MCP] Failed to register tool ${tool.namespacedName}:`, err);
+      }
+    }
+  }
+  function refreshTools() {
+    const auths = state2.getEnrichedAuthorizations();
+    for (const [, { tool, registered }] of proxiedTools) {
+      const description = buildProxiedToolDescription(tool, state2);
+      registered.update({ description });
+      if (tool.gating?.profile) {
+        const hasAuth = auths.some(
+          (a) => a.complete && profileMatches(a.profileId, tool.gating.profile)
+        );
+        if (hasAuth) registered.enable();
+        else registered.disable();
+      } else {
+        registered.disable();
+      }
+    }
+    server.sendToolListChanged();
+  }
+  registerProxiedTools();
+  refreshTools();
+  return { server, gatekeeper: state2.gatekeeper, refreshTools, registerProxiedTools };
+}
+
+// src/lib/gate-content.ts
+import { createHash } from "crypto";
+import { decodeAttestationBlob } from "@hap/core";
+function hashGateContent(text) {
+  const hex = createHash("sha256").update(text, "utf-8").digest("hex");
+  return `sha256:${hex}`;
+}
+function verifyGateContentHashes(content, auth) {
+  const errors = [];
+  if (auth.attestations.length === 0) {
+    return { valid: false, errors: ["No attestations available to verify against"] };
+  }
+  const attestation = decodeAttestationBlob(auth.attestations[0].blob);
+  const expectedHashes = attestation.payload.gate_content_hashes;
+  if (!expectedHashes?.intent) {
+    return { valid: false, errors: ["Attestation does not contain intent hash"] };
+  }
+  if (!content.intent) {
+    return { valid: false, errors: ["Missing intent content"] };
+  }
+  const actual = hashGateContent(content.intent);
+  if (actual !== expectedHashes.intent) {
+    errors.push(`Hash mismatch for "intent": expected ${expectedHashes.intent}, got ${actual}`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/lib/integration-registry.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join4(homedir4(), ".suveren");
+var IntegrationRegistry = class {
+  integrations = /* @__PURE__ */ new Map();
+  filePath;
+  constructor(dataDir) {
+    const dir = dataDir ?? DEFAULT_DATA_DIR;
+    this.filePath = join4(dir, "integrations.json");
+    this.load();
+  }
+  // ─── CRUD ───────────────────────────────────────────────────────────────
+  get(id) {
+    return this.integrations.get(id);
+  }
+  getAll() {
+    return Array.from(this.integrations.values());
+  }
+  getEnabled() {
+    return this.getAll().filter((i) => i.enabled);
+  }
+  add(config) {
+    this.integrations.set(config.id, config);
+    this.save();
+  }
+  update(id, updates) {
+    const existing = this.integrations.get(id);
+    if (!existing) return false;
+    this.integrations.set(id, { ...existing, ...updates });
+    this.save();
+    return true;
+  }
+  remove(id) {
+    const deleted = this.integrations.delete(id);
+    if (deleted) this.save();
+    return deleted;
+  }
+  // ─── Load / Save ────────────────────────────────────────────────────────
+  load() {
+    if (!existsSync4(this.filePath)) {
+      mkdirSync3(dirname3(this.filePath), { recursive: true });
+      return;
+    }
+    try {
+      const raw = readFileSync4(this.filePath, "utf-8");
+      const data = JSON.parse(raw);
+      const migrated = data.integrations.map((i) => {
+        if ("toolGating" in i && !("profile" in i)) {
+          const old = i;
+          const toolGating = old.toolGating;
+          const config = {
+            id: i.id,
+            name: i.name,
+            command: i.command,
+            args: i.args,
+            envKeys: i.envKeys,
+            profile: toolGating?.profile ?? null,
+            enabled: i.enabled
+          };
+          return config;
+        }
+        return i;
+      });
+      this.integrations = new Map(migrated.map((i) => [i.id, i]));
+    } catch {
+      console.error(`[IntegrationRegistry] Could not parse ${this.filePath}, starting fresh`);
+      this.integrations = /* @__PURE__ */ new Map();
+    }
+  }
+  save() {
+    const data = {
+      version: 1,
+      integrations: Array.from(this.integrations.values())
+    };
+    mkdirSync3(dirname3(this.filePath), { recursive: true });
+    writeFileSync3(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+  }
+};
+
+// src/lib/integration-manager.ts
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+import { existsSync as existsSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { execSync } from "child_process";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { getProfile as getProfile3 } from "@hap/core";
+var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join5(homedir5(), ".suveren");
+var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join5(DEFAULT_DATA_DIR2, "integrations");
+var INTEGRATIONS_BIN = join5(INTEGRATIONS_DIR, "node_modules", ".bin");
+function buildPath() {
+  const base = process.env.PATH ?? "";
+  return [INTEGRATIONS_BIN, base].join(":");
+}
+function ensureIntegrationsDir() {
+  if (!existsSync5(INTEGRATIONS_DIR)) {
+    mkdirSync4(INTEGRATIONS_DIR, { recursive: true });
+  }
+  const pkgPath = join5(INTEGRATIONS_DIR, "package.json");
+  if (!existsSync5(pkgPath)) {
+    writeFileSync4(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
+  }
+}
+var RESPAWN_DELAYS = [2e3, 4e3, 6e3];
+var MAX_RESPAWN_ATTEMPTS = 3;
+var IntegrationManager = class {
+  constructor(serviceCredentials2) {
+    this.serviceCredentials = serviceCredentials2;
+  }
+  running = /* @__PURE__ */ new Map();
+  onToolsChanged = null;
+  /**
+   * Register a callback invoked when the tool set changes
+   * (integration started, stopped, or crashed).
+   */
+  setOnToolsChanged(cb) {
+    this.onToolsChanged = cb;
+  }
+  /**
+   * Install an npm package into the managed integrations directory if not already present.
+   * Called automatically before spawning when config.npmPackage is set.
+   */
+  ensureInstalled(npmPackage) {
+    ensureIntegrationsDir();
+    const binName = npmPackage.split("/").pop()?.replace(/^@/, "") ?? npmPackage;
+    const installed = existsSync5(join5(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/")));
+    if (installed) return;
+    console.error(`[IntegrationManager] Installing ${npmPackage}...`);
+    try {
+      execSync(`npm install --no-fund --no-audit ${npmPackage}`, {
+        cwd: INTEGRATIONS_DIR,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 12e4
+      });
+      console.error(`[IntegrationManager] Installed ${npmPackage}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to install ${npmPackage}: ${message}`);
+    }
+  }
+  /**
+   * Start a downstream MCP server integration.
+   * Installs npm package on-demand if needed, resolves envKeys,
+   * spawns the process, connects as MCP client, and discovers tools.
+   */
+  async startIntegration(config) {
+    if (this.running.has(config.id)) {
+      await this.stopIntegration(config.id);
+    }
+    if (config.npmPackage) {
+      this.ensureInstalled(config.npmPackage);
+    }
+    const env = this.resolveEnvKeys(config);
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args,
+      env: {
+        ...process.env,
+        PATH: buildPath(),
+        HAP_DATA_DIR: DEFAULT_DATA_DIR2,
+        ...config.env,
+        ...env
+      }
+    });
+    const client = new Client(
+      { name: "suveren-gateway", version: "0.1.0" },
+      { capabilities: {} }
+    );
+    await client.connect(transport);
+    console.error(`[IntegrationManager] Connected to ${config.id} (${config.command} ${config.args.join(" ")})`);
+    const toolsResult = await client.listTools();
+    const profileGating = config.toolGating ?? (config.profile ? getProfile3(config.profile)?.toolGating ?? null : null);
+    const tools = (toolsResult.tools ?? []).map((tool) => {
+      const gating = this.resolveToolGating(config.profile, profileGating, tool.name);
+      return {
+        originalName: tool.name,
+        namespacedName: `${config.id}__${tool.name}`,
+        integrationId: config.id,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema ?? {},
+        gating
+      };
+    });
+    console.error(`[IntegrationManager] Discovered ${tools.length} tools from ${config.id}`);
+    const entry = {
+      config,
+      client,
+      transport,
+      tools,
+      respawnAttempts: 0
+    };
+    this.running.set(config.id, entry);
+    transport.onclose = () => {
+      console.error(`[IntegrationManager] Transport closed for ${config.id}`);
+      this.handleCrash(config.id);
+    };
+    this.onToolsChanged?.();
+    return tools;
+  }
+  /**
+   * Stop a running integration, closing its transport and removing its tools.
+   */
+  async stopIntegration(id) {
+    const entry = this.running.get(id);
+    if (!entry) return;
+    entry.transport.onclose = void 0;
+    try {
+      await entry.client.close();
+    } catch {
+    }
+    this.running.delete(id);
+    console.error(`[IntegrationManager] Stopped ${id}`);
+    this.onToolsChanged?.();
+  }
+  /**
+   * Proxy a tool call to a downstream MCP server.
+   */
+  async callTool(integrationId, toolName, args) {
+    const entry = this.running.get(integrationId);
+    if (!entry) {
+      return {
+        content: [{ type: "text", text: `Integration "${integrationId}" is not running.` }],
+        isError: true
+      };
+    }
+    try {
+      const result = await entry.client.callTool({ name: toolName, arguments: args });
+      const content = result.content.map((item) => ({
+        type: item.type,
+        text: item.text ?? JSON.stringify(item)
+      }));
+      return { content, 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
+      };
+    }
+  }
+  /**
+   * Get all discovered tools across all running integrations.
+   */
+  getAllTools() {
+    const tools = [];
+    for (const entry of this.running.values()) {
+      tools.push(...entry.tools);
+    }
+    return tools;
+  }
+  /**
+   * Get status info for all known integrations.
+   */
+  getStatus(allConfigs) {
+    const statuses = [];
+    for (const entry of this.running.values()) {
+      statuses.push({
+        id: entry.config.id,
+        name: entry.config.name,
+        running: true,
+        toolCount: entry.tools.length
+      });
+    }
+    if (allConfigs) {
+      for (const config of allConfigs) {
+        if (!this.running.has(config.id)) {
+          statuses.push({
+            id: config.id,
+            name: config.name,
+            running: false,
+            toolCount: 0
+          });
+        }
+      }
+    }
+    return statuses;
+  }
+  /**
+   * Check if an integration is running.
+   */
+  isRunning(id) {
+    return this.running.has(id);
+  }
+  /**
+   * Check if all required env keys for an integration can be resolved.
+   */
+  canResolveEnvKeys(config) {
+    for (const vaultRef of Object.values(config.envKeys)) {
+      const [serviceId, key] = vaultRef.split(".", 2);
+      const creds = this.serviceCredentials.get(serviceId);
+      if (!creds || !(key in creds)) return false;
+    }
+    return true;
+  }
+  /**
+   * Read the credentials stored in memory for a given service id. Used by
+   * startup diagnostics to report which keys are missing when an integration
+   * cannot start — not a general read API.
+   */
+  getServiceCredentials(serviceId) {
+    return this.serviceCredentials.get(serviceId);
+  }
+  /**
+   * Gracefully shut down all running integrations.
+   */
+  async shutdown() {
+    const ids = Array.from(this.running.keys());
+    await Promise.allSettled(ids.map((id) => this.stopIntegration(id)));
+    console.error(`[IntegrationManager] All integrations shut down`);
+  }
+  // ─── Private ──────────────────────────────────────────────────────────────
+  /**
+   * Resolve envKeys from serviceCredentials.
+   * Format: { "STRIPE_API_KEY": "stripe.apiKey" } → looks up serviceCredentials.get("stripe")?.apiKey
+   */
+  resolveEnvKeys(config) {
+    const env = {};
+    for (const [envVar, vaultRef] of Object.entries(config.envKeys)) {
+      const [serviceId, key] = vaultRef.split(".", 2);
+      const creds = this.serviceCredentials.get(serviceId);
+      if (creds && key in creds) {
+        env[envVar] = creds[key];
+      }
+    }
+    for (const [envVar, vaultRef] of Object.entries(config.optionalEnvKeys ?? {})) {
+      const [serviceId, key] = vaultRef.split(".", 2);
+      const creds = this.serviceCredentials.get(serviceId);
+      if (creds && key in creds) {
+        env[envVar] = creds[key];
+      }
+    }
+    return env;
+  }
+  /**
+   * Resolve gating config for a tool from the profile's toolGating section.
+   * Returns the runtime ToolGatingConfig that tool-proxy.ts consumes.
+   */
+  resolveToolGating(profileId, profileGating, toolName) {
+    if (!profileId || !profileGating) return null;
+    if (profileGating.overrides && toolName in profileGating.overrides) {
+      const override = profileGating.overrides[toolName];
+      if (override === null || override.category === "read") {
+        return {
+          profile: profileId,
+          executionMapping: {},
+          category: "read"
+        };
+      }
+      return {
+        profile: profileId,
+        executionMapping: override.executionMapping,
+        staticExecution: override.staticExecution
+      };
+    }
+    return {
+      profile: profileId,
+      executionMapping: profileGating.default.executionMapping,
+      staticExecution: profileGating.default.staticExecution
+    };
+  }
+  /**
+   * Handle a downstream process crash — attempt respawn with backoff.
+   */
+  handleCrash(id) {
+    const entry = this.running.get(id);
+    if (!entry) return;
+    const attempts = entry.respawnAttempts;
+    this.running.delete(id);
+    this.onToolsChanged?.();
+    if (attempts >= MAX_RESPAWN_ATTEMPTS) {
+      console.error(`[IntegrationManager] ${id} crashed ${MAX_RESPAWN_ATTEMPTS} times, giving up`);
+      return;
+    }
+    const delay = RESPAWN_DELAYS[attempts] ?? RESPAWN_DELAYS[RESPAWN_DELAYS.length - 1];
+    console.error(`[IntegrationManager] ${id} crashed, respawning in ${delay}ms (attempt ${attempts + 1}/${MAX_RESPAWN_ATTEMPTS})`);
+    setTimeout(async () => {
+      try {
+        await this.startIntegration(entry.config);
+        const newEntry = this.running.get(id);
+        if (newEntry) {
+          newEntry.respawnAttempts = attempts + 1;
+        }
+      } catch (err) {
+        console.error(`[IntegrationManager] Failed to respawn ${id}:`, err);
+        const fakeEntry = {
+          config: entry.config,
+          client: null,
+          transport: null,
+          tools: [],
+          respawnAttempts: attempts + 1
+        };
+        this.running.set(id, fakeEntry);
+        this.handleCrash(id);
+      }
+    }, delay);
+  }
+};
+
+// src/lib/profile-loader.ts
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { join as join6, resolve } from "path";
+import { registerProfile } from "@hap/core";
+function loadProfiles(profilesDir) {
+  const dir = resolve(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join6(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
+  const indexPath = join6(dir, "index.json");
+  if (!existsSync6(indexPath)) {
+    console.error(`[ProfileLoader] No index.json found at ${indexPath}, skipping profile loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync5(indexPath, "utf-8"));
+  } catch (err) {
+    console.error(`[ProfileLoader] Failed to parse ${indexPath}:`, err);
+    return 0;
+  }
+  let loaded = 0;
+  for (const [profileId, relativePath] of Object.entries(index.profiles)) {
+    const profilePath = join6(dir, relativePath);
+    try {
+      const profile = JSON.parse(readFileSync5(profilePath, "utf-8"));
+      registerProfile(profileId, profile);
+      const shortName = profileId.split("/").pop()?.replace(/@.*$/, "");
+      if (shortName && shortName !== profileId) {
+        registerProfile(shortName, profile);
+      }
+      loaded++;
+    } catch (err) {
+      console.error(`[ProfileLoader] Failed to load profile ${profileId} from ${profilePath}:`, err);
+    }
+  }
+  console.error(`[ProfileLoader] Loaded ${loaded} profile(s) from ${dir}`);
+  return loaded;
+}
+
+// src/lib/manifest-loader.ts
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { join as join7, resolve as resolve2 } from "path";
+var manifests = /* @__PURE__ */ new Map();
+function loadManifests(integrationsDir) {
+  const dir = resolve2(
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join7(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+  );
+  const indexPath = join7(dir, "index.json");
+  if (!existsSync7(indexPath)) {
+    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync6(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 = join7(dir, relativePath);
+    try {
+      const manifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+      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());
+}
+
+// bin/http.ts
+var spUrl = process.env.SUVEREN_AS_URL ?? "https://www.suveren.ai";
+var port = parseInt(process.env.SUVEREN_MCP_PORT ?? "3430", 10);
+var state = new SharedState(spUrl);
+var spApiKey = process.env.SUVEREN_AS_API_KEY ?? "";
+if (spApiKey) {
+  state.spClient.setApiKey(spApiKey);
+}
+var serviceCredentials = /* @__PURE__ */ new Map();
+var integrationRegistry = new IntegrationRegistry();
+var integrationManager = new IntegrationManager(serviceCredentials);
+var activeSessions = /* @__PURE__ */ new Map();
+function refreshAllSessions() {
+  for (const [sessionId, session] of activeSessions) {
+    try {
+      session.registerProxiedTools();
+      session.refreshTools();
+    } catch (err) {
+      console.error(`[Suveren MCP] Failed to refresh session ${sessionId}:`, err);
+    }
+  }
+}
+integrationManager.setOnToolsChanged(() => {
+  refreshAllSessions();
+});
+var app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "http://localhost:3000");
+  res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+  res.header("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+  if (_req.method === "OPTIONS") {
+    res.sendStatus(204);
+    return;
+  }
+  next();
+});
+var INTERNAL_SECRET = process.env.SUVEREN_INTERNAL_SECRET ?? "";
+function internalOnly(req, res, next) {
+  const ip = req.ip ?? req.socket.remoteAddress ?? "";
+  const isLoopback = ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+  if (!isLoopback) {
+    res.status(403).json({ error: "Internal endpoint \u2014 loopback only" });
+    return;
+  }
+  const secret = req.headers["x-internal-secret"];
+  if (INTERNAL_SECRET && secret !== INTERNAL_SECRET) {
+    res.status(403).json({ error: "Invalid internal secret" });
+    return;
+  }
+  next();
+}
+app.post("/internal/configure", internalOnly, (req, res) => {
+  const { sessionCookie, vaultKeyHex, apiKey } = req.body;
+  if (!sessionCookie) {
+    res.status(400).json({ error: "Missing sessionCookie" });
+    return;
+  }
+  state.spClient.setSessionCookie(sessionCookie);
+  console.error("[Suveren MCP] Session cookie configured by control-plane");
+  if (vaultKeyHex) {
+    state.gateStore.setVaultKey(Buffer.from(vaultKeyHex, "hex"));
+    console.error("[Suveren MCP] Vault key configured \u2014 gate store encryption active");
+  }
+  if (apiKey) {
+    state.spClient.setApiKey(apiKey);
+    console.error("[Suveren MCP] SP API key configured by control-plane");
+  }
+  res.json({ ok: true });
+});
+app.post("/internal/gate-content", internalOnly, async (req, res) => {
+  try {
+    const { frameHash, boundsHash, contextHash, context, path: rawPath, gateContent } = req.body;
+    const storageHash = frameHash ?? boundsHash;
+    const hasIntent = !!gateContent?.intent;
+    const hasLegacy = !!gateContent?.problem && !!gateContent?.objective && !!gateContent?.tradeoffs;
+    if (!storageHash || !hasIntent && !hasLegacy) {
+      res.status(400).json({ error: "Missing required fields: frameHash (or boundsHash), gateContent.{intent} or gateContent.{problem,objective,tradeoffs}" });
+      return;
+    }
+    const auth = await state.cache.syncAuthorization(storageHash);
+    if (!auth) {
+      res.status(404).json({ error: `No attestation found for frame hash ${storageHash}` });
+      return;
+    }
+    const verification = verifyGateContentHashes(gateContent, auth);
+    if (!verification.valid) {
+      res.status(400).json({ error: "Gate content hash mismatch", details: verification.errors });
+      return;
+    }
+    const path = rawPath || auth.profileId;
+    state.setGateContent(path, storageHash, auth.profileId, gateContent, {
+      boundsHash,
+      contextHash,
+      context
+    });
+    console.error(`[Suveren MCP] Gate content accepted for ${path}`);
+    for (const [sessionId, session] of activeSessions) {
+      try {
+        session.refreshTools();
+      } catch (err) {
+        console.error(`[Suveren MCP] Failed to refresh session ${sessionId}:`, err);
+      }
+    }
+    res.json({ ok: true, path });
+  } catch (err) {
+    console.error("[Suveren MCP] Error handling /internal/gate-content:", err);
+    res.status(500).json({ error: "Internal error" });
+  }
+});
+app.post("/internal/service-credentials", internalOnly, (req, res) => {
+  const { serviceId, credentials } = req.body;
+  if (!serviceId || !credentials) {
+    res.status(400).json({ error: "Missing serviceId or credentials" });
+    return;
+  }
+  serviceCredentials.set(serviceId, credentials);
+  console.error(`[Suveren MCP] Service credentials stored for ${serviceId}`);
+  void startIntegrationForService(serviceId);
+  res.json({ ok: true });
+});
+app.post("/internal/start-pending-integrations", internalOnly, async (_req, res) => {
+  try {
+    await startPendingIntegrations();
+    const running = integrationManager.getStatus().filter((s) => s.running).map((s) => s.id);
+    res.json({ ok: true, running });
+  } catch (err) {
+    console.error("[Suveren MCP] start-pending-integrations failed:", err);
+    res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+  }
+});
+app.post("/internal/resync-gates", internalOnly, async (_req, res) => {
+  const gates = state.gateStore.getAll();
+  if (gates.length === 0) {
+    res.json({ ok: true, synced: 0 });
+    return;
+  }
+  let synced = 0;
+  let orphaned = 0;
+  for (const gate of gates) {
+    try {
+      const syncHash = gate.frameHash ?? gate.boundsHash;
+      const auth = await state.cache.syncAuthorization(syncHash);
+      if (auth) {
+        state.setGateContent(gate.path, syncHash, auth.profileId, gate.gateContent, {
+          boundsHash: gate.boundsHash,
+          contextHash: gate.contextHash,
+          context: gate.context
+        });
+        synced++;
+        console.error(`[Suveren MCP] Re-synced gate: ${gate.path}`);
+      } else {
+        state.cache.invalidate(gate.path);
+        state.gateStore.delete(gate.path);
+        orphaned++;
+        console.error(`[Suveren MCP] Orphan gate purged (SP attestation deleted): ${gate.path}`);
+      }
+    } catch (err) {
+      console.error(`[Suveren MCP] Failed to re-sync gate ${gate.path}:`, err);
+    }
+  }
+  for (const [sessionId, session] of activeSessions) {
+    try {
+      session.refreshTools();
+    } catch (err) {
+      console.error(`[Suveren MCP] Failed to refresh session ${sessionId}:`, err);
+    }
+  }
+  res.json({ ok: true, synced, orphaned });
+});
+app.post("/internal/add-integration", internalOnly, async (req, res) => {
+  try {
+    const config = req.body;
+    if (!config.id || !config.command) {
+      res.status(400).json({ error: "Missing required fields: id, command" });
+      return;
+    }
+    integrationRegistry.add(config);
+    console.error(`[Suveren MCP] Integration ${config.id} added to registry`);
+    if (config.enabled) {
+      if (Object.keys(config.envKeys ?? {}).length === 0 || integrationManager.canResolveEnvKeys(config)) {
+        try {
+          const tools = await integrationManager.startIntegration(config);
+          res.json({ ok: true, id: config.id, tools: tools.map((t) => t.namespacedName) });
+          return;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`[Suveren MCP] Failed to start integration ${config.id}:`, message);
+          res.json({ ok: true, id: config.id, tools: [], warning: `Saved but failed to start: ${message}` });
+          return;
+        }
+      } else {
+        console.error(`[Suveren MCP] Integration ${config.id} saved but waiting for credentials`);
+        res.json({ ok: true, id: config.id, tools: [], warning: "Saved but waiting for service credentials" });
+        return;
+      }
+    }
+    res.json({ ok: true, id: config.id, tools: [] });
+  } catch (err) {
+    console.error("[Suveren MCP] Error adding integration:", err);
+    res.status(500).json({ error: "Internal error" });
+  }
+});
+app.delete("/internal/remove-integration/:id", internalOnly, async (req, res) => {
+  const id = req.params.id;
+  await integrationManager.stopIntegration(id);
+  const removed = integrationRegistry.remove(id);
+  if (!removed) {
+    res.status(404).json({ error: `Integration "${id}" not found` });
+    return;
+  }
+  console.error(`[Suveren MCP] Integration ${id} removed`);
+  res.json({ ok: true, id });
+});
+app.get("/internal/integrations", internalOnly, (_req, res) => {
+  const configs = integrationRegistry.getAll();
+  const statuses = integrationManager.getStatus(configs);
+  res.json({ integrations: statuses });
+});
+app.post("/internal/stop-all-running", internalOnly, async (_req, res) => {
+  try {
+    await integrationManager.shutdown();
+    console.error("[Suveren MCP] All running integrations stopped (registry preserved)");
+    res.json({ ok: true });
+  } catch (err) {
+    console.error("[Suveren MCP] stop-all-running failed:", err);
+    res.status(500).json({ error: err instanceof Error ? err.message : "Stop failed" });
+  }
+});
+var sseSessions = /* @__PURE__ */ new Map();
+app.get("/sse", async (_req, res) => {
+  const transport = new SSEServerTransport("/messages", res);
+  const { server, refreshTools, registerProxiedTools } = createMcpServer(state, integrationManager);
+  const sessionId = transport.sessionId;
+  sseSessions.set(sessionId, transport);
+  activeSessions.set(sessionId, { refreshTools, registerProxiedTools });
+  console.error(`[Suveren MCP] SSE session ${sessionId} connected`);
+  res.on("close", () => {
+    sseSessions.delete(sessionId);
+    activeSessions.delete(sessionId);
+    console.error(`[Suveren MCP] SSE session ${sessionId} closed`);
+  });
+  server.registerTool("debug_test_tool", { description: "Debug test" }, async () => ({
+    content: [{ type: "text", text: "debug" }]
+  }));
+  await server.connect(transport);
+});
+app.post("/messages", async (req, res) => {
+  const sessionId = req.query.sessionId;
+  const transport = sseSessions.get(sessionId);
+  if (!transport) {
+    res.status(400).json({ error: "Unknown session" });
+    return;
+  }
+  await transport.handlePostMessage(req, res, req.body);
+});
+var streamableSessions = /* @__PURE__ */ new Map();
+app.all("/mcp", async (req, res) => {
+  const sessionId = req.headers["mcp-session-id"];
+  if (req.method === "GET" || req.method === "POST" || req.method === "DELETE") {
+    if (sessionId && streamableSessions.has(sessionId)) {
+      const transport = streamableSessions.get(sessionId);
+      await transport.handleRequest(req, res, req.body);
+      return;
+    }
+    if (req.method === "POST" && !sessionId) {
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID()
+      });
+      transport.onclose = () => {
+        if (transport.sessionId) {
+          streamableSessions.delete(transport.sessionId);
+          activeSessions.delete(transport.sessionId);
+          console.error(`[Suveren MCP] Streamable session ${transport.sessionId} closed`);
+        }
+      };
+      const { server, refreshTools, registerProxiedTools } = createMcpServer(state, integrationManager);
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      if (transport.sessionId && !streamableSessions.has(transport.sessionId)) {
+        streamableSessions.set(transport.sessionId, transport);
+        activeSessions.set(transport.sessionId, { refreshTools, registerProxiedTools });
+        console.error(`[Suveren MCP] Streamable session ${transport.sessionId}`);
+      }
+      return;
+    }
+    res.status(400).json({ error: "Bad request \u2014 missing or invalid session" });
+  } else {
+    res.status(405).json({ error: "Method not allowed" });
+  }
+});
+app.get("/health", (_req, res) => {
+  res.json({
+    status: "ok",
+    transports: ["sse", "streamable-http"],
+    sp: spUrl,
+    activeSessions: activeSessions.size,
+    storedGates: state.gateStore.getAll().length,
+    serviceCredentials: Array.from(serviceCredentials.keys()),
+    integrations: integrationManager.getStatus(integrationRegistry.getAll())
+  });
+});
+app.get("/internal/gate-content", internalOnly, (req, res) => {
+  const path = req.query.path;
+  const gates = state.gateStore.getAll();
+  if (path) {
+    const entry = gates.find(
+      (g) => g.path === path || g.profileId === path || g.boundsHash === path || g.frameHash === path
+    );
+    res.json({ entry: entry ?? null });
+  } else {
+    res.json({ entries: gates });
+  }
+});
+app.get("/internal/manifests", internalOnly, (_req, res) => {
+  res.json({ manifests: getAllManifests() });
+});
+app.get("/internal/brief", internalOnly, (_req, res) => {
+  try {
+    const enriched = state.getEnrichedAuthorizations();
+    const brief = buildMandateBrief({
+      authorizations: enriched,
+      executionLog: state.executionLog,
+      integrationManager
+    });
+    res.json({ brief });
+  } catch (err) {
+    console.error("[Suveren MCP] /internal/brief failed:", err);
+    res.status(500).json({ error: err instanceof Error ? err.message : "Brief preview failed" });
+  }
+});
+async function startPendingIntegrations() {
+  const configs = integrationRegistry.getEnabled();
+  for (const config of configs) {
+    await startOneIntegration(config);
+  }
+}
+async function startIntegrationForService(serviceId) {
+  const candidates = integrationRegistry.getEnabled().filter(
+    (c) => c.id === serviceId || Object.values(c.envKeys ?? {}).some((ref) => typeof ref === "string" && ref.startsWith(`${serviceId}.`))
+  );
+  for (const config of candidates) {
+    await startOneIntegration(config);
+  }
+}
+async function startOneIntegration(config) {
+  if (integrationManager.isRunning(config.id)) return;
+  const needsCreds = Object.keys(config.envKeys ?? {}).length > 0;
+  if (needsCreds && !integrationManager.canResolveEnvKeys(config)) {
+    const missing = [];
+    for (const [envKey, vaultRef] of Object.entries(config.envKeys ?? {})) {
+      const [serviceId, key] = vaultRef.split(".", 2);
+      const creds = integrationManager.getServiceCredentials(serviceId);
+      if (!creds || !(key in creds)) {
+        missing.push(`${envKey} <- ${vaultRef}`);
+      }
+    }
+    console.error(
+      `[Suveren MCP] ${config.id} cannot start \u2014 missing credentials: ${missing.join(", ")}`
+    );
+    return;
+  }
+  const manifest = getManifest(config.id);
+  const effectiveConfig = manifest ? { ...config, toolGating: manifest.toolGating, npmPackage: manifest.npmPackage ?? config.npmPackage } : config;
+  try {
+    await integrationManager.startIntegration(effectiveConfig);
+  } catch (err) {
+    console.error(`[Suveren MCP] Failed to start integration ${config.id}:`, err);
+  }
+}
+process.on("SIGTERM", async () => {
+  console.error("[Suveren MCP] SIGTERM received, shutting down...");
+  await integrationManager.shutdown();
+  process.exit(0);
+});
+process.on("SIGINT", async () => {
+  console.error("[Suveren MCP] SIGINT received, shutting down...");
+  await integrationManager.shutdown();
+  process.exit(0);
+});
+app.listen(port, "0.0.0.0", () => {
+  console.error(`[Suveren MCP] HTTP server listening on http://0.0.0.0:${port}`);
+  console.error(`[Suveren MCP]   SSE:        http://0.0.0.0:${port}/sse`);
+  console.error(`[Suveren MCP]   Streamable: http://0.0.0.0:${port}/mcp`);
+  console.error(`[Suveren MCP]   SP server:  ${spUrl}`);
+  loadProfiles();
+  loadManifests();
+  if (integrationRegistry.getEnabled().length === 0) {
+    const personalManifests = getAllManifests().filter((m) => m.personalDefault);
+    for (const manifest of personalManifests) {
+      const optionalKeys = new Set(
+        manifest.credentials.fields.filter((f) => f.optional).map((f) => f.key)
+      );
+      const envKeys = {};
+      const optionalEnvKeys = {};
+      for (const [envVar, credKey] of Object.entries(manifest.credentials.envMapping)) {
+        if (optionalKeys.has(credKey)) {
+          optionalEnvKeys[envVar] = `${manifest.id}.${credKey}`;
+        } else {
+          envKeys[envVar] = `${manifest.id}.${credKey}`;
+        }
+      }
+      integrationRegistry.add({
+        id: manifest.id,
+        name: manifest.name,
+        command: manifest.mcp.command,
+        args: manifest.mcp.args,
+        env: manifest.mcp.env,
+        envKeys,
+        ...Object.keys(optionalEnvKeys).length > 0 ? { optionalEnvKeys } : {},
+        profile: manifest.profile,
+        toolGating: manifest.toolGating,
+        npmPackage: manifest.npmPackage,
+        enabled: true
+      });
+      console.error(`[Suveren MCP] Auto-registered personal integration: ${manifest.id}`);
+    }
+  }
+  startPendingIntegrations().then(() => {
+    const running = integrationManager.getStatus().filter((s) => s.running);
+    if (running.length > 0) {
+      console.error(`[Suveren MCP] Restored ${running.length} integration(s): ${running.map((s) => s.id).join(", ")}`);
+    }
+  });
+  const PROPOSAL_POLL_INTERVAL = 5e3;
+  async function executeCommittedProposals() {
+    try {
+      const committed = await state.spClient.getCommittedProposals();
+      for (const proposal of committed) {
+        try {
+          let integrationId;
+          let toolName;
+          if (proposal.tool.includes("___")) {
+            const parts = proposal.tool.split("___");
+            if (parts.length !== 2) {
+              console.error(`[Suveren MCP] Invalid tool name in proposal ${proposal.id}: ${proposal.tool}`);
+              continue;
+            }
+            [integrationId, toolName] = parts;
+          } else {
+            const sep = proposal.tool.indexOf("__");
+            if (sep < 0) {
+              console.error(`[Suveren MCP] Invalid tool name in proposal ${proposal.id}: ${proposal.tool}`);
+              continue;
+            }
+            integrationId = proposal.tool.slice(0, sep);
+            toolName = proposal.tool.slice(sep + 2);
+          }
+          const proposalActionType = typeof proposal.executionContext.action_type === "string" ? proposal.executionContext.action_type : void 0;
+          if (!proposalActionType) {
+            console.error(
+              `[Suveren MCP] Warning: proposal ${proposal.id} has no action_type in executionContext. Bounds check may be skipped. Fix the integration manifest for ${proposal.tool}.`
+            );
+          }
+          try {
+            await state.spClient.postReceipt({
+              attestationHash: proposal.frameHash,
+              profileId: proposal.profileId,
+              path: proposal.path,
+              action: proposal.tool,
+              actionType: proposalActionType,
+              executionContext: proposal.executionContext,
+              amount: typeof proposal.executionContext.amount === "number" ? proposal.executionContext.amount : void 0,
+              proposalId: proposal.id,
+              toolArgs: proposal.toolArgs
+            });
+          } catch (err) {
+            console.error(`[Suveren MCP] Receipt failed for proposal ${proposal.id}:`, err instanceof Error ? err.message : err);
+            continue;
+          }
+          try {
+            await integrationManager.callTool(integrationId, toolName, proposal.toolArgs);
+          } catch (err) {
+            console.error(`[Suveren MCP] Tool execution failed for proposal ${proposal.id} after receipt issued:`, err);
+            continue;
+          }
+          state.executionLog.record({
+            profileId: proposal.profileId,
+            path: proposal.path,
+            execution: proposal.executionContext,
+            timestamp: Math.floor(Date.now() / 1e3)
+          });
+          console.error(`[Suveren MCP] Auto-executed proposal ${proposal.id}: ${proposal.tool}`);
+        } catch (err) {
+          console.error(`[Suveren MCP] Failed to execute proposal ${proposal.id}:`, err);
+        }
+      }
+    } catch {
+    }
+  }
+  setInterval(executeCommittedProposals, PROPOSAL_POLL_INTERVAL);
+});