@suveren/gateway 0.28.1 → 0.29.1

package/dist/mcp-server/http.mjs

@@ -2190,21 +2190,168 @@ function nowSec() {
   return Math.floor(Date.now() / 1e3);
 }
 
-// src/lib/proposal-submission-store.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync9, renameSync as renameSync2 } from "fs";
+// src/lib/execution-result-store.ts
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync9, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname7, join as join9 } from "path";
+import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes5 } from "crypto";
 var DEFAULT_DIR6 = process.env.SUVEREN_DATA_DIR ?? join9(homedir6(), ".suveren");
-var FILE_NAME2 = "proposal-submissions.json";
 var MAX_AGE_SECONDS3 = 90 * 24 * 60 * 60;
+var MAX_BYTES = 16 * 1024;
+function capResult(text, structuredContent) {
+  const structJson = structuredContent ? JSON.stringify(structuredContent) : void 0;
+  const textBytes = Buffer.byteLength(text, "utf8");
+  const structBytes = structJson ? Buffer.byteLength(structJson, "utf8") : 0;
+  if (textBytes + structBytes <= MAX_BYTES) {
+    return { text, ...structuredContent ? { structuredContent } : {}, truncated: false };
+  }
+  if (textBytes <= MAX_BYTES) {
+    return { text, truncated: true };
+  }
+  const cappedText = Buffer.from(text, "utf8").subarray(0, MAX_BYTES).toString("utf8");
+  return { text: cappedText, truncated: true };
+}
+var ExecutionResultStore = class {
+  entries = [];
+  baseDir;
+  vaultKey = null;
+  constructor(filePath) {
+    this.baseDir = filePath && filePath.endsWith(".json") ? dirname7(filePath) : filePath ?? DEFAULT_DIR6;
+    this.loadPlaintext();
+  }
+  /** Mirrors OutcomeOutbox.setVaultKey — migrates plaintext -> encrypted once, in place. */
+  setVaultKey(key) {
+    this.vaultKey = key;
+    if (existsSync9(this.encryptedFilePath)) {
+      this.loadEncrypted();
+    } else if (this.entries.length > 0) {
+      this.persistEncrypted();
+      if (existsSync9(this.plaintextFilePath)) {
+        try {
+          unlinkSync5(this.plaintextFilePath);
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * True when encrypted evidence exists on disk that this process cannot
+   * read yet (no vault key). Callers should not report "nothing retained" in
+   * this state — that would claim a hollow absence over unreadable content.
+   */
+  isLocked() {
+    return this.vaultKey === null && existsSync9(this.encryptedFilePath);
+  }
+  /** Record the outcome of one execution. Replaces any prior entry for the same proposal. */
+  record(input, now = nowSec2()) {
+    const capped = capResult(input.text, input.structuredContent);
+    this.entries = this.entries.filter((e) => e.proposalId !== input.proposalId);
+    this.entries.push({
+      proposalId: input.proposalId,
+      ticketId: input.ticketId,
+      ok: input.ok,
+      text: capped.text,
+      ...capped.structuredContent ? { structuredContent: capped.structuredContent } : {},
+      ...capped.truncated ? { truncated: true } : {},
+      recordedAt: now
+    });
+    this.prune(now);
+    this.persist();
+  }
+  /** The retained outcome for a proposal, or undefined if never recorded (or pruned). */
+  get(proposalId) {
+    return this.entries.find((e) => e.proposalId === proposalId);
+  }
+  /** Diagnostic / tests. */
+  get size() {
+    return this.entries.length;
+  }
+  // ─── Retention ────────────────────────────────────────────────────────────
+  prune(now) {
+    const cutoff = now - MAX_AGE_SECONDS3;
+    this.entries = this.entries.filter((e) => e.recordedAt >= cutoff);
+  }
+  // ─── Encryption (mirrors OutcomeOutbox / DenialLog) ────────────────────────
+  encrypt(plaintext) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const iv = randomBytes5(12);
+    const cipher = createCipheriv5("aes-256-gcm", this.vaultKey, iv);
+    const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    return { iv: iv.toString("hex"), ciphertext: enc.toString("hex"), tag: cipher.getAuthTag().toString("hex") };
+  }
+  decrypt(blob) {
+    if (!this.vaultKey) throw new Error("No vault key");
+    const decipher = createDecipheriv5("aes-256-gcm", this.vaultKey, Buffer.from(blob.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
+    return Buffer.concat([decipher.update(Buffer.from(blob.ciphertext, "hex")), decipher.final()]).toString("utf8");
+  }
+  get plaintextFilePath() {
+    return join9(this.baseDir, "execution-results.json");
+  }
+  get encryptedFilePath() {
+    return join9(this.baseDir, "execution-results.enc.json");
+  }
+  loadPlaintext() {
+    if (!existsSync9(this.plaintextFilePath)) {
+      mkdirSync7(this.baseDir, { recursive: true });
+      return;
+    }
+    try {
+      const data = JSON.parse(readFileSync10(this.plaintextFilePath, "utf-8"));
+      this.entries = data.entries ?? [];
+      this.prune(nowSec2());
+    } catch {
+      console.error(`[ExecutionResultStore] Could not parse ${this.plaintextFilePath}, starting fresh`);
+      this.entries = [];
+    }
+  }
+  loadEncrypted() {
+    if (!existsSync9(this.encryptedFilePath)) return;
+    try {
+      const data = JSON.parse(readFileSync10(this.encryptedFilePath, "utf-8"));
+      const storeFile = JSON.parse(this.decrypt(data.blob));
+      this.entries = storeFile.entries ?? [];
+      this.prune(nowSec2());
+    } catch (err) {
+      console.error(`[ExecutionResultStore] 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 };
+    mkdirSync7(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync7(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+  persistEncrypted() {
+    const storeFile = { version: 1, entries: this.entries };
+    const data = { version: 1, blob: this.encrypt(JSON.stringify(storeFile)) };
+    mkdirSync7(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync7(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  }
+};
 function nowSec2() {
   return Math.floor(Date.now() / 1e3);
 }
+
+// src/lib/proposal-submission-store.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync10, renameSync as renameSync2 } 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_NAME2 = "proposal-submissions.json";
+var MAX_AGE_SECONDS4 = 90 * 24 * 60 * 60;
+function nowSec3() {
+  return Math.floor(Date.now() / 1e3);
+}
 var ProposalSubmissionStore = class {
   filePath;
   constructor(filePath) {
-    const baseDir = filePath && filePath.endsWith(".json") ? dirname7(filePath) : filePath ?? DEFAULT_DIR6;
-    this.filePath = join9(baseDir, FILE_NAME2);
+    const baseDir = filePath && filePath.endsWith(".json") ? dirname8(filePath) : filePath ?? DEFAULT_DIR7;
+    this.filePath = join10(baseDir, FILE_NAME2);
   }
   /** Record what was submitted, right after a successful submitProposal(). */
   record(entry) {
@@ -2217,7 +2364,7 @@ var ProposalSubmissionStore = class {
       executionContextHash: hashToolArgs(entry.executionContext),
       authorizationId: entry.authorizationId,
       profileId: entry.profileId,
-      submittedAt: nowSec2(),
+      submittedAt: nowSec3(),
       ...entry.previewHash ? { previewHash: entry.previewHash } : {}
     });
     this.persist(file);
@@ -2228,10 +2375,10 @@ var ProposalSubmissionStore = class {
     return this.load().entries.find((e) => e.proposalId === proposalId);
   }
   load() {
-    if (!existsSync9(this.filePath)) return { version: 1, entries: [] };
+    if (!existsSync10(this.filePath)) return { version: 1, entries: [] };
     try {
-      const parsed = JSON.parse(readFileSync10(this.filePath, "utf-8"));
-      const cutoff = nowSec2() - MAX_AGE_SECONDS3;
+      const parsed = JSON.parse(readFileSync11(this.filePath, "utf-8"));
+      const cutoff = nowSec3() - MAX_AGE_SECONDS4;
       parsed.entries = (parsed.entries ?? []).filter((e) => e.submittedAt >= cutoff);
       return parsed;
     } catch {
@@ -2239,26 +2386,26 @@ var ProposalSubmissionStore = class {
     }
   }
   persist(file) {
-    mkdirSync7(dirname7(this.filePath), { recursive: true, mode: 448 });
+    mkdirSync8(dirname8(this.filePath), { recursive: true, mode: 448 });
     const tmpPath = `${this.filePath}.tmp`;
-    writeFileSync7(tmpPath, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync8(tmpPath, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
     renameSync2(tmpPath, this.filePath);
   }
 };
 
 // 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");
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync11, renameSync as renameSync3 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname9, join as join11 } from "path";
+var DEFAULT_DIR8 = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".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);
+    const baseDir = filePath && filePath.endsWith(".json") ? dirname9(filePath) : filePath ?? DEFAULT_DIR8;
+    this.filePath = join11(baseDir, FILE_NAME3);
   }
   /** Record one preview read. Never throws — recording must not break the read. */
   record(entry) {
@@ -2280,28 +2427,28 @@ var PreviewLog = class {
     return [...this.load().entries];
   }
   load() {
-    if (!existsSync10(this.filePath)) return { version: 1, entries: [] };
+    if (!existsSync11(this.filePath)) return { version: 1, entries: [] };
     try {
-      const parsed = JSON.parse(readFileSync11(this.filePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync12(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 });
+    mkdirSync9(dirname9(this.filePath), { recursive: true, mode: 448 });
     const tmp = `${this.filePath}.tmp`;
-    writeFileSync8(tmp, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
+    writeFileSync9(tmp, JSON.stringify(file, null, 2), { encoding: "utf-8", mode: 384 });
     renameSync3(tmp, this.filePath);
   }
 };
 
 // src/lib/outcome-outbox.ts
-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";
-var DEFAULT_DIR8 = process.env.SUVEREN_DATA_DIR ?? join11(homedir8(), ".suveren");
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync12, unlinkSync as unlinkSync6 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname10, join as join12 } from "path";
+import { createCipheriv as createCipheriv6, createDecipheriv as createDecipheriv6, randomBytes as randomBytes6 } from "crypto";
+var DEFAULT_DIR9 = process.env.SUVEREN_DATA_DIR ?? join12(homedir9(), ".suveren");
 var MAX_AGE_MS3 = 7 * 24 * 60 * 60 * 1e3;
 function outcomeEntryFor(proposal, submittedHere, who, nowMs) {
   if (!submittedHere) return null;
@@ -2316,19 +2463,19 @@ var OutcomeOutbox = class {
   baseDir;
   vaultKey = null;
   constructor(filePath) {
-    this.baseDir = filePath && filePath.endsWith(".json") ? dirname9(filePath) : filePath ?? DEFAULT_DIR8;
+    this.baseDir = filePath && filePath.endsWith(".json") ? dirname10(filePath) : filePath ?? DEFAULT_DIR9;
     this.loadPlaintext();
   }
   /** Mirrors DenialLog.setVaultKey — migrates plaintext -> encrypted once, in place. */
   setVaultKey(key) {
     this.vaultKey = key;
-    if (existsSync11(this.encryptedFilePath)) {
+    if (existsSync12(this.encryptedFilePath)) {
       this.loadEncrypted();
     } else if (this.entries.length > 0) {
       this.persistEncrypted();
-      if (existsSync11(this.plaintextFilePath)) {
+      if (existsSync12(this.plaintextFilePath)) {
         try {
-          unlinkSync5(this.plaintextFilePath);
+          unlinkSync6(this.plaintextFilePath);
         } catch {
         }
       }
@@ -2377,30 +2524,30 @@ var OutcomeOutbox = class {
   // ─── Encryption (mirrors DenialLog / ExecutionLog) ─────────────────────────
   encrypt(plaintext) {
     if (!this.vaultKey) throw new Error("No vault key");
-    const iv = randomBytes5(12);
-    const cipher = createCipheriv5("aes-256-gcm", this.vaultKey, iv);
+    const iv = randomBytes6(12);
+    const cipher = createCipheriv6("aes-256-gcm", this.vaultKey, iv);
     const enc = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
     return { iv: iv.toString("hex"), ciphertext: enc.toString("hex"), tag: cipher.getAuthTag().toString("hex") };
   }
   decrypt(blob) {
     if (!this.vaultKey) throw new Error("No vault key");
-    const decipher = createDecipheriv5("aes-256-gcm", this.vaultKey, Buffer.from(blob.iv, "hex"));
+    const decipher = createDecipheriv6("aes-256-gcm", this.vaultKey, Buffer.from(blob.iv, "hex"));
     decipher.setAuthTag(Buffer.from(blob.tag, "hex"));
     return Buffer.concat([decipher.update(Buffer.from(blob.ciphertext, "hex")), decipher.final()]).toString("utf8");
   }
   get plaintextFilePath() {
-    return join11(this.baseDir, "outcome-outbox.json");
+    return join12(this.baseDir, "outcome-outbox.json");
   }
   get encryptedFilePath() {
-    return join11(this.baseDir, "outcome-outbox.enc.json");
+    return join12(this.baseDir, "outcome-outbox.enc.json");
   }
   loadPlaintext() {
-    if (!existsSync11(this.plaintextFilePath)) {
-      mkdirSync9(this.baseDir, { recursive: true });
+    if (!existsSync12(this.plaintextFilePath)) {
+      mkdirSync10(this.baseDir, { recursive: true });
       return;
     }
     try {
-      const data = JSON.parse(readFileSync12(this.plaintextFilePath, "utf-8"));
+      const data = JSON.parse(readFileSync13(this.plaintextFilePath, "utf-8"));
       this.entries = data.entries ?? [];
       this.prune(Date.now());
     } catch {
@@ -2409,9 +2556,9 @@ var OutcomeOutbox = class {
     }
   }
   loadEncrypted() {
-    if (!existsSync11(this.encryptedFilePath)) return;
+    if (!existsSync12(this.encryptedFilePath)) return;
     try {
-      const data = JSON.parse(readFileSync12(this.encryptedFilePath, "utf-8"));
+      const data = JSON.parse(readFileSync13(this.encryptedFilePath, "utf-8"));
       const storeFile = JSON.parse(this.decrypt(data.blob));
       this.entries = storeFile.entries ?? [];
       this.prune(Date.now());
@@ -2426,14 +2573,14 @@ var OutcomeOutbox = class {
   }
   persistPlaintext() {
     const data = { version: 1, entries: this.entries };
-    mkdirSync9(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync9(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync10(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync10(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   }
   persistEncrypted() {
     const storeFile = { version: 1, entries: this.entries };
     const data = { version: 1, blob: this.encrypt(JSON.stringify(storeFile)) };
-    mkdirSync9(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync9(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync10(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync10(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   }
 };
 function formatOutcomeLine(e) {
@@ -2545,10 +2692,10 @@ var MCPGatekeeper = class {
 };
 
 // src/lib/report/report-store.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync12, unlinkSync as unlinkSync6 } from "fs";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname10, join as join12 } from "path";
-import { createCipheriv as createCipheriv6, createDecipheriv as createDecipheriv6, randomBytes as randomBytes6 } from "crypto";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11, existsSync as existsSync13, unlinkSync as unlinkSync7 } from "fs";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname11, join as join13 } from "path";
+import { createCipheriv as createCipheriv7, createDecipheriv as createDecipheriv7, randomBytes as randomBytes7 } from "crypto";
 
 // src/lib/report/record-resolvers.ts
 function findById(rows, id) {
@@ -2856,29 +3003,29 @@ async function buildCoverage(caseElements, getExport, archive, referenced, windo
 }
 
 // src/lib/report/report-store.ts
-var DEFAULT_DIR9 = process.env.SUVEREN_DATA_DIR ?? join12(homedir9(), ".suveren");
+var DEFAULT_DIR10 = process.env.SUVEREN_DATA_DIR ?? join13(homedir10(), ".suveren");
 var ReportStore = class {
   report = null;
   baseDir;
   vaultKey = null;
   constructor(filePath) {
     if (filePath && filePath.endsWith(".json")) {
-      this.baseDir = dirname10(filePath);
+      this.baseDir = dirname11(filePath);
     } else {
-      this.baseDir = filePath ?? DEFAULT_DIR9;
+      this.baseDir = filePath ?? DEFAULT_DIR10;
     }
     this.loadPlaintext();
   }
   /** Set the vault key for encryption. Triggers migration from plaintext if needed. */
   setVaultKey(key) {
     this.vaultKey = key;
-    if (existsSync12(this.encryptedFilePath)) {
+    if (existsSync13(this.encryptedFilePath)) {
       this.loadEncrypted();
     } else if (this.report !== null) {
       this.persistEncrypted();
-      if (existsSync12(this.plaintextFilePath)) {
+      if (existsSync13(this.plaintextFilePath)) {
         try {
-          unlinkSync6(this.plaintextFilePath);
+          unlinkSync7(this.plaintextFilePath);
         } catch {
         }
       }
@@ -2891,7 +3038,7 @@ var ReportStore = class {
    * "the report exists but is locked".
    */
   isLocked() {
-    return this.vaultKey === null && existsSync12(this.encryptedFilePath);
+    return this.vaultKey === null && existsSync13(this.encryptedFilePath);
   }
   /** The stored, already-verified report — or null if none has been saved
    *  (and the store is not locked; check `isLocked()` first). */
@@ -2925,49 +3072,49 @@ var ReportStore = class {
   // ─── Encryption helpers ─────────────────────────────────────────────────
   encrypt(plaintext) {
     if (!this.vaultKey) throw new Error("No vault key");
-    const iv = randomBytes6(12);
-    const cipher = createCipheriv6("aes-256-gcm", this.vaultKey, iv);
+    const iv = randomBytes7(12);
+    const cipher = createCipheriv7("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 = createDecipheriv6("aes-256-gcm", this.vaultKey, Buffer.from(blob.iv, "hex"));
+    const decipher = createDecipheriv7("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 join12(this.baseDir, "report.json");
+    return join13(this.baseDir, "report.json");
   }
   get encryptedFilePath() {
-    return join12(this.baseDir, "report.enc.json");
+    return join13(this.baseDir, "report.enc.json");
   }
   // ─── Load / Persist ─────────────────────────────────────────────────────
   loadPlaintext() {
-    if (!existsSync12(this.plaintextFilePath)) {
-      mkdirSync10(this.baseDir, { recursive: true });
+    if (!existsSync13(this.plaintextFilePath)) {
+      mkdirSync11(this.baseDir, { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync13(this.plaintextFilePath, "utf-8");
+      const raw = readFileSync14(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 {
-        writeFileSync10(`${this.plaintextFilePath}.corrupt-${Date.now()}`, readFileSync13(this.plaintextFilePath));
+        writeFileSync11(`${this.plaintextFilePath}.corrupt-${Date.now()}`, readFileSync14(this.plaintextFilePath));
       } catch {
       }
       this.report = null;
     }
   }
   loadEncrypted() {
-    if (!existsSync12(this.encryptedFilePath)) return;
+    if (!existsSync13(this.encryptedFilePath)) return;
     try {
-      const raw = readFileSync13(this.encryptedFilePath, "utf-8");
+      const raw = readFileSync14(this.encryptedFilePath, "utf-8");
       const data = JSON.parse(raw);
       const decrypted = this.decrypt(data.blob);
       const parsed = JSON.parse(decrypted);
@@ -2975,7 +3122,7 @@ var ReportStore = class {
     } catch (err) {
       console.error(`[ReportStore] Could not decrypt ${this.encryptedFilePath} \u2014 preserving as .corrupt:`, err);
       try {
-        writeFileSync10(`${this.encryptedFilePath}.corrupt-${Date.now()}`, readFileSync13(this.encryptedFilePath));
+        writeFileSync11(`${this.encryptedFilePath}.corrupt-${Date.now()}`, readFileSync14(this.encryptedFilePath));
       } catch {
       }
       this.report = null;
@@ -2990,16 +3137,16 @@ var ReportStore = class {
   }
   persistPlaintext() {
     const data = { version: 1, report: this.report };
-    mkdirSync10(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync10(this.plaintextFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync11(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync11(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 }))
     };
-    mkdirSync10(this.baseDir, { recursive: true, mode: 448 });
-    writeFileSync10(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+    mkdirSync11(this.baseDir, { recursive: true, mode: 448 });
+    writeFileSync11(this.encryptedFilePath, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   }
 };
 
@@ -3017,6 +3164,8 @@ var SharedState = class {
   reportStore;
   /** Which tickets this Gatekeeper has executed — the "one execution per ticket" half of exactly-once. */
   executionJournal;
+  /** The content half of what executionJournal records — see execution-result-store.ts. */
+  executionResults;
   /** What THIS gateway submitted for each review-mode proposal it created —
    *  see ticket-verify.ts / commitments.ts. */
   proposalSubmissions;
@@ -3057,6 +3206,7 @@ var SharedState = class {
     this.receiptArchive = new ReceiptArchive(gateStorePath);
     this.reportStore = new ReportStore(gateStorePath);
     this.executionJournal = new ExecutionJournal(gateStorePath);
+    this.executionResults = new ExecutionResultStore(gateStorePath);
     this.proposalSubmissions = new ProposalSubmissionStore(gateStorePath);
     this.previewLog = new PreviewLog(gateStorePath);
     this.outcomeOutbox = new OutcomeOutbox(gateStorePath);
@@ -3180,7 +3330,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
 
 // src/lib/mandate-brief.ts
-import { getProfile as getProfile3 } from "@hap/core";
+import { getProfile as getProfile5 } from "@hap/core";
 
 // src/lib/consumption.ts
 import { boundActionTypes } from "@hap/core";
@@ -3248,29 +3398,29 @@ function formatConsumptionFull(entries) {
 }
 
 // src/lib/context-loader.ts
-import { readFileSync as readFileSync14, existsSync as existsSync13, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11, renameSync as renameSync4 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join13, dirname as dirname11 } from "path";
-var DEFAULT_DIR10 = process.env.SUVEREN_DATA_DIR ?? join13(homedir10(), ".suveren");
+import { readFileSync as readFileSync15, existsSync as existsSync14, mkdirSync as mkdirSync12, writeFileSync as writeFileSync12, renameSync as renameSync4 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join14, dirname as dirname12 } from "path";
+var DEFAULT_DIR11 = process.env.SUVEREN_DATA_DIR ?? join14(homedir11(), ".suveren");
 var CONTEXT_MAX_BYTES = 16 * 1024;
 function contextFilePath(dataDir2) {
-  return join13(dataDir2 ?? DEFAULT_DIR10, "context.md");
+  return join14(dataDir2 ?? DEFAULT_DIR11, "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);
-  mkdirSync11(dirname11(filePath), { recursive: true });
+  mkdirSync12(dirname12(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp`;
-  writeFileSync11(tmpPath, content, "utf-8");
+  writeFileSync12(tmpPath, content, "utf-8");
   renameSync4(tmpPath, filePath);
 }
 var BRIEF_MAX_CHARS = 16 * 1024;
 function readContextFile(dataDir2) {
   const filePath = contextFilePath(dataDir2);
-  if (!existsSync13(filePath)) return null;
+  if (!existsSync14(filePath)) return null;
   try {
-    const content = readFileSync14(filePath, "utf-8").trim();
+    const content = readFileSync15(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -3467,12 +3617,234 @@ function attachTicketId(tool, args, ticketId) {
 import { computeContentHash as computeContentHash2 } from "@hap/core";
 
 // src/lib/manifest-loader.ts
-import { readFileSync as readFileSync15, existsSync as existsSync14 } from "fs";
-import { join as join14, resolve } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync15 } from "fs";
+import { join as join15, resolve } from "path";
+import { getProfile as getProfile2 } from "@hap/core";
 
 // src/lib/tool-gating-types.ts
 var MAX_PREVIEW_READS = 10;
 var MAX_FOREACH_ELEMENTS = 50;
+var MAX_RECORD_KEY_STEPS = 2;
+
+// src/lib/scope-specificity.ts
+function tokenSet(value) {
+  if (value === void 0 || value === null) return /* @__PURE__ */ new Set();
+  return new Set(
+    String(value).split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
+  );
+}
+function subsetOrEqual(a, b) {
+  if (b.size === 0) return true;
+  if (a.size === 0) return false;
+  for (const x of a) if (!b.has(x)) return false;
+  return true;
+}
+function atLeastAsSpecific(keys, a, b) {
+  for (const k of keys) {
+    if (!subsetOrEqual(tokenSet(a[k]), tokenSet(b[k]))) return false;
+  }
+  return true;
+}
+function strictlyMoreSpecific(keys, a, b) {
+  return atLeastAsSpecific(keys, a, b) && !atLeastAsSpecific(keys, b, a);
+}
+function selectAuthorization(contextKeys, passers) {
+  if (passers.length === 1) {
+    return { chosen: passers[0], superseded: [], reason: "sole" };
+  }
+  const dominators = passers.filter(
+    (a) => passers.every((b) => b === a || strictlyMoreSpecific(contextKeys, a.context, b.context))
+  );
+  if (dominators.length === 1) {
+    const chosen2 = dominators[0];
+    return { chosen: chosen2, superseded: passers.filter((p) => p !== chosen2), reason: "most-specific" };
+  }
+  const approvers = passers.filter((p) => p.requiresApproval);
+  const pool = approvers.length > 0 ? approvers : passers;
+  const chosen = pool.slice().sort((a, b) => a.id.localeCompare(b.id))[0];
+  return {
+    chosen,
+    superseded: passers.filter((p) => p !== chosen),
+    reason: approvers.length > 0 ? "fail-safe-approval" : "fail-safe-tiebreak"
+  };
+}
+
+// src/lib/read-gate.ts
+function boundsSatisfyReadGate(bounds, gate) {
+  if (!gate.boundField) return true;
+  const actual = bounds?.[gate.boundField];
+  return actual !== void 0 && String(actual) === gate.requiredValue;
+}
+function readToolIsGoverned(g) {
+  if (!g) return false;
+  return Boolean(g.boundField) || g.read != null || g.readGovernance === "none";
+}
+function allowedResources(contexts, boundField) {
+  const out = /* @__PURE__ */ new Set();
+  for (const ctx of contexts) {
+    for (const v of tokenSet(ctx?.[boundField])) out.add(v);
+  }
+  return out;
+}
+function deniedResources(requested, allowed) {
+  return requested.filter((r) => !allowed.has(r));
+}
+function filterItemsByResource(items, idPath, allowed) {
+  return items.filter((it) => {
+    const id = getByDottedPath(it, idPath);
+    return typeof id === "string" && allowed.has(id);
+  });
+}
+function hasBlockedValue(item, valuesPath, blocked) {
+  const v = getByDottedPath(item, valuesPath);
+  const arr = Array.isArray(v) ? v : v != null ? [v] : [];
+  return arr.some((x) => typeof x === "string" && blocked.has(x));
+}
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function parseMessageTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+    const iso = Date.parse(value);
+    if (Number.isFinite(iso)) return iso;
+  }
+  return null;
+}
+function ageInDays(timestampMs, nowMs) {
+  return Math.floor((nowMs - timestampMs) / MS_PER_DAY);
+}
+function maxReadAgeDays(boundsList, field) {
+  let max = null;
+  for (const b of boundsList) {
+    const raw = b?.[field];
+    const n = typeof raw === "number" ? raw : raw !== void 0 ? Number(raw) : NaN;
+    if (Number.isFinite(n)) max = max === null ? n : Math.max(max, n);
+  }
+  return max;
+}
+function isOlderThanMaxAge(timestampMs, maxAgeDays, nowMs) {
+  if (timestampMs === null) return true;
+  return ageInDays(timestampMs, nowMs) > maxAgeDays;
+}
+var TRAILING_OPERATOR = /(?:^|\s)(?:OR|AND|NOT)$|[-+|&:]$/i;
+function parensBalanced(s) {
+  let depth = 0;
+  let inQuote = false;
+  for (const c of s) {
+    if (c === '"') {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (inQuote) continue;
+    if (c === "(") depth++;
+    else if (c === ")" && --depth < 0) return false;
+  }
+  return !inQuote && depth === 0;
+}
+function composeReadQuery(agentQuery, clauses) {
+  const injected = clauses.filter((c) => typeof c === "string" && c.trim() !== "").map((c) => c.trim());
+  const base = (agentQuery ?? "").trim();
+  if (base === "") return { ok: true, query: injected.join(" ") };
+  if (!parensBalanced(base)) {
+    return { ok: false, reason: "the requested search query has unbalanced parentheses" };
+  }
+  if (TRAILING_OPERATOR.test(base)) {
+    return { ok: false, reason: "the requested search query ends in a dangling operator" };
+  }
+  if (injected.length === 0) return { ok: true, query: base };
+  return { ok: true, query: `(${base}) ${injected.join(" ")}` };
+}
+function detectAgeConflict(agentQuery, conflictPattern, maxAgeDays) {
+  if (!agentQuery || !conflictPattern || maxAgeDays === null) return null;
+  let re;
+  try {
+    re = new RegExp(conflictPattern, "gi");
+  } catch {
+    return null;
+  }
+  let worst = null;
+  for (const match of agentQuery.matchAll(re)) {
+    const days = Number(match[1]);
+    if (!Number.isFinite(days)) continue;
+    if (days >= maxAgeDays && (worst === null || days > worst)) worst = days;
+  }
+  return worst;
+}
+function resolveAgeBoundField(boundsSchema, ageExecField) {
+  const fields = boundsSchema?.fields;
+  if (!fields) return null;
+  for (const [name, def] of Object.entries(fields)) {
+    if (def?.boundType?.kind === "per_transaction" && def.boundType.of === ageExecField) return name;
+  }
+  return null;
+}
+function classifyEnumSwitches(boundsSchema) {
+  const readSide = [];
+  const writeSide = [];
+  for (const [name, def] of Object.entries(boundsSchema?.fields ?? {})) {
+    if (def?.boundType?.kind !== "enum") continue;
+    const values = new Set(def.boundType.values ?? []);
+    if (!values.has("none")) continue;
+    if (values.size === 2 && values.has("unlimited")) readSide.push(name);
+    else writeSide.push(name);
+  }
+  return { readSide, writeSide };
+}
+function uncoveredReadSwitchReason(overrides, boundsSchema) {
+  const { readSide, writeSide } = classifyEnumSwitches(boundsSchema);
+  const anySwitch = [...readSide, ...writeSide];
+  if (anySwitch.length === 0) return null;
+  const valuesOf = (field) => boundsSchema?.fields?.[field]?.boundType?.values ?? [];
+  for (const [toolName, entry] of Object.entries(overrides)) {
+    if (entry !== null && typeof entry !== "object") continue;
+    const e = entry ?? {};
+    if (entry !== null && e.category !== "read") continue;
+    if (e.readGovernance === "none") {
+      if (!e.readGovernanceReason) {
+        return `override "${toolName}" declares readGovernance:"none" with no readGovernanceReason \u2014 an exemption from this profile's switch(es) [${anySwitch.join(", ")}] needs a written reason`;
+      }
+      continue;
+    }
+    if (!e.boundField || !anySwitch.includes(e.boundField)) {
+      return `override "${toolName}" is category:"read" under a profile that declares enum switch(es) [${anySwitch.join(", ")}] (read-side: [${readSide.join(", ")}], write-side: [${writeSide.join(", ")}]), but does not reference one via boundField (and carries no readGovernance exemption) \u2014 it would silently ignore e.g. "${anySwitch[0]}: none"`;
+    }
+    const positiveValues = valuesOf(e.boundField).filter((v) => v !== "none");
+    if (!e.requiredValue || !positiveValues.includes(e.requiredValue)) {
+      return `override "${toolName}".requiredValue for boundField "${e.boundField}" must be ${positiveValues.map((v) => `"${v}"`).join(" or ")}, not ${JSON.stringify(e.requiredValue)} \u2014 requiring "none" (or an unlisted value) would invert the gate`;
+    }
+  }
+  return null;
+}
+function getByDottedPath(obj, path) {
+  return path.split(".").reduce(
+    (o, k) => o == null ? void 0 : o[k],
+    obj
+  );
+}
+function firstParsableDate(obj, paths) {
+  for (const path of Array.isArray(paths) ? paths : [paths]) {
+    const parsed = parseMessageTimestamp(getByDottedPath(obj, path));
+    if (parsed !== null) return parsed;
+  }
+  return null;
+}
+function renderAgeConstraint(template, maxAgeDays, nowMs) {
+  const floorIso = new Date(nowMs - maxAgeDays * MS_PER_DAY).toISOString();
+  return template.replace(/\{days\}/g, String(maxAgeDays)).replace(/\{date\}/g, floorIso.slice(0, 10));
+}
+function ageFloorValue(maxAgeDays, nowMs, format = "iso") {
+  const floorMs = nowMs - maxAgeDays * MS_PER_DAY;
+  if (format === "epoch_ms") return floorMs;
+  if (format === "epoch_s") return String(Math.floor(floorMs / 1e3));
+  return new Date(floorMs).toISOString();
+}
+function clampAgeFloor(requested, maxAgeDays, nowMs, format = "iso") {
+  const floorMs = nowMs - maxAgeDays * MS_PER_DAY;
+  const asked = parseMessageTimestamp(requested);
+  if (asked !== null && asked >= floorMs) return requested;
+  return ageFloorValue(maxAgeDays, nowMs, format);
+}
 
 // src/lib/manifest-loader.ts
 var EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -3597,28 +3969,259 @@ function invalidManifestPreviewReason(manifest) {
   }
   return null;
 }
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0;
+}
+var VALID_FIELD_PATH_PARSE = ["address.name", "address.email", "epoch-ms"];
+function invalidFieldPathReason(label, value) {
+  if (isNonEmptyString(value)) return null;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return `${label} must be a non-empty string or a field-path object`;
+  }
+  const f = value;
+  if (!isNonEmptyString(f.path)) return `${label}.path must be a non-empty string`;
+  if (f.where !== void 0) {
+    if (f.where === null || typeof f.where !== "object" || Array.isArray(f.where)) {
+      return `${label}.where must be an object`;
+    }
+    for (const [k, v] of Object.entries(f.where)) {
+      if (typeof v !== "string" && typeof v !== "number" && typeof v !== "boolean") {
+        return `${label}.where.${k} must be a string, number, or boolean`;
+      }
+    }
+  }
+  if (f.pick !== void 0 && !isNonEmptyString(f.pick)) {
+    return `${label}.pick must be a non-empty string`;
+  }
+  if (f.parse !== void 0 && !VALID_FIELD_PATH_PARSE.includes(f.parse)) {
+    return `${label}.parse must be one of ${VALID_FIELD_PATH_PARSE.join(", ")}`;
+  }
+  return null;
+}
+function invalidContextReadReason(label, entry) {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    return `${label} must be an object`;
+  }
+  const r = entry;
+  if (!isNonEmptyString(r.tool)) return `${label}.tool must be a non-empty string`;
+  if (r.args === void 0 || r.args === null || typeof r.args !== "object" || Array.isArray(r.args)) {
+    return `${label}.args must be an object`;
+  }
+  for (const [k, v] of Object.entries(r.args)) {
+    if (typeof v !== "string" || v.length === 0) {
+      return `${label}.args.${k} must be a non-empty string`;
+    }
+  }
+  return null;
+}
+function invalidContextSourceReason(toolName, entry) {
+  const label = `context.sources.${toolName}`;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    return `${label} must be an object`;
+  }
+  const s = entry;
+  const readReason = invalidContextReadReason(`${label}.read`, s.read);
+  if (readReason) return readReason;
+  for (const field of ["title", "author", "at", "body"]) {
+    if (s[field] !== void 0) {
+      const reason = invalidFieldPathReason(`${label}.${field}`, s[field]);
+      if (reason) return reason;
+    }
+  }
+  if (s.keys !== void 0) {
+    if (s.keys === null || typeof s.keys !== "object" || Array.isArray(s.keys)) {
+      return `${label}.keys must be an object`;
+    }
+    for (const [k, v] of Object.entries(s.keys)) {
+      if (k !== "email") return `${label}.keys.${k}: only "email" is a recognized identity key type`;
+      const reason = invalidFieldPathReason(`${label}.keys.${k}`, v);
+      if (reason) return reason;
+    }
+  }
+  if (s.chain !== void 0) {
+    if (s.chain === null || typeof s.chain !== "object" || Array.isArray(s.chain)) {
+      return `${label}.chain must be an object`;
+    }
+    const c = s.chain;
+    if (!isNonEmptyString(c.field)) return `${label}.chain.field must be a non-empty string`;
+    if (typeof c.max !== "number" || c.max <= 0) return `${label}.chain.max must be a positive number`;
+  }
+  return null;
+}
+function invalidContextHistoryReason(history) {
+  const label = "context.history";
+  if (history === null || typeof history !== "object" || Array.isArray(history)) {
+    return `${label} must be an object`;
+  }
+  const h = history;
+  const isKeyType = (v) => v === "email" || v === "email_domain";
+  if (Array.isArray(h.byKey)) {
+    if (h.byKey.length === 0) return `${label}.byKey must not be an empty array`;
+    for (const [i, v] of h.byKey.entries()) {
+      if (!isKeyType(v)) return `${label}.byKey[${i}] must be "email" or "email_domain"`;
+    }
+  } else if (!isKeyType(h.byKey)) {
+    return `${label}.byKey must be "email" or "email_domain" (or an array of those, in preference order)`;
+  }
+  const readReason = invalidContextReadReason(`${label}.read`, h.read);
+  if (readReason) return readReason;
+  if (typeof h.limit !== "number" || h.limit <= 0) return `${label}.limit must be a positive number`;
+  if (typeof h.maxAgeDays !== "number" || h.maxAgeDays <= 0) return `${label}.maxAgeDays must be a positive number`;
+  if (h.item === null || typeof h.item !== "object" || Array.isArray(h.item)) {
+    return `${label}.item must be an object`;
+  }
+  for (const [k, v] of Object.entries(h.item)) {
+    if (k === "kind") {
+      if (!isNonEmptyString(v)) return `${label}.item.kind must be a non-empty string`;
+      continue;
+    }
+    const reason = invalidFieldPathReason(`${label}.item.${k}`, v);
+    if (reason) return reason;
+  }
+  return null;
+}
+function invalidContextRecordKeyReason(name, entry) {
+  const label = `context.recordKeys.${name}`;
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    return `${label} must be an object`;
+  }
+  const rk = entry;
+  const readReason = invalidContextReadReason(`${label}.read`, rk.read);
+  if (readReason) return readReason;
+  if (rk.keys !== void 0) {
+    if (rk.keys === null || typeof rk.keys !== "object" || Array.isArray(rk.keys)) {
+      return `${label}.keys must be an object`;
+    }
+    for (const [k, v] of Object.entries(rk.keys)) {
+      if (k !== "email") return `${label}.keys.${k}: only "email" is a recognized identity key type`;
+      const reason = invalidFieldPathReason(`${label}.keys.${k}`, v);
+      if (reason) return reason;
+    }
+  }
+  if (rk.next !== void 0) {
+    if (rk.next === null || typeof rk.next !== "object" || Array.isArray(rk.next)) {
+      return `${label}.next must be an object`;
+    }
+    const next = rk.next;
+    if (!isNonEmptyString(next.recordKey)) return `${label}.next.recordKey must be a non-empty string`;
+    if (!isNonEmptyString(next.field)) return `${label}.next.field must be a non-empty string`;
+  }
+  if (rk.keys === void 0 && rk.next === void 0) {
+    return `${label} must declare "keys", "next", or both \u2014 an entry with neither learns nothing from the record it reads`;
+  }
+  return null;
+}
+function recordKeyChainLength(name, recordKeys, seen) {
+  if (seen.has(name)) return "cycle";
+  const entry = recordKeys[name];
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return "missing";
+  const next = entry.next;
+  if (!next || typeof next !== "object") return 1;
+  const nextName = next.recordKey;
+  if (typeof nextName !== "string" || !(nextName in recordKeys)) return "missing";
+  const rest = recordKeyChainLength(nextName, recordKeys, /* @__PURE__ */ new Set([...seen, name]));
+  if (rest === "cycle" || rest === "missing") return rest;
+  return 1 + rest;
+}
+function invalidManifestContextReason(manifest) {
+  const ctx = manifest.context;
+  const recordKeyNames = new Set(Object.keys(ctx?.recordKeys ?? {}));
+  if (ctx) {
+    if (ctx.sources !== void 0) {
+      if (ctx.sources === null || typeof ctx.sources !== "object" || Array.isArray(ctx.sources)) {
+        return "context.sources must be an object";
+      }
+      for (const [kind, entry] of Object.entries(ctx.sources)) {
+        const reason = invalidContextSourceReason(kind, entry);
+        if (reason) return reason;
+      }
+    }
+    if (ctx.history !== void 0) {
+      const reason = invalidContextHistoryReason(ctx.history);
+      if (reason) return reason;
+    }
+    if (ctx.recordKeys !== void 0) {
+      if (ctx.recordKeys === null || typeof ctx.recordKeys !== "object" || Array.isArray(ctx.recordKeys)) {
+        return "context.recordKeys must be an object";
+      }
+      for (const [name, entry] of Object.entries(ctx.recordKeys)) {
+        const reason = invalidContextRecordKeyReason(name, entry);
+        if (reason) return reason;
+      }
+      for (const name of Object.keys(ctx.recordKeys)) {
+        const length = recordKeyChainLength(name, ctx.recordKeys, /* @__PURE__ */ new Set());
+        if (length === "cycle") {
+          return `context.recordKeys.${name}.next forms a cycle`;
+        }
+        if (length === "missing") {
+          return `context.recordKeys.${name}.next.recordKey names an entry this manifest does not declare`;
+        }
+        if (length > MAX_RECORD_KEY_STEPS) {
+          return `context.recordKeys.${name}.next chain is ${length} steps long \u2014 max ${MAX_RECORD_KEY_STEPS}`;
+        }
+      }
+    }
+  }
+  const sourceKinds = new Set(Object.keys(ctx?.sources ?? {}));
+  const overrides = manifest.toolGating?.overrides ?? {};
+  for (const [toolName, entry] of Object.entries(overrides)) {
+    if (entry === null || typeof entry !== "object") continue;
+    const e = entry;
+    if (e.contextKeys !== void 0) {
+      if (e.contextKeys === null || typeof e.contextKeys !== "object" || Array.isArray(e.contextKeys)) {
+        return `override "${toolName}".contextKeys must be an object`;
+      }
+      for (const [name, argName] of Object.entries(e.contextKeys)) {
+        if (!isNonEmptyString(argName)) {
+          return `override "${toolName}".contextKeys.${name} must be a non-empty string naming an action argument`;
+        }
+        if (name !== "email" && !recordKeyNames.has(name)) {
+          return `override "${toolName}".contextKeys.${name}: "${name}" is neither "email" nor a context.recordKeys entry on this manifest`;
+        }
+      }
+    }
+    if (e.sourceFromArg !== void 0) {
+      if (e.sourceFromArg === null || typeof e.sourceFromArg !== "object" || Array.isArray(e.sourceFromArg)) {
+        return `override "${toolName}".sourceFromArg must be an object`;
+      }
+      const sfa = e.sourceFromArg;
+      if (!isNonEmptyString(sfa.kind)) return `override "${toolName}".sourceFromArg.kind must be a non-empty string`;
+      if (!isNonEmptyString(sfa.arg)) return `override "${toolName}".sourceFromArg.arg must be a non-empty string`;
+      if (!sourceKinds.has(sfa.kind)) {
+        return `override "${toolName}".sourceFromArg.kind "${String(sfa.kind)}" is not declared in this manifest's context.sources`;
+      }
+    }
+  }
+  return null;
+}
+function invalidManifestReadGateReason(manifest) {
+  const profileDef = getProfile2(manifest.profile);
+  if (!profileDef) return null;
+  const overrides = manifest.toolGating?.overrides ?? {};
+  return uncoveredReadSwitchReason(overrides, profileDef.boundsSchema);
+}
 var manifests = /* @__PURE__ */ new Map();
 function loadManifests(integrationsDir) {
   const dir = resolve(
-    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join14(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
+    integrationsDir ?? process.env.SUVEREN_MANIFESTS_DIR ?? join15(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "content", "integrations")
   );
-  const indexPath = join14(dir, "index.json");
-  if (!existsSync14(indexPath)) {
+  const indexPath = join15(dir, "index.json");
+  if (!existsSync15(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"));
+    index = JSON.parse(readFileSync16(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);
+    const manifestPath = join15(dir, relativePath);
     try {
-      const manifest = JSON.parse(readFileSync15(manifestPath, "utf-8"));
+      const manifest = JSON.parse(readFileSync16(manifestPath, "utf-8"));
       const pinReason = invalidNpmPinReason(manifest);
       if (pinReason) {
         console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${pinReason}`);
@@ -3629,6 +4232,16 @@ function loadManifests(integrationsDir) {
         console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${previewReason}`);
         continue;
       }
+      const contextReason = invalidManifestContextReason(manifest);
+      if (contextReason) {
+        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${contextReason}`);
+        continue;
+      }
+      const readGateReason = invalidManifestReadGateReason(manifest);
+      if (readGateReason) {
+        console.error(`[ManifestLoader] Refusing manifest ${id} (${manifestPath}): ${readGateReason}`);
+        continue;
+      }
       manifests.set(id, manifest);
       loaded++;
     } catch (err) {
@@ -3897,20 +4510,436 @@ async function buildInternalPreview(integrationManager2, integrationId, toolName
   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 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/field-path.ts
+function matchesWhere(element, where) {
+  if (element === null || typeof element !== "object" || Array.isArray(element)) return false;
+  const row = element;
+  return Object.entries(where).every(([key, expected]) => {
+    const actual = row[key];
+    if (typeof expected === "string" && typeof actual === "string") {
+      return expected.toLowerCase() === actual.toLowerCase();
+    }
+    return actual === expected;
+  });
+}
+function parseAddress(value, which) {
+  const m = value.match(/^(.*?)<([^<>]+)>\s*$/);
+  if (m) {
+    const email = m[2].trim();
+    if (which === "address.email") return email || void 0;
+    const name = m[1].trim().replace(/^"(.*)"$/, "$1").trim();
+    return name || void 0;
+  }
+  if (which === "address.email") return value.trim() || void 0;
+  return void 0;
+}
+function parseEpochMs(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isFinite(n)) return void 0;
+  return new Date(n).toISOString();
+}
+function applyParse(value, parse2) {
+  if (value === void 0 || value === null) return void 0;
+  if (parse2 === "epoch-ms") return parseEpochMs(value);
+  if (typeof value !== "string") return void 0;
+  return parseAddress(value, parse2);
+}
+function resolveFieldPath(record, fieldPath) {
+  if (fieldPath === void 0) return void 0;
+  if (typeof fieldPath === "string") return getByDottedPath(record, fieldPath);
+  let value = getByDottedPath(record, fieldPath.path);
+  if (fieldPath.where) {
+    if (!Array.isArray(value)) return void 0;
+    value = value.find((el) => matchesWhere(el, fieldPath.where));
+    if (value === void 0) return void 0;
+  }
+  if (fieldPath.pick !== void 0) {
+    value = getByDottedPath(value, fieldPath.pick);
+  }
+  if (fieldPath.parse) {
+    value = applyParse(value, fieldPath.parse);
+  }
+  return value;
+}
+
+// src/lib/request-context.ts
+var SOURCE_LINK_ARG = "_source";
+function withSourceLink(schema) {
+  const props = schema.properties ?? {};
+  if ("_source" in props) return schema;
+  return {
+    ...schema,
+    properties: {
+      ...props,
+      _source: {
+        type: "object",
+        description: 'Optional. Link the request you are answering \u2014 the ONE record (e.g. an inbound email) this action responds to, so the human approver can see why it was proposed. Only a reference: {"connector": "<integration id>", "kind": "<declared kind>", "id": "<record id>"}. Example: {"connector":"mail","kind":"message","id":"m-17"}. The gateway reads the record itself \u2014 never write a summary or quote here.',
+        properties: {
+          connector: { type: "string" },
+          kind: { type: "string" },
+          id: { type: "string" }
+        }
+      }
+    }
+  };
+}
+function stripSourceLink(args) {
+  if (!(SOURCE_LINK_ARG in args)) return args;
+  const { [SOURCE_LINK_ARG]: _omit, ...rest } = args;
+  return rest;
+}
+var FREE_MAIL_DOMAINS = /* @__PURE__ */ new Set([
+  "gmail.com",
+  "googlemail.com",
+  "outlook.com",
+  "hotmail.com",
+  "hotmail.co.uk",
+  "hotmail.fr",
+  "hotmail.de",
+  "live.com",
+  "msn.com",
+  "yahoo.com",
+  "yahoo.co.uk",
+  "yahoo.de",
+  "yahoo.fr",
+  "ymail.com",
+  "rocketmail.com",
+  "gmx.de",
+  "gmx.net",
+  "gmx.at",
+  "gmx.ch",
+  "gmx.com",
+  "web.de",
+  "t-online.de",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "aol.com",
+  "protonmail.com",
+  "proton.me",
+  "mail.com",
+  "zoho.com",
+  "yandex.com"
+]);
+function isFreeMailDomain(domain) {
+  return FREE_MAIL_DOMAINS.has(domain.toLowerCase());
+}
+function deriveIdentityKeysFromEmail(email) {
+  const lower = email.toLowerCase().trim();
+  const at = lower.lastIndexOf("@");
+  if (at <= 0 || at === lower.length - 1) return [];
+  const domain = lower.slice(at + 1);
+  const keys = [{ type: "email", value: lower }];
+  if (!isFreeMailDomain(domain)) keys.push({ type: "email_domain", value: domain });
+  return keys;
+}
+function deriveIdentityKeysFromValue(value) {
+  if (typeof value === "string") return deriveIdentityKeysFromEmail(value);
+  if (Array.isArray(value)) {
+    return value.flatMap((v) => typeof v === "string" ? deriveIdentityKeysFromEmail(v) : []);
+  }
+  return [];
+}
+function dedupeKeys(keys) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const k of keys) {
+    const sig = `${k.type}:${k.value}`;
+    if (seen.has(sig)) continue;
+    seen.add(sig);
+    out.push(k);
+  }
+  return out;
+}
+function substitute(template, values) {
+  const out = {};
+  for (const [arg, token] of Object.entries(template)) {
+    if (token.startsWith("$")) {
+      const key = token.slice(1);
+      if (key in values) out[arg] = values[key];
+    } else {
+      out[arg] = token;
+    }
+  }
+  return out;
+}
+function parseContextBody(body) {
+  if (body.structured !== void 0) return body.structured;
+  if (body.text !== void 0) {
+    try {
+      return JSON.parse(body.text);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+async function readContextRecord(integrationManager2, connectorId, tool, args) {
+  const read = await readPreview(integrationManager2, connectorId, tool, args);
+  if (read.status === "ok") {
+    const record = parseContextBody(read.body);
+    if (record === void 0) return { status: "unavailable", reason: "connector_error" };
+    return { status: "ok", record };
+  }
+  if (read.status === "not_found") return { status: "not_found" };
+  return { status: "unavailable", reason: read.reason };
+}
+function parseExplicitSourceLink(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "object" || Array.isArray(raw)) return "invalid";
+  const o = raw;
+  if (typeof o.connector !== "string" || !o.connector) return "invalid";
+  if (typeof o.kind !== "string" || !o.kind) return "invalid";
+  if (typeof o.id !== "string" || !o.id) return "invalid";
+  return { connector: o.connector, kind: o.kind, id: o.id };
+}
+function resolveSourceLink(toolArgs, connectorId, sourceFromArg) {
+  const explicit = parseExplicitSourceLink(toolArgs._source);
+  if (explicit !== void 0) return explicit;
+  if (sourceFromArg) {
+    const argVal = toolArgs[sourceFromArg.arg];
+    if (typeof argVal === "string" && argVal) {
+      return { connector: connectorId, kind: sourceFromArg.kind, id: argVal };
+    }
+  }
+  return void 0;
+}
+async function readSourceOnce(integrationManager2, link, sourceConfig) {
+  const args = substitute(sourceConfig.read.args, { id: link.id });
+  const read = await readContextRecord(integrationManager2, link.connector, sourceConfig.read.tool, args);
+  if (read.status === "not_found") return { status: "not_found" };
+  if (read.status === "unavailable") return { status: "unreadable", reason: read.reason };
+  const keys = [];
+  if (sourceConfig.keys?.email) {
+    const v = resolveFieldPath(read.record, sourceConfig.keys.email);
+    if (typeof v === "string" && v) keys.push(...deriveIdentityKeysFromEmail(v));
+  }
+  return { record: read.record, keys };
+}
+async function resolveRequestContext(integrationManager2, toolArgs, actionConnectorId, sourceFromArg, configuredConnectorIds) {
+  const link = resolveSourceLink(toolArgs, actionConnectorId, sourceFromArg);
+  if (link === void 0) return { result: { status: "none" }, keys: [] };
+  if (link === "invalid") {
+    return { result: { status: "unreadable", reason: "malformed link" }, keys: [] };
+  }
+  if (!configuredConnectorIds.has(link.connector)) {
+    return { result: { status: "unreadable", reason: "connector not installed" }, keys: [] };
+  }
+  const connectorManifest = getManifest(link.connector);
+  if (!connectorManifest) {
+    return { result: { status: "unreadable", reason: "connector not installed" }, keys: [] };
+  }
+  const sourceConfig = connectorManifest.context?.sources?.[link.kind];
+  if (!sourceConfig) {
+    return { result: { status: "unreadable", reason: `connector "${link.connector}" declares no "${link.kind}" source` }, keys: [] };
+  }
+  const primary = await readSourceOnce(integrationManager2, link, sourceConfig);
+  if ("status" in primary) {
+    if (primary.status === "not_found") return { result: { status: "not_found" }, keys: [] };
+    return { result: { status: "unreadable", reason: primary.reason ?? "connector unreachable" }, keys: [] };
+  }
+  const implicit = toolArgs._source === void 0;
+  const base = {
+    connector: link.connector,
+    kind: link.kind,
+    implicit,
+    ...sourceConfig.title ? { title: asString(resolveFieldPath(primary.record, sourceConfig.title)) } : {},
+    ...sourceConfig.author ? { author: asString(resolveFieldPath(primary.record, sourceConfig.author)) } : {},
+    ...sourceConfig.at ? { at: asString(resolveFieldPath(primary.record, sourceConfig.at)) } : {},
+    ...sourceConfig.body ? { body: asBody(resolveFieldPath(primary.record, sourceConfig.body)) } : {}
+  };
+  const chain = [];
+  if (sourceConfig.chain) {
+    let currentId = asString(getByDottedPath(primary.record, sourceConfig.chain.field));
+    let hops = 0;
+    const seen = /* @__PURE__ */ new Set([link.id]);
+    while (currentId && hops < sourceConfig.chain.max && !seen.has(currentId)) {
+      seen.add(currentId);
+      const hopLink = { connector: link.connector, kind: link.kind, id: currentId };
+      const hop = await readSourceOnce(integrationManager2, hopLink, sourceConfig);
+      hops++;
+      if ("status" in hop) break;
+      chain.push({
+        ...sourceConfig.author ? { author: asString(resolveFieldPath(hop.record, sourceConfig.author)) } : {},
+        ...sourceConfig.at ? { at: asString(resolveFieldPath(hop.record, sourceConfig.at)) } : {},
+        ...sourceConfig.title ? { title: asString(resolveFieldPath(hop.record, sourceConfig.title)) } : {},
+        ...sourceConfig.body ? { body: asBody(resolveFieldPath(hop.record, sourceConfig.body)) } : {}
+      });
+      currentId = sourceConfig.chain ? asString(getByDottedPath(hop.record, sourceConfig.chain.field)) : void 0;
+    }
+  }
+  return { result: { status: "ok", ...base, chain }, keys: primary.keys };
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+var REQUEST_BODY_CAP = 2e4;
+function asBody(v) {
+  const s = asString(v);
+  return s === void 0 ? void 0 : s.length > REQUEST_BODY_CAP ? s.slice(0, REQUEST_BODY_CAP) : s;
+}
+async function resolveRecordKeyChain(integrationManager2, connectorId, manifest, recordKeyName, idValue, stepsLeft) {
+  if (stepsLeft <= 0) return [];
+  const recordKey = manifest.context?.recordKeys?.[recordKeyName];
+  if (!recordKey) return [];
+  const args = substitute(recordKey.read.args, { id: idValue });
+  const read = await readContextRecord(integrationManager2, connectorId, recordKey.read.tool, args);
+  if (read.status !== "ok") return [];
+  const out = [];
+  const emailField = recordKey.keys?.email;
+  if (emailField) {
+    const v = resolveFieldPath(read.record, emailField);
+    if (typeof v === "string" && v) out.push(...deriveIdentityKeysFromEmail(v));
+  }
+  if (recordKey.next) {
+    const nextId = asString(getByDottedPath(read.record, recordKey.next.field));
+    if (nextId) {
+      out.push(
+        ...await resolveRecordKeyChain(
+          integrationManager2,
+          connectorId,
+          manifest,
+          recordKey.next.recordKey,
+          nextId,
+          stepsLeft - 1
+        )
+      );
+    }
+  }
+  return out;
+}
+async function gatherContextKeysFromAction(integrationManager2, connectorId, contextKeys, toolArgs) {
+  if (!contextKeys) return [];
+  const manifest = getManifest(connectorId);
+  const out = [];
+  for (const [name, argName] of Object.entries(contextKeys)) {
+    const raw = toolArgs[argName];
+    if (raw === void 0 || raw === null) continue;
+    if (name === "email") {
+      out.push(...deriveIdentityKeysFromValue(raw));
+      continue;
+    }
+    if (!manifest?.context?.recordKeys?.[name] || typeof raw !== "string" || !raw) continue;
+    out.push(...await resolveRecordKeyChain(integrationManager2, connectorId, manifest, name, raw, MAX_RECORD_KEY_STEPS));
+  }
+  return out;
+}
+function mapHistoryItem(raw, mapping) {
+  return {
+    // `kind` is a literal label, copied as-is — never a path (doc §8.1).
+    ...mapping.kind ? { kind: mapping.kind } : {},
+    ...mapping.title ? { title: asString(resolveFieldPath(raw, mapping.title)) } : {},
+    ...mapping.body ? { body: asBody(resolveFieldPath(raw, mapping.body)) } : {},
+    ...mapping.at ? { at: asString(resolveFieldPath(raw, mapping.at)) } : {},
+    ...mapping.author ? { author: asString(resolveFieldPath(raw, mapping.author)) } : {},
+    ...mapping.type ? { type: asString(resolveFieldPath(raw, mapping.type)) } : {}
+  };
+}
+function withinWindow(at, cutoffMs) {
+  if (!at) return true;
+  const ms = Date.parse(at);
+  if (Number.isNaN(ms)) return true;
+  return ms >= cutoffMs;
+}
+function chooseHistoryKey(byKey, keys) {
+  const order = Array.isArray(byKey) ? byKey : [byKey];
+  for (const type of order) {
+    const found = keys.find((k) => k.type === type);
+    if (found) return found;
+  }
+  return void 0;
+}
+function resolveHistoryArgsTemplate(template, keyType) {
+  const out = {};
+  for (const [argName, token] of Object.entries(template)) {
+    out[argName === "$keyType" ? keyType : argName] = token;
   }
-  const stale = String(current) !== String(approved);
-  return ok({
-    version: {
-      field: preview.version.field,
-      approved,
-      current,
-      stale,
-      ...stale ? { currentBody: read2.body } : {}
-    }
+  return out;
+}
+async function readConnectorHistory(integrationManager2, connectorId, history, keys, executionJournal) {
+  const key = chooseHistoryKey(history.byKey, keys);
+  if (!key) return { status: "no_match" };
+  const sinceMs = Date.now() - history.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const args = substitute(resolveHistoryArgsTemplate(history.read.args, key.type), {
+    key: key.value,
+    since: new Date(sinceMs).toISOString(),
+    limit: history.limit
   });
+  const read = await readContextRecord(integrationManager2, connectorId, history.read.tool, args);
+  if (read.status !== "ok") return { status: "unreachable" };
+  const rows = Array.isArray(read.record) ? read.record : [];
+  const items = [];
+  for (const row of rows.slice(0, history.limit)) {
+    const item = mapHistoryItem(row, history.item);
+    if (!withinWindow(item.at, sinceMs)) continue;
+    if (history.item.ticket) {
+      const ticketId = asString(resolveFieldPath(row, history.item.ticket));
+      if (ticketId) {
+        const entry = executionJournal.get(ticketId);
+        if (entry?.state === "done") {
+          item.aiWritten = { at: entry.finishedAt ? entry.finishedAt * 1e3 : void 0 };
+        }
+      }
+    }
+    items.push(item);
+  }
+  return { status: "ok", match: { connectorId, matchedKeyType: key.type, matchedKeyValue: key.value, items } };
+}
+async function buildHistory(integrationManager2, keys, executionJournal, configuredConnectorIds) {
+  if (keys.length === 0) return { status: "no_customer_link" };
+  const connectors = getAllManifests().filter((m) => m.context?.history && configuredConnectorIds.has(m.id));
+  if (connectors.length === 0) return { status: "no_match" };
+  const matches = [];
+  const unreachable = [];
+  let anyMatchedType = false;
+  for (const manifest of connectors) {
+    const history = manifest.context.history;
+    const outcome = await readConnectorHistory(integrationManager2, manifest.id, history, keys, executionJournal);
+    if (outcome.status === "no_match") continue;
+    anyMatchedType = true;
+    if (outcome.status === "unreachable") {
+      unreachable.push(manifest.id);
+      continue;
+    }
+    matches.push(outcome.match);
+  }
+  if (!anyMatchedType) return { status: "no_match" };
+  if (matches.length === 0 && unreachable.length > 0) return { status: "unreachable", connectorIds: unreachable };
+  return { status: "ok", matches, unreachableConnectorIds: unreachable };
+}
+async function buildRequestContext(integrationManager2, executionJournal, actionConnectorId, toolArgs, actionGating, configuredConnectorIds) {
+  const { result: request, keys: sourceKeys } = await resolveRequestContext(
+    integrationManager2,
+    toolArgs,
+    actionConnectorId,
+    actionGating?.sourceFromArg,
+    configuredConnectorIds
+  );
+  const actionKeys = await gatherContextKeysFromAction(
+    integrationManager2,
+    actionConnectorId,
+    actionGating?.contextKeys,
+    toolArgs
+  );
+  const keys = dedupeKeys([...actionKeys, ...sourceKeys]);
+  const history = await buildHistory(integrationManager2, keys, executionJournal, configuredConnectorIds);
+  return { request, history };
 }
 
 // src/lib/ticket-verify.ts
@@ -3981,8 +5010,8 @@ async function verifyTicket(cache, receipt, expected) {
   if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
     throw new TicketBindingMismatchError("Ticket carries no valid timestamp \u2014 refusing to execute.");
   }
-  const nowSec3 = Math.floor(Date.now() / 1e3);
-  const ageSec = nowSec3 - timestamp;
+  const nowSec4 = Math.floor(Date.now() / 1e3);
+  const ageSec = nowSec4 - timestamp;
   if (ageSec > TICKET_MAX_AGE_SECONDS) {
     throw new TicketBindingMismatchError(
       `Ticket is ${ageSec}s old, older than the ${TICKET_MAX_AGE_SECONDS}s freshness window \u2014 refusing to execute.`
@@ -4116,191 +5145,34 @@ function normalizeIncomingArgs(tool, args) {
   return out ?? args;
 }
 
-// src/lib/scope-specificity.ts
-function tokenSet(value) {
-  if (value === void 0 || value === null) return /* @__PURE__ */ new Set();
-  return new Set(
-    String(value).split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
-  );
-}
-function subsetOrEqual(a, b) {
-  if (b.size === 0) return true;
-  if (a.size === 0) return false;
-  for (const x of a) if (!b.has(x)) return false;
-  return true;
-}
-function atLeastAsSpecific(keys, a, b) {
-  for (const k of keys) {
-    if (!subsetOrEqual(tokenSet(a[k]), tokenSet(b[k]))) return false;
-  }
-  return true;
-}
-function strictlyMoreSpecific(keys, a, b) {
-  return atLeastAsSpecific(keys, a, b) && !atLeastAsSpecific(keys, b, a);
-}
-function selectAuthorization(contextKeys, passers) {
-  if (passers.length === 1) {
-    return { chosen: passers[0], superseded: [], reason: "sole" };
-  }
-  const dominators = passers.filter(
-    (a) => passers.every((b) => b === a || strictlyMoreSpecific(contextKeys, a.context, b.context))
-  );
-  if (dominators.length === 1) {
-    const chosen2 = dominators[0];
-    return { chosen: chosen2, superseded: passers.filter((p) => p !== chosen2), reason: "most-specific" };
-  }
-  const approvers = passers.filter((p) => p.requiresApproval);
-  const pool = approvers.length > 0 ? approvers : passers;
-  const chosen = pool.slice().sort((a, b) => a.id.localeCompare(b.id))[0];
-  return {
-    chosen,
-    superseded: passers.filter((p) => p !== chosen),
-    reason: approvers.length > 0 ? "fail-safe-approval" : "fail-safe-tiebreak"
-  };
-}
-
-// src/lib/read-gate.ts
-function boundsSatisfyReadGate(bounds, gate) {
-  if (!gate.boundField) return true;
-  const actual = bounds?.[gate.boundField];
-  return actual !== void 0 && String(actual) === gate.requiredValue;
-}
-function readToolIsGoverned(g) {
-  if (!g) return false;
-  return Boolean(g.boundField) || g.read != null || g.readGovernance === "none";
+// src/lib/numeric-execution.ts
+import { getProfile as getProfile3 } from "@hap/core";
+function parseNumericString(value) {
+  if (!/^-?\d+(\.\d+)?$/.test(value)) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
 }
-function allowedResources(contexts, boundField) {
+function declaredNumericFields(profile) {
   const out = /* @__PURE__ */ new Set();
-  for (const ctx of contexts) {
-    for (const v of tokenSet(ctx?.[boundField])) out.add(v);
-  }
-  return out;
-}
-function deniedResources(requested, allowed) {
-  return requested.filter((r) => !allowed.has(r));
-}
-function filterItemsByResource(items, idPath, allowed) {
-  return items.filter((it) => {
-    const id = getByDottedPath(it, idPath);
-    return typeof id === "string" && allowed.has(id);
-  });
-}
-function hasBlockedValue(item, valuesPath, blocked) {
-  const v = getByDottedPath(item, valuesPath);
-  const arr = Array.isArray(v) ? v : v != null ? [v] : [];
-  return arr.some((x) => typeof x === "string" && blocked.has(x));
-}
-var MS_PER_DAY = 24 * 60 * 60 * 1e3;
-function parseMessageTimestamp(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim() !== "") {
-    const n = Number(value);
-    if (Number.isFinite(n)) return n;
-    const iso = Date.parse(value);
-    if (Number.isFinite(iso)) return iso;
-  }
-  return null;
-}
-function ageInDays(timestampMs, nowMs) {
-  return Math.floor((nowMs - timestampMs) / MS_PER_DAY);
-}
-function maxReadAgeDays(boundsList, field) {
-  let max = null;
-  for (const b of boundsList) {
-    const raw = b?.[field];
-    const n = typeof raw === "number" ? raw : raw !== void 0 ? Number(raw) : NaN;
-    if (Number.isFinite(n)) max = max === null ? n : Math.max(max, n);
-  }
-  return max;
-}
-function isOlderThanMaxAge(timestampMs, maxAgeDays, nowMs) {
-  if (timestampMs === null) return true;
-  return ageInDays(timestampMs, nowMs) > maxAgeDays;
-}
-var TRAILING_OPERATOR = /(?:^|\s)(?:OR|AND|NOT)$|[-+|&:]$/i;
-function parensBalanced(s) {
-  let depth = 0;
-  let inQuote = false;
-  for (const c of s) {
-    if (c === '"') {
-      inQuote = !inQuote;
-      continue;
-    }
-    if (inQuote) continue;
-    if (c === "(") depth++;
-    else if (c === ")" && --depth < 0) return false;
-  }
-  return !inQuote && depth === 0;
-}
-function composeReadQuery(agentQuery, clauses) {
-  const injected = clauses.filter((c) => typeof c === "string" && c.trim() !== "").map((c) => c.trim());
-  const base = (agentQuery ?? "").trim();
-  if (base === "") return { ok: true, query: injected.join(" ") };
-  if (!parensBalanced(base)) {
-    return { ok: false, reason: "the requested search query has unbalanced parentheses" };
-  }
-  if (TRAILING_OPERATOR.test(base)) {
-    return { ok: false, reason: "the requested search query ends in a dangling operator" };
-  }
-  if (injected.length === 0) return { ok: true, query: base };
-  return { ok: true, query: `(${base}) ${injected.join(" ")}` };
-}
-function detectAgeConflict(agentQuery, conflictPattern, maxAgeDays) {
-  if (!agentQuery || !conflictPattern || maxAgeDays === null) return null;
-  let re;
-  try {
-    re = new RegExp(conflictPattern, "gi");
-  } catch {
-    return null;
-  }
-  let worst = null;
-  for (const match of agentQuery.matchAll(re)) {
-    const days = Number(match[1]);
-    if (!Number.isFinite(days)) continue;
-    if (days >= maxAgeDays && (worst === null || days > worst)) worst = days;
-  }
-  return worst;
-}
-function resolveAgeBoundField(boundsSchema, ageExecField) {
-  const fields = boundsSchema?.fields;
-  if (!fields) return null;
+  const fields = profile?.executionContextSchema?.fields;
+  if (!fields) return out;
   for (const [name, def] of Object.entries(fields)) {
-    if (def?.boundType?.kind === "per_transaction" && def.boundType.of === ageExecField) return name;
+    if (def.source === "declared" && def.constraint?.type === "number") out.add(name);
   }
-  return null;
-}
-function getByDottedPath(obj, path) {
-  return path.split(".").reduce(
-    (o, k) => o == null ? void 0 : o[k],
-    obj
-  );
+  return out;
 }
-function firstParsableDate(obj, paths) {
-  for (const path of Array.isArray(paths) ? paths : [paths]) {
-    const parsed = parseMessageTimestamp(getByDottedPath(obj, path));
-    if (parsed !== null) return parsed;
+function coerceDeclaredNumericFields(profileId, execution) {
+  const fields = declaredNumericFields(getProfile3(profileId));
+  for (const field of fields) {
+    const value = execution[field];
+    if (typeof value !== "string") continue;
+    const parsed = parseNumericString(value);
+    if (parsed !== void 0) execution[field] = parsed;
   }
-  return null;
-}
-function renderAgeConstraint(template, maxAgeDays, nowMs) {
-  const floorIso = new Date(nowMs - maxAgeDays * MS_PER_DAY).toISOString();
-  return template.replace(/\{days\}/g, String(maxAgeDays)).replace(/\{date\}/g, floorIso.slice(0, 10));
-}
-function ageFloorValue(maxAgeDays, nowMs, format = "iso") {
-  const floorMs = nowMs - maxAgeDays * MS_PER_DAY;
-  if (format === "epoch_ms") return floorMs;
-  if (format === "epoch_s") return String(Math.floor(floorMs / 1e3));
-  return new Date(floorMs).toISOString();
-}
-function clampAgeFloor(requested, maxAgeDays, nowMs, format = "iso") {
-  const floorMs = nowMs - maxAgeDays * MS_PER_DAY;
-  const asked = parseMessageTimestamp(requested);
-  if (asked !== null && asked >= floorMs) return requested;
-  return ageFloorValue(maxAgeDays, nowMs, format);
 }
 
 // src/lib/tool-proxy.ts
-import { getProfile as getProfile2, ContentBindingError, boundActionTypes as boundActionTypes2 } from "@hap/core";
+import { getProfile as getProfile4, ContentBindingError, boundActionTypes as boundActionTypes2 } from "@hap/core";
 import { readFile } from "fs/promises";
 import { extname } from "path";
 import { randomUUID } from "crypto";
@@ -4372,7 +5244,7 @@ function profileMatches(profileId, shortName2) {
   return profileId === shortName2 || profileId.includes("/" + shortName2 + "@") || profileId.endsWith("/" + shortName2);
 }
 function wireExecutionContext(profileId, execution) {
-  const profile = getProfile2(profileId);
+  const profile = getProfile4(profileId);
   const allowed = /* @__PURE__ */ new Set(["action_type"]);
   const fields = profile?.boundsSchema?.fields;
   if (fields) {
@@ -4390,7 +5262,7 @@ function wireExecutionContext(profileId, execution) {
   return out;
 }
 function countBoundsFor(profileId, actionType) {
-  const fields = getProfile2(profileId)?.boundsSchema?.fields;
+  const fields = getProfile4(profileId)?.boundsSchema?.fields;
   if (!fields) return null;
   return Object.entries(fields).filter(([, def]) => def.boundType?.kind === "cumulative_count").filter(([name, def]) => {
     const applies = boundActionTypes2(name, def);
@@ -4465,7 +5337,7 @@ function recordBlocked(state2, tool, 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 scoped = pick.field ? Boolean(getProfile4(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",
@@ -4565,7 +5437,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       };
     };
   }
-  const { profile, executionMapping, staticExecution, category } = tool.gating;
+  const { profile, executionMapping, staticExecution, category, boundField: toolBoundField, requiredValue: toolRequiredValue } = tool.gating;
   const eligibleMandates = () => {
     const refusals = [];
     const matching = state2.getEnrichedAuthorizations().filter((a) => a.complete && profileMatches(a.profileId, profile)).filter((a) => {
@@ -4644,7 +5516,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
           );
         }
       }
-      const readProfile = readAdapter ? getProfile2(matchingAuths[0].profileId) : void 0;
+      const readProfile = readAdapter ? getProfile4(matchingAuths[0].profileId) : void 0;
       const boundsSchema = readProfile?.boundsSchema;
       const ageBoundField = readAdapter?.ageField ? resolveAgeBoundField(boundsSchema, readAdapter.ageField) : null;
       const hasAgeDimension = Boolean(readAdapter?.ageField);
@@ -4789,6 +5661,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
         }
       }
     }
+    coerceDeclaredNumericFields(profile, execution);
     const declaredActionType = typeof execution.action_type === "string" && execution.action_type.length > 0 ? execution.action_type : void 0;
     if (!declaredActionType) {
       recordBlocked(state2, tool, {
@@ -4807,7 +5680,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       };
     }
     {
-      const profileDef = getProfile2(profile);
+      const profileDef = getProfile4(profile);
       const registry = profileDef?.boundsSchema?.actionTypes;
       if (Array.isArray(registry) && registry.length > 0 && !registry.includes(declaredActionType)) {
         recordBlocked(state2, tool, {
@@ -4845,6 +5718,25 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
     const passers = [];
     const structuredRefusals = [];
     for (const candidate of matchingAuths) {
+      if (toolBoundField) {
+        const gateOk = boundsSatisfyReadGate(
+          candidate.bounds ?? candidate.frame,
+          { boundField: toolBoundField, requiredValue: toolRequiredValue }
+        );
+        if (!gateOk) {
+          errors.push(
+            `${candidate.path}: requires "${toolBoundField}: ${toolRequiredValue}", but this authorization does not grant it`
+          );
+          structuredRefusals.push({
+            authorizationId: candidate.authorizationId,
+            profileId: candidate.profileId,
+            code: "BOUND_EXCEEDED",
+            field: toolBoundField,
+            bound: toolRequiredValue
+          });
+          continue;
+        }
+      }
       const { result } = await state2.gatekeeper.verifyExecution(candidate.authorizationId, execution, {
         bounds: candidate.bounds,
         context: candidate.context
@@ -4892,7 +5784,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
         isError: true
       };
     }
-    const contextKeys = getProfile2(passers[0].profileId)?.scopeSchema?.keyOrder ?? [];
+    const contextKeys = getProfile4(passers[0].profileId)?.scopeSchema?.keyOrder ?? [];
     return attemptWithCandidates(passers);
     async function attemptWithCandidates(candidates) {
       const selection = selectAuthorization(
@@ -5194,6 +6086,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.` + a
       let outgoingArgs = shouldAttachFooter() && receiptId ? appendVerificationFooter(tool, args, receiptId, auth.subjects?.[0]) : args;
       if (receiptId) outgoingArgs = attachTicketId(tool, outgoingArgs, receiptId);
       outgoingArgs = encodeOutgoingArgs(tool, outgoingArgs);
+      outgoingArgs = stripSourceLink(outgoingArgs);
       if (receiptId) {
         const begun = state2.executionJournal.begin({
           ticketId: receiptId,
@@ -5270,7 +6163,8 @@ function agentVisibleAuthorizations(authorizations, integrationManager2) {
 // src/lib/agent-rules.ts
 var AGENT_RULES = [
   "Never open or operate the Suveren Gateway's web page \u2014 not in a browser you control, not with computer use. Never ask for, read or type the person's API key. Never approve a proposal: approvals are the person's alone.",
-  "Use only the Suveren tools. No terminal, HTTP or browser calls to the gateway's ports (for example `curl localhost:3500/mcp`)."
+  "Use only the Suveren tools. No terminal, HTTP or browser calls to the gateway's ports (for example `curl localhost:3500/mcp`).",
+  "When a tool offers an optional `_source` argument, set it to link the ONE record (e.g. an inbound email) you are acting on \u2014 just the reference ({connector, kind, id}), never a summary or quote; the gateway reads the record itself for the approver."
 ];
 
 // src/lib/mandate-brief.ts
@@ -5350,7 +6244,7 @@ function buildMandateBrief(opts) {
       const parts = [];
       if (boundsDesc) parts.push(boundsDesc);
       if (executionLog) {
-        const profile = getProfile3(auth.profileId) ?? getProfile3(shortName2);
+        const profile = getProfile5(auth.profileId) ?? getProfile5(shortName2);
         const consumption = getConsumptionState(auth, executionLog, profile);
         const compact = formatConsumptionCompact(consumption);
         if (compact) parts.push(compact);
@@ -5388,7 +6282,7 @@ function buildMandateBrief(opts) {
 }
 
 // src/tools/authorizations.ts
-import { getProfile as getProfile4 } from "@hap/core";
+import { getProfile as getProfile6 } from "@hap/core";
 function shortProfileName2(profileId) {
   const withoutVersion = profileId.replace(/@.*$/, "");
   const parts = withoutVersion.split("/");
@@ -5506,7 +6400,7 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
         } catch {
         }
         const shortName2 = shortProfileName2(auth.profileId);
-        const profile = getProfile4(auth.profileId) ?? getProfile4(shortName2);
+        const profile = getProfile6(auth.profileId) ?? getProfile6(shortName2);
         if (profile) {
           const consumption = getConsumptionState(auth, state2.executionLog, profile);
           const consumptionText = formatConsumptionFull(consumption);
@@ -5566,7 +6460,7 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
           lines.push("    Mode: review (each action requires your approval)");
         }
         const shortName2 = shortProfileName2(auth.profileId);
-        const profile = getProfile4(auth.profileId) ?? getProfile4(shortName2);
+        const profile = getProfile6(auth.profileId) ?? getProfile6(shortName2);
         if (profile) {
           const consumption = getConsumptionState(auth, state2.executionLog, profile);
           const compact = formatConsumptionCompact(consumption);
@@ -5759,6 +6653,18 @@ async function decryptRejectionNote(by) {
 }
 
 // src/tools/commitments.ts
+function recordExecutionOutcome(state2, proposalId, ticketId, ok, text, structuredContent) {
+  try {
+    state2.executionResults?.record({ proposalId, ticketId, ok, text, structuredContent });
+  } catch (err) {
+    console.error(`[Suveren MCP] Could not record the execution result for proposal ${proposalId}:`, err);
+  }
+}
+function logExecutionOutcome(proposalId, ok, shortMessage) {
+  console.error(
+    `[Suveren MCP] Proposal ${proposalId}: execution outcome=${ok ? "ok" : `error (${shortMessage ?? "unknown"})`}`
+  );
+}
 function buildSkippedProposalNote(proposalId) {
   return `Proposal ${proposalId} was approved, but was submitted from another device/installation of this operator (or one whose local record is gone) \u2014 this gateway will not execute it. Re-run the same request here to execute it from this gateway.`;
 }
@@ -6020,16 +6926,24 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       outgoingArgs = attachTicketId(discovered, outgoingArgs, receiptId);
       outgoingArgs = encodeOutgoingArgs(discovered, outgoingArgs);
     }
+    outgoingArgs = stripSourceLink(outgoingArgs);
     let result;
     try {
       result = await integrationManager2.callTool(integrationId, toolName, outgoingArgs);
     } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
       state2.executionJournal.complete(receiptId, "failed");
+      recordExecutionOutcome(state2, proposal.id, receiptId, false, `The tool call threw: ${msg}`);
+      logExecutionOutcome(proposal.id, false, err instanceof Error ? err.name : "thrown error");
+      void notifyControlPlane("execution-failed");
       throw err;
     }
     const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
     if (result.isError) {
       state2.executionJournal.complete(receiptId, "failed", "refused", resultText);
+      recordExecutionOutcome(state2, proposal.id, receiptId, false, resultText);
+      logExecutionOutcome(proposal.id, false, "the connector returned an error");
+      void notifyControlPlane("execution-failed");
       return {
         text: `Proposal ${proposal.id} was approved, but ${integrationId} refused to run it \u2014 nothing was done.
 Reason: ${resultText}`,
@@ -6037,6 +6951,8 @@ Reason: ${resultText}`,
       };
     }
     state2.executionJournal.complete(receiptId, "done");
+    recordExecutionOutcome(state2, proposal.id, receiptId, true, resultText, result.structuredContent);
+    logExecutionOutcome(proposal.id, true);
     state2.executionLog.record({
       profileId: proposal.profileId,
       path: proposal.path,
@@ -6047,6 +6963,12 @@ Reason: ${resultText}`,
 Result: ${resultText}` };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
+    if (state2.executionJournal.get(receiptId)?.state === "intent") {
+      state2.executionJournal.complete(receiptId, "failed");
+      recordExecutionOutcome(state2, proposal.id, receiptId, false, `Receipt issued but tool execution failed: ${msg}`);
+      logExecutionOutcome(proposal.id, false, err instanceof Error ? err.name : "error");
+      void notifyControlPlane("execution-failed");
+    }
     return {
       text: `Proposal ${proposal.id} receipt issued but tool execution failed: ${msg}`,
       isError: true
@@ -6055,11 +6977,22 @@ Result: ${resultText}` };
 }
 function localOutcomeOfExecuted(proposal, state2) {
   const entry = state2.executionJournal?.findByProposal?.(proposal.id);
-  if (!entry || entry.state === "done") return null;
+  if (!entry) return null;
   const integration = proposal.tool.split("__")[0];
+  if (entry.state === "done") {
+    const stored = state2.executionResults?.get(proposal.id);
+    if (!stored || !stored.ok) return null;
+    return {
+      text: `Proposal ${proposal.id} was approved and executed.
+Result: ${stored.text}`,
+      isError: false
+    };
+  }
   if (entry.state === "failed") {
-    const reasonSuffix = entry.detail ? `
-Reason: ${entry.detail}` : "";
+    const stored = state2.executionResults?.get(proposal.id);
+    const detail = (stored && !stored.ok ? stored.text : void 0) ?? entry.detail;
+    const reasonSuffix = detail ? `
+Reason: ${detail}` : "";
     return {
       text: entry.outcome === "as_refused" ? `Proposal ${proposal.id} was approved, but the Authority Server refused its ticket \u2014 nothing ran. Do not retry the same values; ask the person (e.g. for a higher limit).${reasonSuffix}` : 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.${reasonSuffix}` : 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.${reasonSuffix}` : `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.${reasonSuffix}`,
       isError: true
@@ -6406,21 +7339,21 @@ function createMcpServer(state2, integrationManager2) {
 }
 
 // src/lib/agent-contact.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync16, renameSync as renameSync5, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname12, join as join15 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync13, readFileSync as readFileSync17, renameSync as renameSync5, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname13, join as join16 } from "path";
 var FILE = "agent-contact.json";
 var REWRITE_AFTER_MS = 6e4;
 var AgentContactStore = class {
   path;
   current;
   constructor(dataDir2) {
-    this.path = join15(dataDir2, FILE);
+    this.path = join16(dataDir2, FILE);
     this.current = this.load();
   }
   load() {
-    if (!existsSync15(this.path)) return null;
+    if (!existsSync16(this.path)) return null;
     try {
-      const v = JSON.parse(readFileSync16(this.path, "utf8"));
+      const v = JSON.parse(readFileSync17(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 {
@@ -6443,9 +7376,9 @@ var AgentContactStore = class {
     };
     if (!due) return;
     try {
-      mkdirSync12(dirname12(this.path), { recursive: true });
+      mkdirSync13(dirname13(this.path), { recursive: true });
       const tmp = `${this.path}.tmp`;
-      writeFileSync12(tmp, JSON.stringify(this.current, null, 2));
+      writeFileSync13(tmp, JSON.stringify(this.current, null, 2));
       renameSync5(tmp, this.path);
     } catch (err) {
       console.error("[Suveren MCP] Could not save agent contact:", err);
@@ -6480,16 +7413,16 @@ function verifyGateContentHashes(content, auth) {
 }
 
 // src/lib/integration-registry.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync13, existsSync as existsSync16 } from "fs";
-import { homedir as homedir11 } from "os";
-import { dirname as dirname13, join as join16 } from "path";
-var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join16(homedir11(), ".suveren");
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync18, writeFileSync as writeFileSync14, existsSync as existsSync17 } from "fs";
+import { homedir as homedir12 } from "os";
+import { dirname as dirname14, join as join17 } from "path";
+var DEFAULT_DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join17(homedir12(), ".suveren");
 var IntegrationRegistry = class {
   integrations = /* @__PURE__ */ new Map();
   filePath;
   constructor(dataDir2) {
     const dir = dataDir2 ?? DEFAULT_DATA_DIR;
-    this.filePath = join16(dir, "integrations.json");
+    this.filePath = join17(dir, "integrations.json");
     this.load();
   }
   // ─── CRUD ───────────────────────────────────────────────────────────────
@@ -6520,12 +7453,12 @@ var IntegrationRegistry = class {
   }
   // ─── Load / Save ────────────────────────────────────────────────────────
   load() {
-    if (!existsSync16(this.filePath)) {
-      mkdirSync13(dirname13(this.filePath), { recursive: true });
+    if (!existsSync17(this.filePath)) {
+      mkdirSync14(dirname14(this.filePath), { recursive: true });
       return;
     }
     try {
-      const raw = readFileSync17(this.filePath, "utf-8");
+      const raw = readFileSync18(this.filePath, "utf-8");
       const data = JSON.parse(raw);
       const migrated = data.integrations.map((i) => {
         if ("toolGating" in i && !("profile" in i)) {
@@ -6554,15 +7487,15 @@ var IntegrationRegistry = class {
       version: 1,
       integrations: Array.from(this.integrations.values())
     };
-    mkdirSync13(dirname13(this.filePath), { recursive: true });
-    writeFileSync13(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+    mkdirSync14(dirname14(this.filePath), { recursive: true });
+    writeFileSync14(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
   }
 };
 
 // src/lib/integration-manager.ts
-import { homedir as homedir12 } from "os";
-import { join as join17, delimiter } from "path";
-import { existsSync as existsSync17, writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, readFileSync as readFileSync18, rmSync } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join18, delimiter } from "path";
+import { existsSync as existsSync18, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15, readFileSync as readFileSync19, rmSync } from "fs";
 import { execFile } from "child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -6692,8 +7625,8 @@ function inheritedConnectorEnv(parent, passEnv = []) {
 }
 
 // src/lib/integration-manager.ts
-var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join17(homedir12(), ".suveren");
-var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join17(DEFAULT_DATA_DIR2, "integrations");
+var DEFAULT_DATA_DIR2 = process.env.SUVEREN_DATA_DIR ?? join18(homedir13(), ".suveren");
+var INTEGRATIONS_DIR = process.env.SUVEREN_INTEGRATIONS_DIR ?? join18(DEFAULT_DATA_DIR2, "integrations");
 var OFFLINE_MODE = process.env.SUVEREN_OFFLINE === "1";
 var installLock = Promise.resolve();
 function withInstallLock(task) {
@@ -6701,7 +7634,7 @@ function withInstallLock(task) {
   installLock = run.then(() => void 0, () => void 0);
   return run;
 }
-var INTEGRATIONS_BIN = join17(INTEGRATIONS_DIR, "node_modules", ".bin");
+var INTEGRATIONS_BIN = join18(INTEGRATIONS_DIR, "node_modules", ".bin");
 function getIntegrationsBinDir() {
   return INTEGRATIONS_BIN;
 }
@@ -6710,12 +7643,12 @@ function buildPath() {
   return [INTEGRATIONS_BIN, base].join(delimiter);
 }
 function ensureIntegrationsDir() {
-  if (!existsSync17(INTEGRATIONS_DIR)) {
-    mkdirSync14(INTEGRATIONS_DIR, { recursive: true });
+  if (!existsSync18(INTEGRATIONS_DIR)) {
+    mkdirSync15(INTEGRATIONS_DIR, { recursive: true });
   }
-  const pkgPath = join17(INTEGRATIONS_DIR, "package.json");
-  if (!existsSync17(pkgPath)) {
-    writeFileSync14(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
+  const pkgPath = join18(INTEGRATIONS_DIR, "package.json");
+  if (!existsSync18(pkgPath)) {
+    writeFileSync15(pkgPath, JSON.stringify({ name: "suveren-integrations", version: "1.0.0", private: true }, null, 2));
   }
 }
 function readAgeOf(config) {
@@ -6804,19 +7737,19 @@ var IntegrationManager = class {
    * exist, and treat anything else as not-installed (and reinstallable).
    */
   isUsableInstall(npmPackage) {
-    const pkgDir = join17(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    const pkgJson = join17(pkgDir, "package.json");
-    if (!existsSync17(pkgDir) || !existsSync17(pkgJson)) return false;
+    const pkgDir = join18(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    const pkgJson = join18(pkgDir, "package.json");
+    if (!existsSync18(pkgDir) || !existsSync18(pkgJson)) return false;
     try {
-      const pkg = JSON.parse(readFileSync18(pkgJson, "utf8"));
+      const pkg = JSON.parse(readFileSync19(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 (!existsSync17(join17(pkgDir, target))) return false;
+        if (!existsSync18(join18(pkgDir, target))) return false;
         if (!this.binShimExists(binName)) return false;
       }
-      if (binEntries.length === 0 && pkg.main && !existsSync17(join17(pkgDir, pkg.main))) return false;
+      if (binEntries.length === 0 && pkg.main && !existsSync18(join18(pkgDir, pkg.main))) return false;
       return true;
     } catch {
       return false;
@@ -6831,9 +7764,9 @@ var IntegrationManager = class {
    */
   readInstalledVersion(npmPackage) {
     if (!this.isUsableInstall(npmPackage)) return null;
-    const pkgJson = join17(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"), "package.json");
+    const pkgJson = join18(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"), "package.json");
     try {
-      const pkg = JSON.parse(readFileSync18(pkgJson, "utf8"));
+      const pkg = JSON.parse(readFileSync19(pkgJson, "utf8"));
       return typeof pkg.version === "string" ? pkg.version : null;
     } catch {
       return null;
@@ -6847,7 +7780,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) => existsSync17(join17(INTEGRATIONS_BIN, c)));
+    return candidates.some((c) => existsSync18(join18(INTEGRATIONS_BIN, c)));
   }
   /**
    * The exact version THIS gateway's CURRENTLY LOADED manifest pins
@@ -6937,8 +7870,8 @@ var IntegrationManager = class {
    * nothing at all.
    */
   async installNow(npmPackage, exactVersion, cleanFirst = true) {
-    const pkgDir = join17(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
-    if (cleanFirst && existsSync17(pkgDir)) {
+    const pkgDir = join18(INTEGRATIONS_DIR, "node_modules", ...npmPackage.split("/"));
+    if (cleanFirst && existsSync18(pkgDir)) {
       console.error(`[IntegrationManager] Removing ${exactVersion ? "outdated" : "unusable"} install of ${npmPackage}`);
       try {
         rmSync(pkgDir, { recursive: true, force: true });
@@ -7118,19 +8051,19 @@ var IntegrationManager = class {
     const profileGating = config.toolGating ?? null;
     const tools = (toolsResult.tools ?? []).map((tool) => {
       const gating = this.resolveToolGating(config.profile, profileGating, tool.name);
+      let inputSchema = withoutBlockedArgs(
+        tool.inputSchema ?? {},
+        gating?.blockedArgs
+      );
+      if (gating && gating.category !== "read" && gating.category !== "disabled") {
+        inputSchema = withSourceLink(inputSchema);
+      }
       return {
         originalName: tool.name,
         namespacedName: `${config.id}__${tool.name}`,
         integrationId: config.id,
         description: tool.description ?? "",
-        // A downstream schema otherwise reaches the agent verbatim, so a
-        // connector can offer a control-bypassing argument and we would pass it
-        // straight on. Anything the manifest blocks is removed here, before the
-        // agent ever sees it exists.
-        inputSchema: withoutBlockedArgs(
-          tool.inputSchema ?? {},
-          gating?.blockedArgs
-        ),
+        inputSchema,
         outputSchema: tool.outputSchema,
         gating
       };
@@ -7525,7 +8458,20 @@ var IntegrationManager = class {
         argNormalization: ext.argNormalization,
         hideUnlessAuthorized: ext.hideUnlessAuthorized,
         simulationOnly: ext.simulationOnly,
-        approvalView: ext.approvalView
+        approvalView: ext.approvalView,
+        contextKeys: ext.contextKeys,
+        sourceFromArg: ext.sourceFromArg,
+        // A WRITE override may ALSO declare a capability-gate (enum boundType,
+        // e.g. records.json's archive_access/delete_access) — the same
+        // mechanism the read branch uses, now generalized: hap-core's
+        // Gatekeeper deliberately never compares an `enum` bound against
+        // execution (gatekeeper.ts's 'enum' case: "the gateway tool-proxy
+        // gates tool calls ... before they reach the Gatekeeper"), so if this
+        // branch dropped it, nothing anywhere would ever enforce it. Before
+        // this, boundField/requiredValue on a non-"read" override was silently
+        // discarded here — the config in the manifest existed but did nothing.
+        boundField: ext.boundField,
+        requiredValue: ext.requiredValue
       };
     }
     return {
@@ -7656,7 +8602,7 @@ async function buildTicketDetails(archive, ticketIds) {
 }
 
 // src/lib/report/window.ts
-import { getProfile as getProfile5 } from "@hap/core";
+import { getProfile as getProfile7 } from "@hap/core";
 var REPORT_AGE_FIELD = "read_age_days";
 var REPORTING_PROFILE = "reporting";
 var END_SKEW_SECONDS = 120;
@@ -7670,7 +8616,7 @@ function windowLabel(start, days, loadedAt) {
   if (loadedAt !== null && loadedAt === start) return `${since} (when the test data was loaded)`;
   return `${since} (the last ${days} ${days === 1 ? "day" : "days"})`;
 }
-var defaultLookup = (id) => getProfile5(id);
+var defaultLookup = (id) => getProfile7(id);
 function reportingMandateRefusal(m, lookup = defaultLookup) {
   const schema = lookup(m.profileId)?.boundsSchema;
   const field = resolveAgeBoundField(schema, REPORT_AGE_FIELD);
@@ -7880,28 +8826,28 @@ function agentAccess(token, opensSession) {
 }
 
 // src/lib/profile-loader.ts
-import { readFileSync as readFileSync19, existsSync as existsSync18 } from "fs";
-import { join as join18, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync20, existsSync as existsSync19 } from "fs";
+import { join as join19, resolve as resolve2 } from "path";
 import { registerProfile } from "@hap/core";
 function loadProfiles(profilesDir) {
-  const dir = resolve2(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join18(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
-  const indexPath = join18(dir, "index.json");
-  if (!existsSync18(indexPath)) {
+  const dir = resolve2(profilesDir ?? process.env.SUVEREN_PROFILES_DIR ?? join19(import.meta.dirname ?? __dirname, "..", "..", "..", "..", "..", "hap-profiles"));
+  const indexPath = join19(dir, "index.json");
+  if (!existsSync19(indexPath)) {
     warnNoProfiles(`No index.json at ${indexPath}`);
     return 0;
   }
   let index;
   try {
-    index = JSON.parse(readFileSync19(indexPath, "utf-8"));
+    index = JSON.parse(readFileSync20(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 = join18(dir, relativePath);
+    const profilePath = join19(dir, relativePath);
     try {
-      const profile = JSON.parse(readFileSync19(profilePath, "utf-8"));
+      const profile = JSON.parse(readFileSync20(profilePath, "utf-8"));
       registerProfile(profileId, profile);
       const shortName2 = profileId.split("/").pop()?.replace(/@.*$/, "");
       if (shortName2 && shortName2 !== profileId) {
@@ -8242,20 +9188,20 @@ async function controlPlaneMandate(dryRun, request) {
 }
 
 // src/lib/guides.ts
-import { existsSync as existsSync19, readdirSync, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname14, join as join19 } from "path";
+import { existsSync as existsSync20, readdirSync, readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname15, join as join20 } 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 = join19(dir, "content", "guides");
-    if (existsSync19(candidate)) return candidate;
-    const parent = dirname14(dir);
+    const candidate = join20(dir, "content", "guides");
+    if (existsSync20(candidate)) return candidate;
+    const parent = dirname15(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return join19(import.meta.dirname ?? __dirname, "content", "guides");
+  return join20(import.meta.dirname ?? __dirname, "content", "guides");
 }
 function parse(body) {
   const lines = body.split(/\r?\n/);
@@ -8266,14 +9212,14 @@ function parse(body) {
   return { title, summary };
 }
 function readDir(dir, source) {
-  if (!dir || !existsSync19(dir)) return [];
+  if (!dir || !existsSync20(dir)) return [];
   const out = [];
   for (const file of readdirSync(dir)) {
     const m = FILE_RE.exec(file);
     if (!m) continue;
     let body;
     try {
-      body = readFileSync20(join19(dir, file), "utf8");
+      body = readFileSync21(join20(dir, file), "utf8");
     } catch {
       continue;
     }
@@ -8408,7 +9354,7 @@ function unifiedLineDiff(before, after) {
 }
 
 // src/lib/builtins/setup.ts
-import { getProfile as getProfile6 } from "@hap/core";
+import { getProfile as getProfile8 } from "@hap/core";
 var DELEGATION_PROFILE = "delegation";
 var DELEGATION_INTENT_HINT = [
   "Why \u2014 With test data only, I want to find out which routine parts of my work an AI could take over, so people gain time \u2014 before anything touches real systems.",
@@ -8460,7 +9406,7 @@ function delegationItselfRefusal(args) {
 }
 function delegationMandateRefusal(auth) {
   if (isSimulationMode()) return void 0;
-  const profile = getProfile6(auth.profileId);
+  const profile = getProfile8(auth.profileId);
   if (profile?.scopeSchema?.fields?.allowed_profiles) return void 0;
   return `your Delegation mandate (${shortName(auth.profileId)} ${versionOf(auth.profileId)}) does not declare which profiles or modes you may propose \u2014 only a Delegation mandate on delegation 0.4 or later works outside simulation mode. Ask the person to give a current Delegation mandate.`;
 }
@@ -8518,7 +9464,7 @@ function delegationChecks(deps, args, targetShortName, targetDisplayName) {
   );
   const first = governing[0];
   if (first) {
-    const delegationProfile = getProfile6(first.profileId);
+    const delegationProfile = getProfile8(first.profileId);
     const entry = getConsumptionState(first, deps.state.executionLog, delegationProfile).find((e) => e.field === "mandate_daily_max");
     if (entry && entry.limit !== null) {
       checks.push(`Proposals today: ${entry.current} of ${entry.limit}`);
@@ -8528,7 +9474,7 @@ function delegationChecks(deps, args, targetShortName, targetDisplayName) {
 }
 function resolveTargetProfile(input) {
   if (typeof input !== "string" || !input.trim()) return void 0;
-  const profile = getProfile6(input.trim());
+  const profile = getProfile8(input.trim());
   if (!profile) return void 0;
   return { profile, shortName: shortName(profile.id) };
 }
@@ -8679,7 +9625,7 @@ Read each topic with get_guide(topic) before doing that step.`);
             return { ...builtinText(`Unknown topic "${topic}". Topics: ${guides.map((g) => g.topic).join(", ") || "none installed"}.`), isError: true };
           }
           const body = fillGenerated(guide.body.trim(), {
-            limits: () => limitsSection(systems.map((s) => ({ id: s.id, profile: getProfile6(s.profile) }))),
+            limits: () => limitsSection(systems.map((s) => ({ id: s.id, profile: getProfile8(s.profile) }))),
             package: () => packageSection(
               deps.integrationManager.getAllTools().find((t) => !deps.integrationManager.isBuiltin(t.integrationId) && t.originalName === "load_simulation")
             )
@@ -8821,8 +9767,8 @@ function registerBuiltins(deps, factories = BUILTIN_FACTORIES) {
 import { decodeMandateBlob as decodeMandateBlob3 } from "@hap/core";
 
 // src/lib/committed-executor.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync21, unlinkSync as unlinkSync7, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname15, join as join20 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync16, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname16, join as join21 } from "path";
 function describeAutoExecutionLog(proposalId, tool, result) {
   if (result.skipped) return null;
   return result.isError ? `[Suveren MCP] Auto-exec proposal ${proposalId}: ${result.text}` : `[Suveren MCP] Auto-executed proposal ${proposalId}: ${tool}`;
@@ -8854,7 +9800,7 @@ var ExecutorLock = class {
   path;
   held = false;
   constructor(dataDir2) {
-    this.path = join20(dataDir2, "executor.lock");
+    this.path = join21(dataDir2, "executor.lock");
   }
   /** Try to take the lock. Returns the holder's pid when someone else has it. */
   acquire() {
@@ -8862,9 +9808,9 @@ var ExecutorLock = class {
     if (current && current.pid !== process.pid && isAlive(current.pid)) {
       return { held: false, holderPid: current.pid };
     }
-    mkdirSync15(dirname15(this.path), { recursive: true, mode: 448 });
+    mkdirSync16(dirname16(this.path), { recursive: true, mode: 448 });
     const lock = { pid: process.pid, startedAt: Math.floor(Date.now() / 1e3) };
-    writeFileSync15(this.path, JSON.stringify(lock), { mode: 384 });
+    writeFileSync16(this.path, JSON.stringify(lock), { mode: 384 });
     this.held = true;
     return { held: true };
   }
@@ -8880,15 +9826,15 @@ var ExecutorLock = class {
     const current = this.read();
     if (current?.pid === process.pid) {
       try {
-        unlinkSync7(this.path);
+        unlinkSync8(this.path);
       } catch {
       }
     }
   }
   read() {
-    if (!existsSync20(this.path)) return null;
+    if (!existsSync21(this.path)) return null;
     try {
-      const parsed = JSON.parse(readFileSync21(this.path, "utf8"));
+      const parsed = JSON.parse(readFileSync22(this.path, "utf8"));
       return typeof parsed?.pid === "number" ? parsed : null;
     } catch {
       return null;
@@ -8905,20 +9851,20 @@ function isAlive(pid) {
 }
 
 // bin/http.ts
-import { homedir as homedir13 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join23 } from "path";
 
 // src/lib/mcp-as-tracker.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname16, join as join21 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname17, join as join22 } from "path";
 function trackerPath(dataDir2) {
-  return join21(dataDir2, "mcp-as-pairing.json");
+  return join22(dataDir2, "mcp-as-pairing.json");
 }
 function readMcpPairedAsUrl(dataDir2) {
   const path = trackerPath(dataDir2);
-  if (!existsSync21(path)) return null;
+  if (!existsSync22(path)) return null;
   try {
-    const data = JSON.parse(readFileSync22(path, "utf-8"));
+    const data = JSON.parse(readFileSync23(path, "utf-8"));
     return typeof data.asUrl === "string" ? data.asUrl : null;
   } catch {
     return null;
@@ -8926,12 +9872,12 @@ function readMcpPairedAsUrl(dataDir2) {
 }
 function writeMcpPairedAsUrl(dataDir2, asUrl) {
   const path = trackerPath(dataDir2);
-  mkdirSync16(dirname16(path), { recursive: true, mode: 448 });
-  writeFileSync16(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
+  mkdirSync17(dirname17(path), { recursive: true, mode: 448 });
+  writeFileSync17(path, JSON.stringify({ asUrl }, null, 2), { encoding: "utf-8", mode: 384 });
 }
 
 // bin/http.ts
-var dataDir = process.env.SUVEREN_DATA_DIR ?? join22(homedir13(), ".suveren");
+var dataDir = process.env.SUVEREN_DATA_DIR ?? join23(homedir14(), ".suveren");
 var spUrl = resolveAsUrl(dataDir);
 validatePinTlsForUrl(resolvePinTls(dataDir), spUrl);
 var port = parseInt(process.env.SUVEREN_MCP_PORT ?? "3430", 10);
@@ -9017,7 +9963,8 @@ app.post("/internal/configure", internalOnly, (req, res) => {
     state.receiptArchive.setVaultKey(key);
     state.reportStore.setVaultKey(key);
     state.outcomeOutbox.setVaultKey(key);
-    console.error("[Suveren MCP] Vault key configured \u2014 gate store + denial log + receipt archive + report store + outcome outbox encryption active");
+    state.executionResults.setVaultKey(key);
+    console.error("[Suveren MCP] Vault key configured \u2014 gate store + denial log + receipt archive + report store + outcome outbox + execution results encryption active");
   }
   if (apiKey) {
     state.spClient.setApiKey(apiKey);
@@ -9166,6 +10113,32 @@ app.post("/internal/preview", internalOnly, async (req, res) => {
   });
   res.json(result);
 });
+app.post("/internal/request-context", internalOnly, async (req, res) => {
+  const { tool, toolArgs } = req.body;
+  if (!tool || typeof toolArgs !== "object" || toolArgs === null) {
+    res.status(400).json({ error: "Missing 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 manifest = getManifest(integrationId);
+  const actionGating = manifest?.toolGating?.overrides?.[toolName];
+  const configuredConnectorIds = new Set(integrationRegistry.getAll().map((c) => c.id));
+  const result = await buildRequestContext(
+    integrationManager,
+    state.executionJournal,
+    integrationId,
+    toolArgs,
+    actionGating ?? void 0,
+    configuredConnectorIds
+  );
+  res.json(result);
+});
 app.post("/internal/add-integration", internalOnly, async (req, res) => {
   try {
     const config = req.body;
@@ -9659,7 +10632,7 @@ app.listen(port, bindHost, () => {
     (proposal) => executeCommitted(proposal, state, integrationManager)
   );
   installCommittedExecutor(committedExecutor);
-  const dataDir2 = process.env.SUVEREN_DATA_DIR ?? join22(homedir13(), ".suveren");
+  const dataDir2 = process.env.SUVEREN_DATA_DIR ?? join23(homedir14(), ".suveren");
   const executorLock = new ExecutorLock(dataDir2);
   const lock = executorLock.acquire();
   if (!lock.held) {