@suveren/gateway 0.2.12 → 0.3.1

package/README.md

@@ -1,6 +1,20 @@
 # Suveren Gateway
 
-**Suveren** is a commercial service built on the [Human Agency Protocol (HAP)](https://humanagencyprotocol.org) — the open protocol for bounded AI agent authority. The gateway is a Suveren product. The `@hap/core` protocol library inside this repo stays HAP-named because it re-exports the open HAP library. When you see "HAP-compliant" or references to the protocol spec, those describe the open standard, not the Suveren brand.
+> **HAP is the protocol. Suveren is an implementation of it.**
+>
+> The Human Agency Protocol (HAP) is the open standard for bounded AI-agent
+> authority — it defines the roles (**Authority Server**, **Gatekeeper**,
+> **Executor**) and the concepts (profiles, gates, attestations, bounds,
+> context, receipts). **Suveren** implements them: this repo is the **Gateway**,
+> and [`suveren-as`](https://www.suveren.ai) is the **Authority Server**. The
+> protocol is open — anyone can build their own compliant gateway.
+
+This repository is the **Suveren Gateway** — Suveren's implementation of the HAP
+**Gatekeeper + Executor** roles. It runs locally and verifies every tool call
+against its authorization before the call reaches an external service. (The
+`@hap/core` library inside this repo keeps its HAP name because it re-exports the
+open protocol library — "HAP-compliant" and spec references describe the open
+standard, not the Suveren brand.)
 
 Part of [suveren.ai](https://www.suveren.ai).
 
@@ -16,11 +30,11 @@ Works with any MCP-compatible agent. Define and authorize what they're allowed t
 
 Set the threshold. Routine actions execute automatically within the bounds you defined. High-stakes actions pause for your review before the agent acts.
 
-**Automatic** — You commit to specific bounds upfront: max amounts, allowed actions, time windows. The agent executes autonomously within those bounds. Each tool call is verified against your authorization and produces a signed receipt.
+**Automatic** — You commit to specific bounds upfront: max amounts, allowed actions, time windows. The agent executes autonomously within those bounds. For each tool call the gateway verifies your authorization and requests a receipt from the Authority Server, which issues the signed receipt before the call runs — no receipt, no execution.
 
 **Review each action** — You define bounds but defer full commitment. When the agent proposes an action, you review it in the gateway UI — seeing exactly which tool, which arguments, which context. You approve or reject. Execution only proceeds after your decision.
 
-Both modes are bounded. Both produce receipts. Both create a full audit trail. The difference is whether you trust the bounds enough for autonomous execution, or want to review each action individually.
+Both modes are bounded. In both, the Authority Server issues a signed receipt before the action runs — no receipt, no execution — and that signed history is a full audit trail. The difference is whether you trust the bounds enough for autonomous execution, or want to review each action individually.
 
 ---
 
@@ -33,7 +47,7 @@ Human                                 AI Agent
   |    articulate direction,              |
   |    commit (or defer)                  |
   v                                       |
-Service Provider                          |
+Authority Server                          |
   | 2. Sign attestation (Ed25519)         |
   v                                       |
 Gateway                                   |
@@ -41,14 +55,14 @@ Gateway                                   |
   |              4. Tool call <-----------|
   |                                       |
   | 5. Fully committed:                   |
-  |    Gatekeeper verifies bounds         |
-  |    -> receipt issued, execute         |
+  |    Gatekeeper checks bounds, asks AS  |
+  |    -> AS issues receipt, execute      |
   |                                       |
   |    Deferred commitment:               |
   |    -> proposal created                |
   |    -> human reviews in UI             |
   |    -> commit or reject                |
-  |    -> execute on commit               |
+  |    -> on commit: AS receipt, execute  |
 ```
 
 The agent never holds credentials or signing authority. It acts within the bounds you set — high autonomy without losing accountability.

package/dist/control-plane/index.mjs

@@ -362,6 +362,13 @@ async function getGateContent(path) {
   if (!res.ok) throw new Error("Failed to fetch gate content");
   return res.json();
 }
+async function getEnrichedAuthorizations() {
+  const res = await fetch(`${MCP_BASE}/internal/authorizations`, {
+    headers: internalHeaders()
+  });
+  if (!res.ok) throw new Error("Failed to fetch authorizations");
+  return res.json();
+}
 async function getMcpHealth() {
   const res = await fetch(`${MCP_BASE}/health`);
   if (!res.ok) throw new Error("MCP server unreachable");
@@ -375,6 +382,7 @@ import {
   HkdfSha256,
   Aes256Gcm
 } from "@hpke/core";
+import { canonicalizeText } from "@hap/core";
 function getSuite() {
   return new CipherSuite({
     kem: new DhkemX25519HkdfSha256(),
@@ -975,6 +983,84 @@ ${request.currentText}
     };
   }
 }
+async function callModel(config, messages, opts) {
+  if (config.provider === "ollama") {
+    const response2 = await fetch(`${config.endpoint}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: config.model,
+        messages,
+        stream: false,
+        options: { temperature: opts.temperature, num_predict: opts.maxTokens }
+      }),
+      signal: AbortSignal.timeout(opts.timeoutMs)
+    });
+    if (!response2.ok) throw new Error(`Ollama: ${response2.status}`);
+    const data2 = await response2.json();
+    return data2.message?.content?.trim() || "No response generated.";
+  }
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+  const response = await fetch(`${config.endpoint}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ model: config.model, messages, temperature: opts.temperature, max_tokens: opts.maxTokens }),
+    signal: AbortSignal.timeout(opts.timeoutMs)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`AI provider: ${response.status} - ${errorText}`);
+  }
+  const data = await response.json();
+  return data.choices?.[0]?.message?.content?.trim() || "No response generated.";
+}
+var INTENT_REVIEW_PROMPT = `You are a reviewing assistant for Suveren. A human is creating a NEW agent authorization. Compare the MEANING of its Intent against the Intent of their EXISTING authorizations on the same profile.
+
+Focus ONLY on the intent prose \u2014 the stated situation, goal, and soft rules / watch-outs. Surface:
+- Contradictions: a soft rule or goal in one intent that conflicts with another (e.g. one says "never email on weekends", the new one implies weekend sends; one says "formal tone only", another "keep it casual").
+- Tension: intent that works against, or ignores a caution stated in, another authorization.
+- Redundant purpose: the new intent describes essentially the same purpose as an existing one.
+
+Do NOT report:
+- That scopes/recipients overlap, or that numeric limits differ \u2014 those are detected separately and already shown to the user. Ignore them entirely.
+- Anything not grounded in the actual intent text.
+
+Use each authorization's scope ONLY to judge whether two intents' rules would actually collide in practice (overlapping targets) versus being independent \u2014 never report the scope overlap itself.
+
+Rules:
+- Be concise \u2014 a few short bullets at most.
+- If the new intent has no real content yet (just placeholder prompts like "Why \u2014 \u2026", "Goal \u2014 \u2026", "Watch out \u2014 \u2026"), reply EXACTLY: "Not enough intent written yet to review."
+- If the intents are compatible, reply EXACTLY: "No intent conflicts found with your existing authorizations."
+- Refer to each existing authorization by its number in square brackets \u2014 e.g. [1], [2] \u2014 matching the numbered list provided, and you may also state its scope. Never invent names. Do NOT rewrite intent or make the decision \u2014 you surface; the human decides.`;
+async function getIntentReview(config, request) {
+  const disclaimer = "AI surfaces reality. You decide.";
+  const lines = [];
+  lines.push(`NEW authorization on profile "${request.profileName}":`);
+  if (request.scope) lines.push(`  Scope (for context only): ${request.scope}`);
+  lines.push(`  Intent: ${request.newIntent.trim() || "(empty)"}`);
+  lines.push("");
+  lines.push("EXISTING authorizations on the same profile:");
+  request.existingGrants.forEach((g, i) => {
+    lines.push(`  [${i + 1}]`);
+    if (g.scope) lines.push(`    Scope (for context only): ${g.scope}`);
+    lines.push(`    Intent: ${g.intent.trim() || "(empty)"}`);
+  });
+  const messages = [
+    { role: "system", content: INTENT_REVIEW_PROMPT },
+    { role: "user", content: lines.join("\n") }
+  ];
+  try {
+    const review = await callModel(config, messages, { temperature: 0.2, maxTokens: 400, timeoutMs: 45e3 });
+    return { success: true, review, disclaimer };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      disclaimer
+    };
+  }
+}
 async function testAIConnectivity(config) {
   try {
     if (config.provider === "ollama") {
@@ -999,6 +1085,10 @@ async function testAIConnectivity(config) {
 }
 
 // src/routes/ai.ts
+var describeScope = (c = {}) => {
+  const vals = Object.values(c).map((v) => String(v).trim()).filter(Boolean);
+  return vals.length > 0 ? vals.join(", ") : "all (unscoped)";
+};
 function createAIRouter(vault2) {
   const router = Router3();
   function loadAIConfig() {
@@ -1043,6 +1133,46 @@ function createAIRouter(vault2) {
     const result = await getAIChatResponse(config, request);
     res.json(result);
   });
+  router.post("/intent-review", async (req, res) => {
+    const config = loadAIConfig();
+    if (!config) {
+      res.status(400).json({ error: "AI not configured. Save AI settings in Settings > General." });
+      return;
+    }
+    const { profileId, newIntent, context } = req.body;
+    if (!profileId) {
+      res.status(400).json({ error: "Missing profileId" });
+      return;
+    }
+    let existing = [];
+    try {
+      const data = await getEnrichedAuthorizations();
+      existing = (data.authorizations ?? []).filter((a) => a.profileId === profileId && !!a.intent?.trim());
+    } catch {
+      existing = [];
+    }
+    if (existing.length === 0) {
+      res.json({ success: true, review: null, note: "No other authorizations on this profile to compare against." });
+      return;
+    }
+    const result = await getIntentReview(config, {
+      profileName: profileId.split("/").pop() ?? profileId,
+      newIntent: newIntent ?? "",
+      scope: describeScope(context),
+      existingGrants: existing.map((a) => ({
+        intent: a.intent ?? "",
+        scope: describeScope(a.context)
+      }))
+    });
+    res.json({
+      ...result,
+      grants: existing.map((a) => ({
+        scope: describeScope(a.context),
+        intent: a.intent,
+        bounds: a.bounds
+      }))
+    });
+  });
   router.post("/test", async (req, res) => {
     const body = req.body;
     let config;
@@ -1234,6 +1364,7 @@ function createMCPRouter() {
 
 // src/routes/encrypt-intent.ts
 import { Router as Router6 } from "express";
+import { computeIntentDisclosureHash } from "@hap/core";
 function createEncryptIntentRouter() {
   const router = Router6();
   router.post("/", async (req, res) => {
@@ -1279,10 +1410,14 @@ function createEncryptIntentRouter() {
           enc: Buffer.from(wrap.enc).toString("base64")
         };
       }
+      const intentCiphertextB64 = Buffer.from(encrypted.intentCiphertext).toString("base64");
+      const approversFrozen = parsed.map((r) => r.userId);
+      const intentDisclosureHash = computeIntentDisclosureHash(intentCiphertextB64, approversFrozen);
       res.json({
-        intentCiphertext: Buffer.from(encrypted.intentCiphertext).toString("base64"),
+        intentCiphertext: intentCiphertextB64,
         encryptedKeys,
-        approversFrozen: parsed.map((r) => r.userId)
+        approversFrozen,
+        intentDisclosureHash
       });
     } catch (err) {
       console.error("[Control Plane] encrypt-intent error:", err);
@@ -1863,6 +1998,15 @@ app.get("/gate-content", authGuard, async (req, res) => {
     res.status(500).json({ error: "Failed to fetch gate content from MCP server" });
   }
 });
+app.get("/active-authorizations", authGuard, async (_req, res) => {
+  try {
+    const data = await getEnrichedAuthorizations();
+    res.json(data);
+  } catch (err) {
+    console.error("[Control Plane] Authorizations retrieval error:", err);
+    res.status(500).json({ error: "Failed to fetch authorizations from MCP server" });
+  }
+});
 app.post("/gate-content", jsonParser, authGuard, async (req, res) => {
   try {
     const { frameHash, boundsHash, contextHash, context, path, gateContent } = req.body;

package/dist/mcp-server/http.mjs

@@ -182,6 +182,11 @@ var SPClient = class {
 };
 
 // src/lib/attestation-cache.ts
+import { decodeAttestationBlob } from "@hap/core";
+function isCommitmentDowngrade(auth) {
+  const requiresReview = auth.signedCommitmentMode === "review" || auth.signedCommitmentMode === "review_above_cap";
+  return requiresReview && (auth.deferredCommitmentDomains ?? []).length === 0;
+}
 var AttestationCache = class {
   constructor(spClient) {
     this.spClient = spClient;
@@ -226,8 +231,25 @@ var AttestationCache = class {
   async syncAuthorization(frameHash) {
     const result = await this.spClient.getAttestations(frameHash);
     if (!result.profile_id || !result.frame) return null;
+    if (result.revoked) {
+      this.authorizations.delete(frameHash);
+      if (result.frame_hash) this.authorizations.delete(result.frame_hash);
+      return null;
+    }
     const storageHash = result.frame_hash ?? result.bounds_hash;
     const bounds = result.bounds ?? result.frame;
+    let signedCommitmentMode;
+    let subjects;
+    const firstBlob = result.attestations[0]?.blob;
+    if (firstBlob) {
+      try {
+        const payload = decodeAttestationBlob(firstBlob).payload;
+        signedCommitmentMode = payload.commitment_mode;
+        subjects = payload.subjects;
+      } catch {
+        signedCommitmentMode = void 0;
+      }
+    }
     const auth = {
       frameHash: storageHash,
       boundsHash: result.bounds_hash,
@@ -247,9 +269,11 @@ var AttestationCache = class {
       requiredDomains: result.required_domains ?? [],
       attestedDomains: result.attested_domains ?? [],
       deferredCommitmentDomains: result.deferred_commitment_domains ?? [],
+      signedCommitmentMode,
+      subjects,
       complete: result.complete
     };
-    this.authorizations.set(auth.path, auth);
+    this.authorizations.set(auth.frameHash ?? auth.path, auth);
     return auth;
   }
   /**
@@ -278,7 +302,7 @@ var AttestationCache = class {
    * Cache an authorization directly (e.g., from SP response after creation).
    */
   cacheAuthorization(auth) {
-    this.authorizations.set(auth.path, auth);
+    this.authorizations.set(auth.frameHash ?? auth.path, auth);
   }
   /**
    * Remove a cached authorization by path. Called when the SP reports the
@@ -715,7 +739,7 @@ var SharedState = class {
   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;
+      const gateEntry = (auth.frameHash ? this.gateStore.get(auth.frameHash) : null) ?? (auth.boundsHash ? this.gateStore.get(auth.boundsHash) : null) ?? this.gateStore.get(auth.path) ?? null;
       return {
         ...auth,
         gateContent: gateEntry?.gateContent ?? null,
@@ -905,20 +929,23 @@ function buildMandateBrief(opts) {
 import { getProfile as getProfile3 } from "@hap/core";
 
 // src/lib/receipt-footer.ts
+import { deriveIdentityLine } from "@hap/core";
 var AS_BASE = (process.env.SUVEREN_AS_URL ?? "https://www.suveren.ai").replace(/\/$/, "");
+var OPERATOR_NAME = process.env.SUVEREN_OPERATOR_NAME ?? "Suveren";
 var FOOTER_PROFILES = /* @__PURE__ */ new Set(["email", "calendar", "publish"]);
 var CONTENT_FIELD_CANDIDATES = ["body", "text", "description", "content"];
-var FOOTER_MARKER = "\u2014 Sent by an AI agent via Suveren";
+var FOOTER_MARKER = "\u2014 Sent by an AI agent";
 function shouldAttachFooter() {
   return true;
 }
 function verifyUrl(receiptId) {
   return `${AS_BASE}/r/${receiptId}`;
 }
-function footerText(receiptId) {
+function footerText(receiptId, subject) {
+  const line = deriveIdentityLine(subject, { operatorName: OPERATOR_NAME });
   return `
 
-${FOOTER_MARKER}. Verify: ${verifyUrl(receiptId)}`;
+\u2014 ${line}. Verify: ${verifyUrl(receiptId)}`;
 }
 function isStringType(t) {
   return t === "string" || Array.isArray(t) && t.includes("string");
@@ -937,45 +964,34 @@ function stripFooter(value) {
   if (i === -1) return value;
   return value.slice(0, i).replace(/\n+$/, "");
 }
-function appendVerificationFooter(tool, args, receiptId) {
+function appendVerificationFooter(tool, args, receiptId, subject) {
   const profile = tool.gating?.profile;
   if (!profile || !FOOTER_PROFILES.has(profile)) return args;
   const field = detectContentField(tool);
   if (!field) return args;
   const current = typeof args[field] === "string" ? args[field] : "";
-  return { ...args, [field]: stripFooter(current) + footerText(receiptId) };
+  return { ...args, [field]: stripFooter(current) + footerText(receiptId, subject) };
 }
 
 // src/lib/content-binding.ts
-import { createHash } from "crypto";
-import { canonicalize, getProfile as getProfile2 } from "@hap/core";
-function canonicalizeText(input) {
-  const nfc = input.normalize("NFC");
-  const lf = nfc.replace(/\r\n?/g, "\n");
-  const lines = lf.split("\n").map((line) => line.replace(/[ \t]+$/, ""));
-  return lines.join("\n").replace(/\n+$/, "");
-}
-function sha256Hex(bytes) {
-  return createHash("sha256").update(bytes, "utf8").digest("hex");
-}
+import { computeContentHash, getProfile as getProfile2 } from "@hap/core";
 function getContentBinding(profileId) {
-  const profile = getProfile2(profileId);
-  return profile?.content_binding;
+  return getProfile2(profileId)?.content_binding;
 }
 function computeContentBinding(profileId, tool, toolArgs) {
   const binding = getContentBinding(profileId);
   if (!binding) return void 0;
-  let canonicalBytes;
+  let contentHash;
   if (binding.kind === "jcs") {
-    canonicalBytes = canonicalize(toolArgs);
+    contentHash = computeContentHash(binding, toolArgs);
   } else {
     const field = tool ? detectContentField(tool) : null;
     if (!field) return void 0;
     const raw = typeof toolArgs[field] === "string" ? toolArgs[field] : "";
-    canonicalBytes = canonicalizeText(raw);
+    contentHash = computeContentHash(binding, raw);
   }
   return {
-    contentHash: `sha256:${sha256Hex(canonicalBytes)}`,
+    contentHash,
     contentBinding: { version: binding.version, kind: binding.kind }
   };
 }
@@ -1111,7 +1127,7 @@ function createGatedToolHandler(tool, integrationManager2, state2) {
     }
     const errors = [];
     for (const auth of matchingAuths) {
-      const { result } = await state2.gatekeeper.verifyExecution(auth.path, execution, {
+      const { result } = await state2.gatekeeper.verifyExecution(auth.frameHash ?? auth.path, execution, {
         bounds: auth.bounds,
         context: auth.context
       });
@@ -1119,6 +1135,15 @@ function createGatedToolHandler(tool, integrationManager2, state2) {
       }
       if (result.approved) {
         const authHash = auth.frameHash ?? auth.boundsHash;
+        if (isCommitmentDowngrade(auth)) {
+          return {
+            content: [{
+              type: "text",
+              text: `Refusing to execute ${tool.originalName}: the signed authorization requires review (commitment_mode="${auth.signedCommitmentMode}") but the Authority Server returned no pending approvers. This inconsistency (a possible commitment-mode downgrade) is rejected fail-closed. Re-fetch the authorization or contact the Authority Server operator.`
+            }],
+            isError: true
+          };
+        }
         if ((auth.deferredCommitmentDomains ?? []).length > 0) {
           try {
             const enrichedArgs = await attachImagePreview(args);
@@ -1227,7 +1252,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           }
           if (err instanceof SPReceiptError && err.statusCode === 403) {
             if (/revoked/i.test(err.message)) {
-              state2.cache.invalidate(auth.path);
+              state2.cache.invalidate(auth.frameHash ?? auth.path);
             }
             return {
               content: [{ type: "text", text: `Blocked by SP: ${err.message}` }],
@@ -1245,7 +1270,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           execution: { ...execution },
           timestamp: Math.floor(Date.now() / 1e3)
         });
-        let outgoingArgs = shouldAttachFooter() && receiptId ? appendVerificationFooter(tool, args, receiptId) : args;
+        let outgoingArgs = shouldAttachFooter() && receiptId ? appendVerificationFooter(tool, args, receiptId, auth.subjects?.[0]) : args;
         if (receiptId) outgoingArgs = attachReceiptId(tool, outgoingArgs, receiptId);
         return integrationManager2.callTool(tool.integrationId, tool.originalName, outgoingArgs);
       }
@@ -1390,6 +1415,15 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
         output2.push(`[${auth.path}] ${auth.profileId} (${remainingMin} min remaining)${statusLabel}`);
         output2.push("");
         output2.push(`  Bounds: ${boundsDesc}`);
+        const reviewDomains = auth.deferredCommitmentDomains ?? [];
+        output2.push(reviewDomains.length > 0 ? "  Mode: review \u2014 each action requires your approval before it runs (a proposal is created, not executed)" : "  Mode: automatic \u2014 actions run immediately within bounds");
+        try {
+          const meta = await state2.spClient.getFrameMetadata(auth.frameHash ?? auth.boundsHash ?? auth.path);
+          if (meta?.aboveCap) {
+            output2.push("  \u26A0 Above team cap \u2014 actions here require approval even within these bounds.");
+          }
+        } catch {
+        }
         const shortName = shortProfileName2(auth.profileId);
         const profile = getProfile3(auth.profileId) ?? getProfile3(shortName);
         if (profile) {
@@ -1443,6 +1477,9 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
       if (auth.complete) {
         const lines = [`  [${auth.path}] ${auth.profileId} \u2014 ${remainingMin} min remaining`];
         lines.push(`    Bounds: ${boundsDesc}`);
+        if ((auth.deferredCommitmentDomains ?? []).length > 0) {
+          lines.push("    Mode: review (each action requires your approval)");
+        }
         const shortName = shortProfileName2(auth.profileId);
         const profile = getProfile3(auth.profileId) ?? getProfile3(shortName);
         if (profile) {
@@ -1866,18 +1903,17 @@ function createMcpServer(state2, integrationManager2) {
 }
 
 // src/lib/gate-content.ts
-import { createHash as createHash2 } from "crypto";
-import { decodeAttestationBlob } from "@hap/core";
+import { computeIntentHash } from "@hap/core";
+import { decodeAttestationBlob as decodeAttestationBlob2 } from "@hap/core";
 function hashGateContent(text) {
-  const hex = createHash2("sha256").update(text, "utf-8").digest("hex");
-  return `sha256:${hex}`;
+  return computeIntentHash(text);
 }
 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 attestation = decodeAttestationBlob2(auth.attestations[0].blob);
   const expectedHashes = attestation.payload.gate_content_hashes;
   if (!expectedHashes?.intent) {
     return { valid: false, errors: ["Attestation does not contain intent hash"] };
@@ -2477,7 +2513,7 @@ app.post("/internal/gate-content", internalOnly, async (req, res) => {
       res.status(400).json({ error: "Gate content hash mismatch", details: verification.errors });
       return;
     }
-    const path = rawPath || auth.profileId;
+    const path = rawPath || storageHash;
     state.setGateContent(path, storageHash, auth.profileId, gateContent, {
       boundsHash,
       contextHash,
@@ -2537,7 +2573,7 @@ app.post("/internal/resync-gates", internalOnly, async (_req, res) => {
       const syncHash = gate.frameHash ?? gate.boundsHash;
       const auth = await state.cache.syncAuthorization(syncHash);
       if (auth) {
-        state.setGateContent(gate.path, syncHash, auth.profileId, gate.gateContent, {
+        state.setGateContent(syncHash, syncHash, auth.profileId, gate.gateContent, {
           boundsHash: gate.boundsHash,
           contextHash: gate.contextHash,
           context: gate.context
@@ -2545,8 +2581,8 @@ app.post("/internal/resync-gates", internalOnly, async (_req, res) => {
         synced++;
         console.error(`[Suveren MCP] Re-synced gate: ${gate.path}`);
       } else {
-        state.cache.invalidate(gate.path);
-        state.gateStore.delete(gate.path);
+        state.cache.invalidate(syncHash);
+        state.gateStore.delete(syncHash);
         orphaned++;
         console.error(`[Suveren MCP] Orphan gate purged (SP attestation deleted): ${gate.path}`);
       }
@@ -2709,6 +2745,17 @@ app.get("/internal/gate-content", internalOnly, (req, res) => {
     res.json({ entries: gates });
   }
 });
+app.get("/internal/authorizations", internalOnly, (_req, res) => {
+  const authorizations = state.getEnrichedAuthorizations().map((a) => ({
+    profileId: a.profileId,
+    frameHash: a.frameHash,
+    bounds: a.frame,
+    context: a.context ?? {},
+    intent: a.gateContent?.intent ?? null,
+    deferredCommitmentDomains: a.deferredCommitmentDomains ?? []
+  }));
+  res.json({ authorizations });
+});
 app.get("/internal/manifests", internalOnly, (_req, res) => {
   res.json({ manifests: getAllManifests() });
 });
@@ -2782,7 +2829,7 @@ app.listen(port, "0.0.0.0", () => {
   console.error(`[Suveren MCP]   SP server:  ${spUrl}`);
   profilesLoaded = loadProfiles();
   loadManifests();
-  if (integrationRegistry.getEnabled().length === 0) {
+  if (process.env.SUVEREN_DISABLE_AUTO_INTEGRATIONS !== "1" && integrationRegistry.getEnabled().length === 0) {
     const personalManifests = getAllManifests().filter((m) => m.personalDefault);
     for (const manifest of personalManifests) {
       const optionalKeys = new Set(