@suveren/gateway 0.20.2 → 0.22.0

package/dist/mcp-server/http.mjs

@@ -1931,6 +1931,7 @@ import { createHash as createHash2 } from "crypto";
 var DEFAULT_DIR5 = process.env.SUVEREN_DATA_DIR ?? join8(homedir5(), ".suveren");
 var FILE_NAME = "execution-journal.json";
 var MAX_AGE_SECONDS2 = 90 * 24 * 60 * 60;
+var DETAIL_CAP = 500;
 function hashToolArgs(args) {
   return "sha256:" + createHash2("sha256").update(stableStringify(args)).digest("hex");
 }
@@ -1969,15 +1970,30 @@ var ExecutionJournal = class {
     this.persist(file);
     return { ok: true };
   }
-  /** Close an `intent` row. Missing row is a programming error, not a silent no-op. */
-  complete(ticketId, state2) {
+  /**
+   * Close an `intent` row. Missing row is a programming error, not a silent
+   * no-op. `detail` (capped to DETAIL_CAP) is stored only alongside outcome
+   * 'refused' — see JournalEntry's doc comment.
+   */
+  complete(ticketId, state2, outcome, detail) {
     const file = this.load();
     const row = file.entries.find((e) => e.ticketId === ticketId);
     if (!row) throw new Error(`execution journal: no row for ticket ${ticketId} to complete`);
     row.state = state2;
+    if (outcome) row.outcome = outcome;
+    if (detail !== void 0) {
+      row.detail = detail.length > DETAIL_CAP ? detail.slice(0, DETAIL_CAP) : detail;
+    }
     row.finishedAt = nowSec();
     this.persist(file);
   }
+  /** The newest row for a review-path proposal — what really happened when it
+   *  ran on this gateway (the AS marks a proposal "executed" when it issues the
+   *  ticket, before the action runs). Undefined when it never ran here. */
+  findByProposal(proposalId) {
+    const rows = this.load().entries.filter((e) => e.proposalId === proposalId);
+    return rows[rows.length - 1];
+  }
   /** All rows, newest last. Diagnostic. */
   getAll() {
     return [...this.load().entries];
@@ -2037,7 +2053,8 @@ var ProposalSubmissionStore = class {
       executionContextHash: hashToolArgs(entry.executionContext),
       authorizationId: entry.authorizationId,
       profileId: entry.profileId,
-      submittedAt: nowSec2()
+      submittedAt: nowSec2(),
+      ...entry.previewHash ? { previewHash: entry.previewHash } : {}
     });
     this.persist(file);
   }
@@ -2065,6 +2082,56 @@ var ProposalSubmissionStore = class {
   }
 };
 
+// src/lib/preview-log.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync10, renameSync as renameSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname8, join as join10 } from "path";
+var DEFAULT_DIR7 = process.env.SUVEREN_DATA_DIR ?? join10(homedir7(), ".suveren");
+var FILE_NAME3 = "preview-log.json";
+var MAX_RECORDS2 = 500;
+var MAX_AGE_MS2 = 30 * 24 * 60 * 60 * 1e3;
+var PreviewLog = class {
+  filePath;
+  constructor(filePath) {
+    const baseDir = filePath && filePath.endsWith(".json") ? dirname8(filePath) : filePath ?? DEFAULT_DIR7;
+    this.filePath = join10(baseDir, FILE_NAME3);
+  }
+  /** Record one preview read. Never throws — recording must not break the read. */
+  record(entry) {
+    try {
+      const file = this.load();
+      file.entries.push(entry);
+      const cutoff = entry.ts - MAX_AGE_MS2;
+      file.entries = file.entries.filter((e) => e.ts >= cutoff);
+      if (file.entries.length > MAX_RECORDS2) {
+        file.entries = file.entries.slice(file.entries.length - MAX_RECORDS2);
+      }
+      this.persist(file);
+    } catch (err) {
+      console.error("[PreviewLog] failed to record preview read:", err);
+    }
+  }
+  /** Diagnostic only. */
+  getAll() {
+    return [...this.load().entries];
+  }
+  load() {
+    if (!existsSync10(this.filePath)) return { version: 1, entries: [] };
+    try {
+      const parsed = JSON.parse(readFileSync11(this.filePath, "utf-8"));
+      return { version: 1, entries: parsed.entries ?? [] };
+    } catch {
+      return { version: 1, entries: [] };
+    }
+  }
+  persist(file) {
+    mkdirSync8(dirname8(this.filePath), { recursive: true, mode: 448 });
+    const tmp = `${this.filePath}.tmp`;
+    writeFileSync8(tmp, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
+    renameSync3(tmp, this.filePath);
+  }
+};
+
 // src/lib/gatekeeper.ts
 import { verify } from "@hap/core";
 var MCPGatekeeper = class {
@@ -2157,9 +2224,9 @@ var MCPGatekeeper = class {
 };
 
 // src/lib/report/report-store.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync10, unlinkSync as unlinkSync5 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname8, join as join10 } from "path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync11, unlinkSync as unlinkSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname9, join as join11 } from "path";
 import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes5 } from "crypto";
 
 // src/lib/report/record-resolvers.ts
@@ -2468,27 +2535,27 @@ async function buildCoverage(caseElements, getExport, archive, referenced, windo
 }
 
 // src/lib/report/report-store.ts
-var DEFAULT_DIR7 = process.env.SUVEREN_DATA_DIR ?? join10(homedir7(), ".suveren");
+var DEFAULT_DIR8 = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".suveren");
 var ReportStore = class {
   report = null;
   baseDir;
   vaultKey = null;
   constructor(filePath) {
     if (filePath && filePath.endsWith(".json")) {
-      this.baseDir = dirname8(filePath);
+      this.baseDir = dirname9(filePath);
     } else {
-      this.baseDir = filePath ?? DEFAULT_DIR7;
+      this.baseDir = filePath ?? DEFAULT_DIR8;
     }
     this.loadPlaintext();
   }
   /** Set the vault key for encryption. Triggers migration from plaintext if needed. */
   setVaultKey(key) {
     this.vaultKey = key;
-    if (existsSync10(this.encryptedFilePath)) {
+    if (existsSync11(this.encryptedFilePath)) {
       this.loadEncrypted();
     } else if (this.report !== null) {
       this.persistEncrypted();
-      if (existsSync10(this.plaintextFilePath)) {
+      if (existsSync11(this.plaintextFilePath)) {
         try {
           unlinkSync5(this.plaintextFilePath);
         } catch {
@@ -2503,7 +2570,7 @@ var ReportStore = class {
    * "the report exists but is locked".
    */
   isLocked() {
-    return this.vaultKey === null && existsSync10(this.encryptedFilePath);
+    return this.vaultKey === null && existsSync11(this.encryptedFilePath);
   }
   /** The stored, already-verified report — or null if none has been saved
    *  (and the store is not locked; check `isLocked()` first). */
@@ -2552,34 +2619,34 @@ var ReportStore = class {
   }
   // ─── File paths ─────────────────────────────────────────────────────────
   get plaintextFilePath() {
-    return join10(this.baseDir, "report.json");
+    return join11(this.baseDir, "report.json");
   }
   get encryptedFilePath() {
-    return join10(this.baseDir, "report.enc.json");
+    return join11(this.baseDir, "report.enc.json");
   }
   // ─── Load / Persist ─────────────────────────────────────────────────────
   loadPlaintext() {
-    if (!existsSync10(this.plaintextFilePath)) {
-      mkdirSync8(this.baseDir, { recursive: true });
+    if (!existsSync11(this.plaintextFilePath)) {
+      mkdirSync9(this.baseDir, { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync11(this.plaintextFilePath, "utf-8");
+      const raw = readFileSync12(this.plaintextFilePath, "utf-8");
       const parsed = JSON.parse(raw);
       this.report = parsed.report ?? null;
     } catch {
       console.error(`[ReportStore] Could not parse ${this.plaintextFilePath} \u2014 preserving as .corrupt`);
       try {
-        writeFileSync8(`${this.plaintextFilePath}.corrupt-${Date.now()}`, readFileSync11(this.plaintextFilePath));
+        writeFileSync9(`${this.plaintextFilePath}.corrupt-${Date.now()}`, readFileSync12(this.plaintextFilePath));
       } catch {
       }
       this.report = null;
     }
   }
   loadEncrypted() {
-    if (!existsSync10(this.encryptedFilePath)) return;
+    if (!existsSync11(this.encryptedFilePath)) return;
     try {
-      const raw = readFileSync11(this.encryptedFilePath, "utf-8");
+      const raw = readFileSync12(this.encryptedFilePath, "utf-8");
       const data = JSON.parse(raw);
       const decrypted = this.decrypt(data.blob);
       const parsed = JSON.parse(decrypted);
@@ -2587,7 +2654,7 @@ var ReportStore = class {
     } catch (err) {
       console.error(`[ReportStore] Could not decrypt ${this.encryptedFilePath} \u2014 preserving as .corrupt:`, err);
       try {
-        writeFileSync8(`${this.encryptedFilePath}.corrupt-${Date.now()}`, readFileSync11(this.encryptedFilePath));
+        writeFileSync9(`${this.encryptedFilePath}.corrupt-${Date.now()}`, readFileSync12(this.encryptedFilePath));
       } catch {
       }
       this.report = null;
@@ -2602,16 +2669,16 @@ var ReportStore = class {
   }
   persistPlaintext() {
     const data = { version: 1, report: this.report };
-    mkdirSync8(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync8(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync9(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync9(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   }
   persistEncrypted() {
     const data = {
       version: 1,
       blob: this.encrypt(JSON.stringify({ version: 1, report: this.report }))
     };
-    mkdirSync8(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync8(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync9(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync9(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   }
 };
 
@@ -2632,6 +2699,8 @@ var SharedState = class {
   /** What THIS gateway submitted for each review-mode proposal it created —
    *  see ticket-verify.ts / commitments.ts. */
   proposalSubmissions;
+  /** AU3 — local, content-free record of preview reads. See preview-log.ts. */
+  previewLog;
   gatekeeper;
   /**
    * V7 — set by {@link checkAsCompat} (called once at process start, and
@@ -2665,6 +2734,7 @@ var SharedState = class {
     this.reportStore = new ReportStore(gateStorePath);
     this.executionJournal = new ExecutionJournal(gateStorePath);
     this.proposalSubmissions = new ProposalSubmissionStore(gateStorePath);
+    this.previewLog = new PreviewLog(gateStorePath);
     this.gatekeeper = new MCPGatekeeper(this.cache);
   }
   /**
@@ -2853,29 +2923,29 @@ function formatConsumptionFull(entries) {
 }
 
 // src/lib/context-loader.ts
-import { readFileSync as readFileSync12, existsSync as existsSync11, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, renameSync as renameSync3 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join11, dirname as dirname9 } from "path";
-var DEFAULT_DIR8 = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".suveren");
+import { readFileSync as readFileSync13, existsSync as existsSync12, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, renameSync as renameSync4 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join12, dirname as dirname10 } from "path";
+var DEFAULT_DIR9 = process.env.SUVEREN_DATA_DIR ?? join12(homedir9(), ".suveren");
 var CONTEXT_MAX_BYTES = 16 * 1024;
 function contextFilePath(dataDir2) {
-  return join11(dataDir2 ?? DEFAULT_DIR8, "context.md");
+  return join12(dataDir2 ?? DEFAULT_DIR9, "context.md");
 }
 function writeContextFile(content, dataDir2) {
   const bytes = Buffer.byteLength(content, "utf-8");
   if (bytes > CONTEXT_MAX_BYTES) throw new Error(`the brief is ${bytes} bytes; the limit is ${CONTEXT_MAX_BYTES}.`);
   const filePath = contextFilePath(dataDir2);
-  mkdirSync9(dirname9(filePath), { recursive: true });
+  mkdirSync10(dirname10(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp`;
-  writeFileSync9(tmpPath, content, "utf-8");
-  renameSync3(tmpPath, filePath);
+  writeFileSync10(tmpPath, content, "utf-8");
+  renameSync4(tmpPath, filePath);
 }
 var BRIEF_MAX_CHARS = 16 * 1024;
 function readContextFile(dataDir2) {
   const filePath = contextFilePath(dataDir2);
-  if (!existsSync11(filePath)) return null;
+  if (!existsSync12(filePath)) return null;
   try {
-    const content = readFileSync12(filePath, "utf-8").trim();
+    const content = readFileSync13(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -3061,6 +3131,252 @@ function attachTicketId(tool, args, ticketId) {
   return { ...args, ticket_id: ticketId };
 }
 
+// src/lib/preview.ts
+import { computeContentHash as computeContentHash2 } from "@hap/core";
+
+// src/lib/manifest-loader.ts
+import { readFileSync as readFileSync14, existsSync as existsSync13 } from "fs";
+import { join as join13, resolve } from "path";
+var EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function isExactSemver(value) {
+  return typeof value === "string" && EXACT_SEMVER_RE.test(value);
+}
+function invalidNpmPinReason(manifest) {
+  if (!manifest.npmPackage) return null;
+  if (manifest.npmVersion === void 0) {
+    return `npmPackage "${manifest.npmPackage}" is set but npmVersion is missing \u2014 every connector manifest must pin an exact tested version`;
+  }
+  if (!isExactSemver(manifest.npmVersion)) {
+    return `npmVersion ${JSON.stringify(manifest.npmVersion)} for "${manifest.npmPackage}" is not an exact semver (e.g. "1.2.3") \u2014 ranges, dist-tags like "latest", git specs, URLs, and file paths are not allowed`;
+  }
+  return null;
+}
+function invalidPreviewReason(toolName, entry) {
+  if (entry === null || typeof entry !== "object") return null;
+  const preview = entry.preview;
+  if (preview === void 0) return null;
+  if (preview === null || typeof preview !== "object" || Array.isArray(preview)) {
+    return `override "${toolName}".preview must be an object`;
+  }
+  const p = preview;
+  if (typeof p.tool !== "string" || p.tool.length === 0) {
+    return `override "${toolName}".preview.tool must be a non-empty string`;
+  }
+  if (p.args === void 0 || p.args === null || typeof p.args !== "object" || Array.isArray(p.args)) {
+    return `override "${toolName}".preview.args must be an object mapping preview-tool arg names to action arg names`;
+  }
+  for (const [argName, source] of Object.entries(p.args)) {
+    if (typeof source !== "string" || source.length === 0) {
+      return `override "${toolName}".preview.args.${argName} must name a non-empty source argument (string)`;
+    }
+  }
+  if (p.version !== void 0) {
+    if (p.version === null || typeof p.version !== "object" || Array.isArray(p.version)) {
+      return `override "${toolName}".preview.version must be an object`;
+    }
+    const v = p.version;
+    if (typeof v.arg !== "string" || v.arg.length === 0) {
+      return `override "${toolName}".preview.version.arg must be a non-empty string`;
+    }
+    if (typeof v.field !== "string" || v.field.length === 0) {
+      return `override "${toolName}".preview.version.field must be a non-empty string`;
+    }
+  }
+  if (p.fields !== void 0) {
+    if (!Array.isArray(p.fields)) {
+      return `override "${toolName}".preview.fields must be an array of field names`;
+    }
+    for (const [i, f] of p.fields.entries()) {
+      if (typeof f !== "string" || f.length === 0) {
+        return `override "${toolName}".preview.fields[${i}] must be a non-empty string`;
+      }
+    }
+  }
+  return null;
+}
+function invalidManifestPreviewReason(manifest) {
+  const overrides = manifest.toolGating?.overrides ?? {};
+  for (const [toolName, entry] of Object.entries(overrides)) {
+    const reason = invalidPreviewReason(toolName, entry);
+    if (reason) return reason;
+  }
+  return null;
+}
+var manifests = /* @__PURE__ */ new Map();
+function loadManifests(integrationsDir) {
+  const dir = resolve(
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join13(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+  );
+  const indexPath = join13(dir, "index.json");
+  if (!existsSync13(indexPath)) {
+    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
+    return 0;
+  }
+  let index;
+  try {
+    index = JSON.parse(readFileSync14(indexPath, "utf-8"));
+  } catch (err) {
+    console.error(`[ManifestLoader] Failed to parse ${indexPath}:`, err);
+    return 0;
+  }
+  let loaded = 0;
+  for (const [id, relativePath] of Object.entries(index.integrations)) {
+    const manifestPath = join13(dir, relativePath);
+    try {
+      const manifest = JSON.parse(readFileSync14(manifestPath, "utf-8"));
+      const pinReason = invalidNpmPinReason(manifest);
+      if (pinReason) {
+        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${pinReason}`);
+        continue;
+      }
+      const previewReason = invalidManifestPreviewReason(manifest);
+      if (previewReason) {
+        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${previewReason}`);
+        continue;
+      }
+      manifests.set(id, manifest);
+      loaded++;
+    } catch (err) {
+      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
+    }
+  }
+  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
+  return loaded;
+}
+function getManifest(id) {
+  return manifests.get(id);
+}
+function getAllManifests() {
+  return Array.from(manifests.values());
+}
+
+// src/lib/preview.ts
+var PREVIEW_READ_TIMEOUT_MS = 5e3;
+var PREVIEW_MESSAGE_CAP = 500;
+function capText(text, max = PREVIEW_MESSAGE_CAP) {
+  if (text === void 0) return void 0;
+  return text.length > max ? text.slice(0, max) : text;
+}
+function getToolPreviewConfig(integrationId, toolName) {
+  const manifest = getManifest(integrationId);
+  const overrides = manifest?.toolGating?.overrides ?? {};
+  const entry = overrides[toolName];
+  return entry?.preview;
+}
+function mapPreviewArgs(preview, actionArgs) {
+  const mapped = {};
+  for (const [targetArg, sourceArg] of Object.entries(preview.args)) {
+    if (sourceArg in actionArgs) mapped[targetArg] = actionArgs[sourceArg];
+  }
+  return mapped;
+}
+var PreviewTimeoutError = class extends Error {
+};
+function withTimeout(p, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new PreviewTimeoutError("preview read timed out")), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+}
+async function readPreview(integrationManager2, integrationId, previewTool, args) {
+  const discovered = integrationManager2.getAllTools().find((t) => t.integrationId === integrationId && t.originalName === previewTool);
+  if (!discovered) {
+    return { status: "unavailable", reason: "no_connector" };
+  }
+  try {
+    const result = await withTimeout(
+      integrationManager2.callTool(integrationId, previewTool, args),
+      PREVIEW_READ_TIMEOUT_MS
+    );
+    const text = result.content?.[0]?.text;
+    if (result.isError) {
+      return { status: "not_found", message: capText(text) };
+    }
+    return {
+      status: "ok",
+      body: {
+        ...result.structuredContent !== void 0 ? { structured: result.structuredContent } : {},
+        ...discovered.outputSchema ? { outputSchema: discovered.outputSchema } : {},
+        ...text !== void 0 ? { text } : {}
+      }
+    };
+  } catch (err) {
+    if (err instanceof PreviewTimeoutError) {
+      return { status: "unavailable", reason: "timeout" };
+    }
+    return {
+      status: "unavailable",
+      reason: "connector_error",
+      message: capText(err instanceof Error ? err.message : String(err))
+    };
+  }
+}
+function hashPreviewBody(body) {
+  if (body.structured !== void 0) {
+    return computeContentHash2({ kind: "jcs", version: "1" }, body.structured);
+  }
+  return computeContentHash2({ kind: "text", version: "1" }, body.text ?? "");
+}
+async function computeSubmissionPreviewHash(integrationManager2, integrationId, toolName, actionArgs) {
+  const preview = getToolPreviewConfig(integrationId, toolName);
+  if (!preview || preview.version) return void 0;
+  const mapped = mapPreviewArgs(preview, actionArgs);
+  const read = await readPreview(integrationManager2, integrationId, preview.tool, mapped);
+  if (read.status !== "ok") return void 0;
+  return hashPreviewBody(read.body);
+}
+async function previewChangedSinceSubmission(integrationManager2, integrationId, toolName, actionArgs, previousHash) {
+  const preview = getToolPreviewConfig(integrationId, toolName);
+  if (!preview) return true;
+  const mapped = mapPreviewArgs(preview, actionArgs);
+  const read = await readPreview(integrationManager2, integrationId, preview.tool, mapped);
+  if (read.status !== "ok") return true;
+  return hashPreviewBody(read.body) !== previousHash;
+}
+async function buildInternalPreview(integrationManager2, integrationId, toolName, actionArgs) {
+  const preview = getToolPreviewConfig(integrationId, toolName);
+  if (!preview) return { status: "none" };
+  const mappedArgs = mapPreviewArgs(preview, actionArgs);
+  const read1 = await readPreview(integrationManager2, integrationId, preview.tool, mappedArgs);
+  if (read1.status !== "ok") return read1;
+  const ok = (extra = {}) => ({
+    status: "ok",
+    integration: integrationId,
+    tool: preview.tool,
+    body: read1.body,
+    ...preview.fields ? { fields: preview.fields } : {},
+    ...extra
+  });
+  if (!preview.version) {
+    return ok();
+  }
+  const approved = actionArgs[preview.version.arg];
+  if (typeof approved !== "string" && typeof approved !== "number") {
+    return ok();
+  }
+  const { [preview.version.arg]: _omit, ...withoutVersion } = actionArgs;
+  const mappedCurrentArgs = mapPreviewArgs(preview, withoutVersion);
+  const read2 = await readPreview(integrationManager2, integrationId, preview.tool, mappedCurrentArgs);
+  if (read2.status !== "ok" || read2.body.structured === void 0) {
+    return ok();
+  }
+  const current = read2.body.structured[preview.version.field];
+  if (typeof current !== "string" && typeof current !== "number") {
+    return ok();
+  }
+  const stale = String(current) !== String(approved);
+  return ok({
+    version: {
+      field: preview.version.field,
+      approved,
+      current,
+      stale,
+      ...stale ? { currentBody: read2.body } : {}
+    }
+  });
+}
+
 // src/lib/ticket-verify.ts
 import { verifyTicketSignature } from "@hap/core";
 var TicketBindingMismatchError = class extends Error {
@@ -3563,6 +3879,7 @@ function denyRead(state2, tool, reason, detail, target) {
       tool: tool.originalName,
       integrationId: tool.integrationId,
       profile: tool.gating?.profile ?? null,
+      kind: "read",
       reason,
       detail,
       target
@@ -3571,15 +3888,62 @@ function denyRead(state2, tool, reason, detail, target) {
   }
   return { content: [{ type: "text", text: `Read blocked by Gatekeeper: ${detail}` }], isError: true };
 }
+function recordBlocked(state2, tool, rec) {
+  state2.denialLog?.record({
+    ts: Date.now(),
+    tool: tool.originalName,
+    integrationId: tool.integrationId,
+    profile: tool.gating?.profile ?? null,
+    ...rec
+  });
+}
+function recordGatekeeperRefusal(state2, tool, refusals) {
+  if (refusals.length === 0) return;
+  const pick = refusals.find((r) => r.bound !== void 0 && r.actual !== void 0) ?? refusals[0];
+  const scoped = pick.field ? Boolean(getProfile2(pick.profileId)?.scopeSchema?.fields?.[pick.field]) : false;
+  const asValueOrString = (v) => typeof v === "number" || typeof v === "string" ? v : void 0;
+  recordBlocked(state2, tool, {
+    kind: scoped ? "scope" : "bound",
+    detail: "Refused locally by the Gatekeeper.",
+    mandateId: pick.authorizationId,
+    field: pick.field,
+    value: asValueOrString(pick.actual),
+    limit: asValueOrString(pick.bound),
+    who: "gateway",
+    code: pick.code
+  });
+}
+function recordAsRefusal(state2, tool, authorizationId, err) {
+  const code = typeof err?.code === "string" ? err.code : void 0;
+  const asValueOrString = (v) => typeof v === "number" || typeof v === "string" ? v : void 0;
+  recordBlocked(state2, tool, {
+    kind: code === "CUMULATIVE_LIMIT_EXCEEDED" ? "cumulative" : code === "BOUND_EXCEEDED" ? "bound" : "not_authorized",
+    detail: "Refused by the Authority Server.",
+    mandateId: authorizationId,
+    field: typeof err?.field === "string" ? err.field : void 0,
+    value: asValueOrString(err?.actual),
+    limit: asValueOrString(err?.expected),
+    who: "authority-server",
+    code
+  });
+}
 function createGatedToolHandler(tool, integrationManager2, state2) {
   if (isSimulationMode() && !integrationManager2.isSimulationSafe(tool.integrationId)) {
-    return async () => ({
-      content: [{
-        type: "text",
-        text: `Refused: "${tool.namespacedName}" is not available. No ticket was requested.`
-      }],
-      isError: true
-    });
+    return async () => {
+      recordBlocked(state2, tool, {
+        kind: "simulation",
+        detail: "Real systems are blocked while simulation mode is on.",
+        who: "gateway",
+        code: "SIMULATION_MODE"
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Refused: "${tool.namespacedName}" is not available. No ticket was requested.`
+        }],
+        isError: true
+      };
+    };
   }
   const gated = createGatedToolHandlerInner(tool, integrationManager2, state2);
   const gateable = !!tool.gating?.profile && tool.gating.category !== "disabled";
@@ -3642,6 +4006,15 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
   };
   const noEligibleMandate = (refusals) => {
     const reasons = [...new Set(refusals)].join(" ");
+    recordBlocked(state2, tool, {
+      kind: "not_authorized",
+      // Fixed text only: `reasons` can name resources or correspondents (read
+      // refusals), and a blocked-action record carries no content.
+      detail: `No active authorization matching profile "${profile}".`,
+      field: profile,
+      who: "gateway",
+      code: "NO_MATCHING_MANDATE"
+    });
     return {
       content: [{
         type: "text",
@@ -3847,6 +4220,13 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
     }
     const declaredActionType = typeof execution.action_type === "string" && execution.action_type.length > 0 ? execution.action_type : void 0;
     if (!declaredActionType) {
+      recordBlocked(state2, tool, {
+        kind: "bound",
+        detail: `${tool.namespacedName} declares no action_type in its manifest's staticExecution.`,
+        field: "action_type",
+        who: "gateway",
+        code: "MISSING_ACTION_TYPE"
+      });
       return {
         content: [{
           type: "text",
@@ -3859,6 +4239,14 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       const profileDef = getProfile2(profile);
       const registry = profileDef?.boundsSchema?.actionTypes;
       if (Array.isArray(registry) && registry.length > 0 && !registry.includes(declaredActionType)) {
+        recordBlocked(state2, tool, {
+          kind: "bound",
+          detail: `action_type "${declaredActionType}" is not in profile ${profile}'s actionTypes registry.`,
+          field: "action_type",
+          value: declaredActionType,
+          who: "gateway",
+          code: "INVALID_ACTION_TYPE"
+        });
         return {
           content: [{
             type: "text",
@@ -3872,6 +4260,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
     if (matchingAuths.length === 0) return noEligibleMandate(refusals);
     const errors = [];
     const passers = [];
+    const structuredRefusals = [];
     for (const candidate of matchingAuths) {
       const { result } = await state2.gatekeeper.verifyExecution(candidate.authorizationId, execution, {
         bounds: candidate.bounds,
@@ -3880,6 +4269,13 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       const capped = result.approved ? zeroCappedBound(candidate.profileId, candidate.bounds ?? candidate.frame, typeof execution.action_type === "string" ? execution.action_type : void 0) : null;
       if (result.approved && capped) {
         errors.push(`${candidate.path}: ${capped} is 0 \u2014 this mandate does not allow "${execution.action_type}"`);
+        structuredRefusals.push({
+          authorizationId: candidate.authorizationId,
+          profileId: candidate.profileId,
+          code: "BOUND_EXCEEDED",
+          field: typeof execution.action_type === "string" ? execution.action_type : void 0,
+          bound: 0
+        });
       } else if (result.approved) {
         passers.push(candidate);
       } else {
@@ -3890,9 +4286,20 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
           return `${candidate.path}: ${e.message}`;
         });
         errors.push(...reasons);
+        for (const e of result.errors) {
+          structuredRefusals.push({
+            authorizationId: candidate.authorizationId,
+            profileId: candidate.profileId,
+            code: e.code,
+            field: e.field,
+            bound: e.bound,
+            actual: e.actual
+          });
+        }
       }
     }
     if (passers.length === 0) {
+      recordGatekeeperRefusal(state2, tool, structuredRefusals);
       return {
         content: [{
           type: "text",
@@ -3943,13 +4350,20 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
             toolArgs: enrichedArgs,
             executionContext: wireExecCtx
           });
+          const previewHash = await computeSubmissionPreviewHash(
+            integrationManager2,
+            tool.integrationId,
+            tool.originalName,
+            enrichedArgs
+          );
           state2.proposalSubmissions.record({
             proposalId: proposal.id,
             tool: tool.namespacedName,
             toolArgs: enrichedArgs,
             executionContext: wireExecCtx,
             authorizationId: authzId,
-            profileId: auth.profileId
+            profileId: auth.profileId,
+            previewHash
           });
           return {
             content: [{
@@ -4044,6 +4458,7 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
           state2.cache.markNeedsReapproval(auth.authorizationId);
           const remaining = candidates.filter((c) => c.authorizationId !== auth.authorizationId);
           if (remaining.length === 0) {
+            recordAsRefusal(state2, tool, auth.authorizationId, { code: "VERSION_UNSUPPORTED" });
             return {
               content: [{
                 type: "text",
@@ -4059,9 +4474,11 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
         }
         if (err instanceof SPReceiptError && isStaleMandateRefusal(err)) {
           state2.cache.invalidate(auth.authorizationId);
-          const code = err.body?.errors?.[0]?.code ?? "unknown";
+          const staleErr = err.body?.errors?.[0];
+          const code = staleErr?.code ?? "unknown";
           const remaining = candidates.filter((c) => c.authorizationId !== auth.authorizationId);
           if (remaining.length === 0) {
+            recordAsRefusal(state2, tool, auth.authorizationId, staleErr);
             console.error(
               `[Suveren MCP] fallback(${tool.namespacedName}): mandate ${auth.authorizationId} invalid (${code}) \u2014 no remaining candidates`
             );
@@ -4112,13 +4529,20 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
               executionContext: wireExecCtx,
               pendingApprovers: uniqueApprovers
             });
+            const previewHash = await computeSubmissionPreviewHash(
+              integrationManager2,
+              tool.integrationId,
+              tool.originalName,
+              enrichedArgs
+            );
             state2.proposalSubmissions.record({
               proposalId: proposal.id,
               tool: tool.namespacedName,
               toolArgs: enrichedArgs,
               executionContext: wireExecCtx,
               authorizationId: authzId,
-              profileId: auth.profileId
+              profileId: auth.profileId,
+              previewHash
             });
             return {
               content: [{
@@ -4141,6 +4565,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           }
         }
         if (err instanceof SPReceiptError && err.statusCode === 422) {
+          recordAsRefusal(state2, tool, auth.authorizationId, err.body?.errors?.[0]);
           return {
             content: [{ type: "text", text: `Action blocked: ${err.message} (hard team ceiling \u2014 contact the team admin)` }],
             isError: true
@@ -4151,6 +4576,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           if (errors403?.[0]?.code === "MANDATE_REVOKED") {
             state2.cache.invalidate(auth.authorizationId);
           }
+          recordAsRefusal(state2, tool, auth.authorizationId, errors403?.[0]);
           return {
             content: [{ type: "text", text: `Blocked by SP: ${err.message}` }],
             isError: true
@@ -4798,6 +5224,8 @@ async function executeCommitted(proposal, state2, integrationManager2) {
     if (err instanceof SPReceiptError) {
       const code = err.body.errors?.[0]?.code;
       if (code === "PROPOSAL_ALREADY_EXECUTED") {
+        const local = localOutcomeOfExecuted(proposal, state2);
+        if (local) return local;
         return {
           text: `Proposal ${proposal.id} has already been executed by another request.`
         };
@@ -4849,6 +5277,22 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       `[Suveren MCP] Proposal ${proposal.id}: ticket ${receiptId} was replayed by the AS with no local execution record \u2014 executing once (lost-response recovery).`
     );
   }
+  if (submitted.previewHash) {
+    const changed = await previewChangedSinceSubmission(
+      integrationManager2,
+      integrationId,
+      toolName,
+      proposal.toolArgs,
+      submitted.previewHash
+    );
+    if (changed) {
+      state2.executionJournal.complete(receiptId, "failed", "changed");
+      return {
+        text: `Proposal ${proposal.id} was approved, but the record changed in ${integrationId} since it was requested \u2014 nothing was done. A new attempt needs a new request and approval.`,
+        isError: true
+      };
+    }
+  }
   try {
     let outgoingArgs = proposal.toolArgs;
     if (discovered && receiptId) {
@@ -4865,6 +5309,15 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       state2.executionJournal.complete(receiptId, "failed");
       throw err;
     }
+    const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
+    if (result.isError) {
+      state2.executionJournal.complete(receiptId, "failed", "refused", resultText);
+      return {
+        text: `Proposal ${proposal.id} was approved, but ${integrationId} refused to run it \u2014 nothing was done.
+Reason: ${resultText}`,
+        isError: true
+      };
+    }
     state2.executionJournal.complete(receiptId, "done");
     state2.executionLog.record({
       profileId: proposal.profileId,
@@ -4872,7 +5325,6 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       execution: proposal.executionContext,
       timestamp: Math.floor(Date.now() / 1e3)
     });
-    const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
     return { text: `Proposal ${proposal.id} committed and executed.
 Result: ${resultText}` };
   } catch (err) {
@@ -4883,6 +5335,21 @@ Result: ${resultText}` };
     };
   }
 }
+function localOutcomeOfExecuted(proposal, state2) {
+  const entry = state2.executionJournal?.findByProposal?.(proposal.id);
+  if (!entry || entry.state === "done") return null;
+  const integration = proposal.tool.split("__")[0];
+  if (entry.state === "failed") {
+    return {
+      text: entry.outcome === "refused" ? `Proposal ${proposal.id} was approved, but ${integration} refused to run it \u2014 nothing was done. Do not call the tool again with the same values; a new attempt needs a new request and approval.` : entry.outcome === "changed" ? `Proposal ${proposal.id} was approved, but the record changed in ${integration} since it was requested \u2014 nothing was done. A new attempt needs a new request and approval.` : `Proposal ${proposal.id} was approved, but running it failed \u2014 whether anything happened in ${integration} is unknown. Check ${integration} before trying again; a new attempt needs a new request and approval.`,
+      isError: true
+    };
+  }
+  return {
+    text: `Proposal ${proposal.id} was approved and started running; the outcome is not known yet. Do not call the tool again.`,
+    isError: false
+  };
+}
 function checkPendingCommitmentsHandler(state2, integrationManager2) {
   return async (args) => {
     if (!state2.spClient.isUnlocked()) {
@@ -4907,6 +5374,13 @@ function checkPendingCommitmentsHandler(state2, integrationManager2) {
           };
         }
         if (match.status === "executed") {
+          const local = localOutcomeOfExecuted(match, state2);
+          if (local) {
+            return {
+              content: [{ type: "text", text: local.text }],
+              ...local.isError ? { isError: true } : {}
+            };
+          }
           const result = match.executionResult ? `
 Result: ${JSON.stringify(match.executionResult, null, 2)}` : " The action ran; the gateway did not retain its output.";
           return {
@@ -5172,21 +5646,21 @@ function createMcpServer(state2, integrationManager2) {
 }
 
 // src/lib/agent-contact.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync10, readFileSync as readFileSync13, renameSync as renameSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname10, join as join12 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync15, renameSync as renameSync5, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname11, join as join14 } from "path";
 var FILE = "agent-contact.json";
 var REWRITE_AFTER_MS = 6e4;
 var AgentContactStore = class {
   path;
   current;
   constructor(dataDir2) {
-    this.path = join12(dataDir2, FILE);
+    this.path = join14(dataDir2, FILE);
     this.current = this.load();
   }
   load() {
-    if (!existsSync12(this.path)) return null;
+    if (!existsSync14(this.path)) return null;
     try {
-      const v = JSON.parse(readFileSync13(this.path, "utf8"));
+      const v = JSON.parse(readFileSync15(this.path, "utf8"));
       if (typeof v.clientName !== "string" || typeof v.firstSeenAt !== "string" || typeof v.lastSeenAt !== "string") return null;
       return { clientName: v.clientName, clientVersion: v.clientVersion, firstSeenAt: v.firstSeenAt, lastSeenAt: v.lastSeenAt };
     } catch {
@@ -5209,10 +5683,10 @@ var AgentContactStore = class {
     };
     if (!due) return;
     try {
-      mkdirSync10(dirname10(this.path), { recursive: true });
+      mkdirSync11(dirname11(this.path), { recursive: true });
       const tmp = `${this.path}.tmp`;
-      writeFileSync10(tmp, JSON.stringify(this.current, null, 2));
-      renameSync4(tmp, this.path);
+      writeFileSync11(tmp, JSON.stringify(this.current, null, 2));
+      renameSync5(tmp, this.path);
     } catch (err) {
       console.error("[Suveren MCP] Could not save agent contact:", err);
     }
@@ -5246,16 +5720,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname11, join as join13 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join13(homedir9(), ".suveren");
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync15 } from "fs";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname12, join as join15 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join15(homedir10(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir2) {
     const dir = dataDir2 ?? DEFAULT_DATA_DIR;
-    this.filePath = join13(dir, "integrations.json");
+    this.filePath = join15(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -5286,12 +5760,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync13(this.filePath)) {
-      mkdirSync11(dirname11(this.filePath), { recursive: true });
+    if (!existsSync15(this.filePath)) {
+      mkdirSync12(dirname12(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync14(this.filePath, "utf-8");
+      const raw = readFileSync16(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -5320,79 +5794,19 @@ var IntegrationRegistry = class {
       version: 1,
       integrations: Array.from(this.integrations.values())
     };
-    mkdirSync11(dirname11(this.filePath), { recursive: true });
-    writeFileSync11(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+    mkdirSync12(dirname12(this.filePath), { recursive: true });
+    writeFileSync12(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
   }
 };
 
 // src/lib/integration-manager.ts
-import { homedir as homedir10 } from "os";
-import { join as join15, delimiter } from "path";
-import { existsSync as existsSync15, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, readFileSync as readFileSync16, rmSync } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join16, delimiter } from "path";
+import { existsSync as existsSync16, writeFileSync as writeFileSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync17, rmSync } from "fs";
 import { execFile } from "child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
-// src/lib/manifest-loader.ts
-import { readFileSync as readFileSync15, existsSync as existsSync14 } from "fs";
-import { join as join14, resolve } from "path";
-var EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
-function isExactSemver(value) {
-  return typeof value === "string" && EXACT_SEMVER_RE.test(value);
-}
-function invalidNpmPinReason(manifest) {
-  if (!manifest.npmPackage) return null;
-  if (manifest.npmVersion === void 0) {
-    return `npmPackage "${manifest.npmPackage}" is set but npmVersion is missing \u2014 every connector manifest must pin an exact tested version`;
-  }
-  if (!isExactSemver(manifest.npmVersion)) {
-    return `npmVersion ${JSON.stringify(manifest.npmVersion)} for "${manifest.npmPackage}" is not an exact semver (e.g. "1.2.3") \u2014 ranges, dist-tags like "latest", git specs, URLs, and file paths are not allowed`;
-  }
-  return null;
-}
-var manifests = /* @__PURE__ */ new Map();
-function loadManifests(integrationsDir) {
-  const dir = resolve(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join14(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
-  );
-  const indexPath = join14(dir, "index.json");
-  if (!existsSync14(indexPath)) {
-    console.error(`[ManifestLoader] No index.json found at ${indexPath}, skipping manifest loading`);
-    return 0;
-  }
-  let index;
-  try {
-    index = JSON.parse(readFileSync15(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 = join14(dir, relativePath);
-    try {
-      const manifest = JSON.parse(readFileSync15(manifestPath, "utf-8"));
-      const pinReason = invalidNpmPinReason(manifest);
-      if (pinReason) {
-        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${pinReason}`);
-        continue;
-      }
-      manifests.set(id, manifest);
-      loaded++;
-    } catch (err) {
-      console.error(`[ManifestLoader] Failed to load manifest ${id} from ${manifestPath}:`, err);
-    }
-  }
-  console.error(`[ManifestLoader] Loaded ${loaded} integration manifest(s) from ${dir}`);
-  return loaded;
-}
-function getManifest(id) {
-  return manifests.get(id);
-}
-function getAllManifests() {
-  return Array.from(manifests.values());
-}
-
 // src/lib/remote-auth-preflight.ts
 var AUTH_HEADER_RE = /^authorization:\s*(.+)$/i;
 function remotePreflightTarget(command, args) {
@@ -5518,8 +5932,8 @@ function inheritedConnectorEnv(parent, passEnv = []) {
 }
 
 // src/lib/integration-manager.ts
-var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join15(homedir10(), ".suveren");
-var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join15(DEFAULT_DATA_DIR2, "integrations");
+var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join16(homedir11(), ".suveren");
+var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join16(DEFAULT_DATA_DIR2, "integrations");
 var OFFLINE_MODE = process.env.SUVEREN_OFFLINE === "1";
 var installLock = Promise.resolve();
 function withInstallLock(task) {
@@ -5527,7 +5941,7 @@ function withInstallLock(task) {
   installLock = run.then(() => void 0, () => void 0);
   return run;
 }
-var INTEGRATIONS_BIN = join15(INTEGRATIONS_DIR, "node_modules", ".bin");
+var INTEGRATIONS_BIN = join16(INTEGRATIONS_DIR, "node_modules", ".bin");
 function getIntegrationsBinDir() {
   return INTEGRATIONS_BIN;
 }
@@ -5536,12 +5950,12 @@ function buildPath() {
   return [INTEGRATIONS_BIN, base].join(delimiter);
 }
 function ensureIntegrationsDir() {
-  if (!existsSync15(INTEGRATIONS_DIR)) {
-    mkdirSync12(INTEGRATIONS_DIR, { recursive: true });
+  if (!existsSync16(INTEGRATIONS_DIR)) {
+    mkdirSync13(INTEGRATIONS_DIR, { recursive: true });
   }
-  const pkgPath = join15(INTEGRATIONS_DIR, "package.json");
-  if (!existsSync15(pkgPath)) {
-    writeFileSync12(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
+  const pkgPath = join16(INTEGRATIONS_DIR, "package.json");
+  if (!existsSync16(pkgPath)) {
+    writeFileSync13(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
   }
 }
 function readAgeOf(config) {
@@ -5630,19 +6044,19 @@ var IntegrationManager = class {
    * exist, and treat anything else as not-installed (and reinstallable).
    */
   isUsableInstall(npmPackage) {
-    const pkgDir = join15(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    const pkgJson = join15(pkgDir, "package.json");
-    if (!existsSync15(pkgDir) || !existsSync15(pkgJson)) return false;
+    const pkgDir = join16(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    const pkgJson = join16(pkgDir, "package.json");
+    if (!existsSync16(pkgDir) || !existsSync16(pkgJson)) return false;
     try {
-      const pkg = JSON.parse(readFileSync16(pkgJson, "utf8"));
+      const pkg = JSON.parse(readFileSync17(pkgJson, "utf8"));
       const defaultBinName = (pkg.name ?? npmPackage).split("/").pop() ?? "";
       const binMap = typeof pkg.bin === "string" ? { [defaultBinName]: pkg.bin } : pkg.bin ?? {};
       const binEntries = Object.entries(binMap);
       for (const [binName, target] of binEntries) {
-        if (!existsSync15(join15(pkgDir, target))) return false;
+        if (!existsSync16(join16(pkgDir, target))) return false;
         if (!this.binShimExists(binName)) return false;
       }
-      if (binEntries.length === 0 && pkg.main && !existsSync15(join15(pkgDir, pkg.main))) return false;
+      if (binEntries.length === 0 && pkg.main && !existsSync16(join16(pkgDir, pkg.main))) return false;
       return true;
     } catch {
       return false;
@@ -5657,9 +6071,9 @@ var IntegrationManager = class {
    */
   readInstalledVersion(npmPackage) {
     if (!this.isUsableInstall(npmPackage)) return null;
-    const pkgJson = join15(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"), "package.json");
+    const pkgJson = join16(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"), "package.json");
     try {
-      const pkg = JSON.parse(readFileSync16(pkgJson, "utf8"));
+      const pkg = JSON.parse(readFileSync17(pkgJson, "utf8"));
       return typeof pkg.version === "string" ? pkg.version : null;
     } catch {
       return null;
@@ -5673,7 +6087,7 @@ var IntegrationManager = class {
   binShimExists(binName) {
     if (!binName) return false;
     const candidates = process.platform === "win32" ? [binName, `${binName}.cmd`, `${binName}.CMD`, `${binName}.ps1`] : [binName];
-    return candidates.some((c) => existsSync15(join15(INTEGRATIONS_BIN, c)));
+    return candidates.some((c) => existsSync16(join16(INTEGRATIONS_BIN, c)));
   }
   /**
    * The exact version THIS gateway's CURRENTLY LOADED manifest pins
@@ -5763,8 +6177,8 @@ var IntegrationManager = class {
    * nothing at all.
    */
   async installNow(npmPackage, exactVersion, cleanFirst = true) {
-    const pkgDir = join15(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    if (cleanFirst && existsSync15(pkgDir)) {
+    const pkgDir = join16(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    if (cleanFirst && existsSync16(pkgDir)) {
       console.error(`[IntegrationManager] Removing ${exactVersion ? "outdated" : "unusable"} install of ${npmPackage}`);
       try {
         rmSync(pkgDir, { recursive: true, force: true });
@@ -5957,6 +6371,7 @@ var IntegrationManager = class {
           tool.inputSchema ?? {},
           gating?.blockedArgs
         ),
+        outputSchema: tool.outputSchema,
         gating
       };
     });
@@ -6121,7 +6536,11 @@ var IntegrationManager = class {
         type: item.type,
         text: item.text ?? JSON.stringify(item)
       }));
-      return { content, isError: result.isError };
+      return {
+        content,
+        isError: result.isError,
+        structuredContent: result.structuredContent
+      };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       return {
@@ -6670,28 +7089,28 @@ function agentAccess(token, opensSession) {
 }
 
 // src/lib/profile-loader.ts
-import { readFileSync as readFileSync17, existsSync as existsSync16 } from "fs";
-import { join as join16, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync18, existsSync as existsSync17 } from "fs";
+import { join as join17, resolve as resolve2 } from "path";
 import { registerProfile } from "@hap/core";
 function loadProfiles(profilesDir) {
-  const dir = resolve2(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join16(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
-  const indexPath = join16(dir, "index.json");
-  if (!existsSync16(indexPath)) {
+  const dir = resolve2(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join17(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
+  const indexPath = join17(dir, "index.json");
+  if (!existsSync17(indexPath)) {
     warnNoProfiles(`No index.json at ${indexPath}`);
     return 0;
   }
   let index;
   try {
-    index = JSON.parse(readFileSync17(indexPath, "utf-8"));
+    index = JSON.parse(readFileSync18(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 = join16(dir, relativePath);
+    const profilePath = join17(dir, relativePath);
     try {
-      const profile = JSON.parse(readFileSync17(profilePath, "utf-8"));
+      const profile = JSON.parse(readFileSync18(profilePath, "utf-8"));
       registerProfile(profileId, profile);
       const shortName = profileId.split("/").pop()?.replace(/@.*$/, "");
       if (shortName && shortName !== profileId) {
@@ -7029,20 +7448,20 @@ async function controlPlaneMandate(dryRun, request) {
 }
 
 // src/lib/guides.ts
-import { existsSync as existsSync17, readdirSync, readFileSync as readFileSync18 } from "fs";
-import { dirname as dirname12, join as join17 } from "path";
+import { existsSync as existsSync18, readdirSync, readFileSync as readFileSync19 } from "fs";
+import { dirname as dirname13, join as join18 } from "path";
 var FILE_RE = /^(?:(\d+)-)?([a-z0-9][a-z0-9-]*)\.md$/;
 function builtinGuidesDir() {
   if (process.env.SUVEREN_BUILTIN_GUIDES_DIR) return process.env.SUVEREN_BUILTIN_GUIDES_DIR;
   let dir = import.meta.dirname ?? __dirname;
   for (let i = 0; i < 8; i++) {
-    const candidate = join17(dir, "content", "guides");
-    if (existsSync17(candidate)) return candidate;
-    const parent = dirname12(dir);
+    const candidate = join18(dir, "content", "guides");
+    if (existsSync18(candidate)) return candidate;
+    const parent = dirname13(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return join17(import.meta.dirname ?? __dirname, "content", "guides");
+  return join18(import.meta.dirname ?? __dirname, "content", "guides");
 }
 function parse(body) {
   const lines = body.split(/\r?\n/);
@@ -7053,14 +7472,14 @@ function parse(body) {
   return { title, summary };
 }
 function readDir(dir, source) {
-  if (!dir || !existsSync17(dir)) return [];
+  if (!dir || !existsSync18(dir)) return [];
   const out = [];
   for (const file of readdirSync(dir)) {
     const m = FILE_RE.exec(file);
     if (!m) continue;
     let body;
     try {
-      body = readFileSync18(join17(dir, file), "utf8");
+      body = readFileSync19(join18(dir, file), "utf8");
     } catch {
       continue;
     }
@@ -7370,8 +7789,8 @@ function registerBuiltins(deps, factories = BUILTIN_FACTORIES) {
 import { decodeMandateBlob as decodeMandateBlob3 } from "@hap/core";
 
 // src/lib/committed-executor.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname13, join as join18 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync20, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname14, join as join19 } from "path";
 var CommittedExecutor = class {
   constructor(run) {
     this.run = run;
@@ -7399,7 +7818,7 @@ var ExecutorLock = class {
   path;
   held = false;
   constructor(dataDir2) {
-    this.path = join18(dataDir2, "executor.lock");
+    this.path = join19(dataDir2, "executor.lock");
   }
   /** Try to take the lock. Returns the holder's pid when someone else has it. */
   acquire() {
@@ -7407,9 +7826,9 @@ var ExecutorLock = class {
     if (current && current.pid !== process.pid && isAlive(current.pid)) {
       return { held: false, holderPid: current.pid };
     }
-    mkdirSync13(dirname13(this.path), { recursive: true, mode: 448 });
+    mkdirSync14(dirname14(this.path), { recursive: true, mode: 448 });
     const lock = { pid: process.pid, startedAt: Math.floor(Date.now() / 1e3) };
-    writeFileSync13(this.path, JSON.stringify(lock), { mode: 384 });
+    writeFileSync14(this.path, JSON.stringify(lock), { mode: 384 });
     this.held = true;
     return { held: true };
   }
@@ -7431,9 +7850,9 @@ var ExecutorLock = class {
     }
   }
   read() {
-    if (!existsSync18(this.path)) return null;
+    if (!existsSync19(this.path)) return null;
     try {
-      const parsed = JSON.parse(readFileSync19(this.path, "utf8"));
+      const parsed = JSON.parse(readFileSync20(this.path, "utf8"));
       return typeof parsed?.pid === "number" ? parsed : null;
     } catch {
       return null;
@@ -7450,20 +7869,20 @@ function isAlive(pid) {
 }
 
 // bin/http.ts
-import { homedir as homedir11 } from "os";
-import { join as join20 } from "path";
+import { homedir as homedir12 } from "os";
+import { join as join21 } from "path";
 
 // src/lib/mcp-as-tracker.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname14, join as join19 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname15, join as join20 } from "path";
 function trackerPath(dataDir2) {
-  return join19(dataDir2, "mcp-as-pairing.json");
+  return join20(dataDir2, "mcp-as-pairing.json");
 }
 function readMcpPairedAsUrl(dataDir2) {
   const path = trackerPath(dataDir2);
-  if (!existsSync19(path)) return null;
+  if (!existsSync20(path)) return null;
   try {
-    const data = JSON.parse(readFileSync20(path, "utf-8"));
+    const data = JSON.parse(readFileSync21(path, "utf-8"));
     return typeof data.asUrl === "string" ? data.asUrl : null;
   } catch {
     return null;
@@ -7471,12 +7890,12 @@ function readMcpPairedAsUrl(dataDir2) {
 }
 function writeMcpPairedAsUrl(dataDir2, asUrl) {
   const path = trackerPath(dataDir2);
-  mkdirSync14(dirname14(path), { recursive: true, mode: 448 });
-  writeFileSync14(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
+  mkdirSync15(dirname15(path), { recursive: true, mode: 448 });
+  writeFileSync15(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
 }
 
 // bin/http.ts
-var dataDir = process.env.SUVEREN_DATA_DIR ?? join20(homedir11(), ".suveren");
+var dataDir = process.env.SUVEREN_DATA_DIR ?? join21(homedir12(), ".suveren");
 var spUrl = resolveAsUrl(dataDir);
 validatePinTlsForUrl(resolvePinTls(dataDir), spUrl);
 var port = parseInt(process.env.SUVEREN_MCP_PORT ?? "3430", 10);
@@ -7686,6 +8105,29 @@ app.post("/internal/resync-gates", internalOnly, async (_req, res) => {
   }
   res.json({ ok: true, synced, orphaned });
 });
+app.post("/internal/preview", internalOnly, async (req, res) => {
+  const { proposalId, tool, toolArgs } = req.body;
+  if (!proposalId || !tool || typeof toolArgs !== "object" || toolArgs === null) {
+    res.status(400).json({ error: "Missing proposalId, tool, or toolArgs" });
+    return;
+  }
+  const sep = tool.indexOf("__");
+  if (sep < 0) {
+    res.status(400).json({ error: `Invalid tool name: ${tool}` });
+    return;
+  }
+  const integrationId = tool.slice(0, sep);
+  const toolName = tool.slice(sep + 2);
+  const result = await buildInternalPreview(integrationManager, integrationId, toolName, toolArgs);
+  state.previewLog.record({
+    ts: Date.now(),
+    proposalId,
+    integrationId,
+    tool: toolName,
+    status: result.status
+  });
+  res.json(result);
+});
 app.post("/internal/add-integration", internalOnly, async (req, res) => {
   try {
     const config = req.body;
@@ -8179,7 +8621,7 @@ app.listen(port, bindHost, () => {
     (proposal) => executeCommitted(proposal, state, integrationManager)
   );
   installCommittedExecutor(committedExecutor);
-  const dataDir2 = process.env.SUVEREN_DATA_DIR ?? join20(homedir11(), ".suveren");
+  const dataDir2 = process.env.SUVEREN_DATA_DIR ?? join21(homedir12(), ".suveren");
   const executorLock = new ExecutorLock(dataDir2);
   const lock = executorLock.acquire();
   if (!lock.held) {