@suveren/gateway 0.29.0 → 0.30.0

package/dist/mcp-server/http.mjs

@@ -1071,6 +1071,25 @@ var SPClient = class {
     if (!res.ok) return null;
     return res.json();
   }
+  /**
+   * One proposal by id, whatever its status — `GET /api/proposals/:id`
+   * (the AS admits the creator, an approver, or the authorization's owner;
+   * this gateway only ever calls it for an id it itself submitted, via
+   * proposalSubmissions, so the creator case always applies). Used by the
+   * `/internal/my-pending-proposals` stand-in (bin/http.ts) — see that
+   * route's doc comment for why it exists at all: the AS has no endpoint
+   * to list "proposals I created" scoped by creator, only `?domain=`,
+   * `?status=committed/rejected`, and `?approver=me`, none of which ever
+   * match an above-cap proposal that has no pendingDomains unless the
+   * caller also happens to be a pendingApprover.
+   */
+  async getProposal(id) {
+    const res = await this.fetch(`/api/proposals/${encodeURIComponent(id)}`);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(`SP proposal request failed: ${res.status}`);
+    const data = await res.json();
+    return data.proposal;
+  }
   /**
    * Get proposals that have been fully committed and are ready for execution.
    */
@@ -1124,7 +1143,7 @@ var AsKeyMismatchError = class extends Error {
   }
 };
 function isCommitmentDowngrade(auth) {
-  const requiresReview = auth.signedCommitmentMode === "review" || auth.signedCommitmentMode === "review_above_cap";
+  const requiresReview = auth.signedCommitmentMode === "review";
   return requiresReview && (auth.deferredCommitmentDomains ?? []).length === 0;
 }
 var AttestationCache = class {
@@ -1171,23 +1190,37 @@ var AttestationCache = class {
    */
   activeWorkspaceGroupId = null;
   /**
-   * Re-resolve {@link activeWorkspaceGroupId} from the Authority Server.
-   * Called by the resync-gates flow (http.ts's `/internal/resync-gates`),
-   * never on the hot tool-call path — it makes up to two AS calls. Leaves
-   * the previous value in place on any failure (network error, unexpected
-   * shape): losing a known-good value on a transient blip would turn this
-   * defence-in-depth check into a false refusal of every cached mandate,
-   * which is worse than leaving it momentarily stale.
+   * TR7 (work-plan "Added 2026-10-14"): the account's own Personal group id
+   * — learned alongside {@link activeWorkspaceGroupId} so {@link isTeamGroup}
+   * can tell a TEAM-owned authorization apart from a Personal one without a
+   * live AS call on the hot read path. `null` = not yet known, same
+   * "skip rather than guess" posture as `activeWorkspaceGroupId`.
+   */
+  personalGroupId = null;
+  /**
+   * Re-resolve {@link activeWorkspaceGroupId} and {@link personalGroupId}
+   * from the Authority Server. Called by the resync-gates flow (http.ts's
+   * `/internal/resync-gates`), never on the hot tool-call path — it makes up
+   * to two AS calls (`getActiveTeamGroupId` + `getPersonalGroupId`, the
+   * second already needed for both values). Leaves the previous value(s) in
+   * place on any failure (network error, unexpected shape): losing a
+   * known-good value on a transient blip would turn this defence-in-depth
+   * check into a false refusal of every cached mandate, which is worse than
+   * leaving it momentarily stale.
    */
   async refreshActiveWorkspace() {
+    let activeTeam = null;
+    try {
+      activeTeam = await this.spClient.getActiveTeamGroupId();
+      if (activeTeam) this.activeWorkspaceGroupId = activeTeam;
+    } catch {
+    }
     try {
-      const activeTeam = await this.spClient.getActiveTeamGroupId();
-      if (activeTeam) {
-        this.activeWorkspaceGroupId = activeTeam;
-        return;
-      }
       const personalId = await this.spClient.getPersonalGroupId();
-      if (personalId) this.activeWorkspaceGroupId = personalId;
+      if (personalId) {
+        this.personalGroupId = personalId;
+        if (!activeTeam) this.activeWorkspaceGroupId = personalId;
+      }
     } catch {
     }
   }
@@ -1200,6 +1233,19 @@ var AttestationCache = class {
   isForeignWorkspace(groupId) {
     return groupId !== void 0 && this.activeWorkspaceGroupId !== null && groupId !== this.activeWorkspaceGroupId;
   }
+  /**
+   * TR7 — is `groupId` a TEAM group (not the account's own Personal
+   * workspace)? `undefined` ("don't know") when either `groupId` itself or
+   * the account's Personal group id hasn't been learned yet — callers MUST
+   * treat that the same as Personal (read enforcement has no Authority
+   * Server backstop to fail closed to, unlike {@link isForeignWorkspace}'s
+   * ticket-time safety net, so an unknown status must never be read as
+   * "team" — that would apply a ceiling nobody has actually confirmed).
+   */
+  isTeamGroup(groupId) {
+    if (groupId === void 0 || this.personalGroupId === null) return void 0;
+    return groupId !== this.personalGroupId;
+  }
   /**
    * Get the SP public key, fetching from SP if not cached or expired, then —
    * when a pin exists for this exact AS URL — verifying the live key still
@@ -1779,6 +1825,7 @@ var DenialLog = class {
     } catch (err) {
       console.error("[DenialLog] failed to record denial:", err);
     }
+    void notifyControlPlane("denial-recorded");
   }
   /** Recent denials, newest first. `sinceMs` and `limit` are optional filters. */
   getRecent(sinceMs, limit = MAX_RECORDS) {
@@ -2190,21 +2237,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 +2411,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);
@@ -2227,11 +2421,23 @@ var ProposalSubmissionStore = class {
   get(proposalId) {
     return this.load().entries.find((e) => e.proposalId === proposalId);
   }
+  /**
+   * Every submission still on record (newest-pruned by `MAX_AGE_SECONDS`
+   * — see `load`). "Awaiting others" stand-in (2026-10-15, real-gateway
+   * e2e): until the Authority Server has a creator-scoped proposal query,
+   * this (every id THIS gateway has ever submitted) is the only local
+   * source for "proposals I created" — bin/http.ts's
+   * `/internal/my-pending-proposals` resolves each id's CURRENT state from
+   * the AS and filters to `status: 'pending'`.
+   */
+  list() {
+    return this.load().entries;
+  }
   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 +2445,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 +2486,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 +2522,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 +2583,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 +2615,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 +2632,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 +2751,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 +3062,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 +3097,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 +3131,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 +3181,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 +3196,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 +3223,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 +3265,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 +3389,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
 
 // src/lib/mandate-brief.ts
-import { getProfile as getProfile4 } from "@hap/core";
+import { getProfile as getProfile5 } from "@hap/core";
 
 // src/lib/consumption.ts
 import { boundActionTypes } from "@hap/core";
@@ -3248,29 +3457,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;
@@ -3463,18 +3672,239 @@ function attachTicketId(tool, args, ticketId) {
   return { ...args, ticket_id: ticketId };
 }
 
-// src/lib/preview.ts
-import { computeContentHash as computeContentHash2 } from "@hap/core";
-
-// src/lib/manifest-loader.ts
-import { readFileSync as readFileSync15, existsSync as existsSync14 } from "fs";
-import { join as join14, resolve } from "path";
-
-// src/lib/tool-gating-types.ts
-var MAX_PREVIEW_READS = 10;
-var MAX_FOREACH_ELEMENTS = 50;
-var MAX_RECORD_KEY_STEPS = 2;
-
+// src/lib/preview.ts
+import { computeContentHash as computeContentHash2 } from "@hap/core";
+
+// src/lib/manifest-loader.ts
+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-]+)*)?$/;
 function isExactSemver(value) {
@@ -3823,28 +4253,34 @@ function invalidManifestContextReason(manifest) {
   }
   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}`);
@@ -3860,6 +4296,11 @@ function loadManifests(integrationsDir) {
         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) {
@@ -4144,189 +4585,6 @@ async function buildInternalPreview(integrationManager2, integrationId, toolName
   });
 }
 
-// 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 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/field-path.ts
 function matchesWhere(element, where) {
   if (element === null || typeof element !== "object" || Array.isArray(element)) return false;
@@ -4811,8 +5069,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.`
@@ -4947,7 +5205,7 @@ function normalizeIncomingArgs(tool, args) {
 }
 
 // src/lib/numeric-execution.ts
-import { getProfile as getProfile2 } from "@hap/core";
+import { getProfile as getProfile3 } from "@hap/core";
 function parseNumericString(value) {
   if (!/^-?\d+(\.\d+)?$/.test(value)) return void 0;
   const parsed = Number(value);
@@ -4963,7 +5221,7 @@ function declaredNumericFields(profile) {
   return out;
 }
 function coerceDeclaredNumericFields(profileId, execution) {
-  const fields = declaredNumericFields(getProfile2(profileId));
+  const fields = declaredNumericFields(getProfile3(profileId));
   for (const field of fields) {
     const value = execution[field];
     if (typeof value !== "string") continue;
@@ -4973,7 +5231,7 @@ function coerceDeclaredNumericFields(profileId, execution) {
 }
 
 // src/lib/tool-proxy.ts
-import { getProfile as getProfile3, 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";
@@ -5045,7 +5303,7 @@ function profileMatches(profileId, shortName2) {
   return profileId === shortName2 || profileId.includes("/" + shortName2 + "@") || profileId.endsWith("/" + shortName2);
 }
 function wireExecutionContext(profileId, execution) {
-  const profile = getProfile3(profileId);
+  const profile = getProfile4(profileId);
   const allowed = /* @__PURE__ */ new Set(["action_type"]);
   const fields = profile?.boundsSchema?.fields;
   if (fields) {
@@ -5063,7 +5321,7 @@ function wireExecutionContext(profileId, execution) {
   return out;
 }
 function countBoundsFor(profileId, actionType) {
-  const fields = getProfile3(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);
@@ -5138,7 +5396,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(getProfile3(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",
@@ -5238,7 +5496,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) => {
@@ -5317,17 +5575,19 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
           );
         }
       }
-      const readProfile = readAdapter ? getProfile3(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);
       let readMaxAge = null;
       if (hasAgeDimension) {
         const localAge = integrationManager2.getReadAgeDays(tool.integrationId);
-        readMaxAge = localAge ?? (ageBoundField ? maxReadAgeDays(
+        const signedAge = ageBoundField ? maxReadAgeDays(
           matchingAuths.map((a) => a.bounds ?? a.frame),
           ageBoundField
-        ) : null);
+        ) : null;
+        const isTeam = typeof state2.cache?.isTeamGroup === "function" ? state2.cache.isTeamGroup(matchingAuths[0]?.groupId) : void 0;
+        readMaxAge = isTeam === true && signedAge !== null ? localAge !== null ? Math.min(localAge, signedAge) : signedAge : localAge ?? signedAge;
         if (readMaxAge === null) {
           return denyRead(
             state2,
@@ -5481,7 +5741,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       };
     }
     {
-      const profileDef = getProfile3(profile);
+      const profileDef = getProfile4(profile);
       const registry = profileDef?.boundsSchema?.actionTypes;
       if (Array.isArray(registry) && registry.length > 0 && !registry.includes(declaredActionType)) {
         recordBlocked(state2, tool, {
@@ -5519,6 +5779,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
@@ -5566,7 +5845,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
         isError: true
       };
     }
-    const contextKeys = getProfile3(passers[0].profileId)?.scopeSchema?.keyOrder ?? [];
+    const contextKeys = getProfile4(passers[0].profileId)?.scopeSchema?.keyOrder ?? [];
     return attemptWithCandidates(passers);
     async function attemptWithCandidates(candidates) {
       const selection = selectAuthorization(
@@ -5758,29 +6037,33 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
           return attemptWithCandidates(remaining);
         }
         if (err instanceof SPReceiptError && err.statusCode === 409) {
-          const spBody = err.body;
-          let pendingApprovers = spBody.approvers ?? [];
-          if (pendingApprovers.length === 0) {
-            try {
-              const summary = await state2.spClient.getAuthorizationSummary(authzId);
-              if (summary?.approvers_frozen) {
-                pendingApprovers = summary.approvers_frozen;
-              }
-              if (summary?.created_by) {
-                pendingApprovers = [summary.created_by, ...pendingApprovers];
-              }
-            } catch {
-            }
-          } else {
-            try {
-              const summary = await state2.spClient.getAuthorizationSummary(authzId);
-              if (summary?.created_by) {
-                pendingApprovers = [summary.created_by, ...pendingApprovers];
+          const rawBody = err.body;
+          const spBody = rawBody?.errors?.[0] ?? rawBody;
+          let pendingApprovers = spBody?.approvers ?? [];
+          let summary;
+          const authSummary = async () => {
+            if (summary === void 0) {
+              try {
+                summary = await state2.spClient.getAuthorizationSummary(authzId);
+              } catch {
+                summary = null;
               }
-            } catch {
             }
+            return summary;
+          };
+          if (pendingApprovers.length === 0) {
+            const s = await authSummary();
+            if (s?.approvers_frozen) pendingApprovers = s.approvers_frozen;
+          }
+          const isTeam = typeof state2.cache?.isTeamGroup === "function" ? state2.cache.isTeamGroup(auth.groupId) : void 0;
+          const ownerId = (await authSummary())?.created_by;
+          if (isTeam === true) {
+            if (ownerId) pendingApprovers = pendingApprovers.filter((uid) => uid !== ownerId);
+          } else if (ownerId) {
+            pendingApprovers = [ownerId, ...pendingApprovers];
           }
           const uniqueApprovers = [...new Set(pendingApprovers)];
+          const recipientUserIds = ownerId ? [.../* @__PURE__ */ new Set([ownerId, ...uniqueApprovers])] : uniqueApprovers;
           try {
             const enrichedArgs = await attachImagePreview(args);
             const wireExecCtx = wireExecutionContext(auth.profileId, execution);
@@ -5793,7 +6076,8 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
               toolArgs: enrichedArgs,
               executionContext: wireExecCtx,
               pendingApprovers: uniqueApprovers,
-              recipientUserIds: uniqueApprovers
+              recipientUserIds,
+              ...ownerId ? { createdBy: ownerId } : {}
             });
             const previewHash = await computeSubmissionPreviewHash(
               integrationManager2,
@@ -6026,7 +6310,7 @@ function buildMandateBrief(opts) {
       const parts = [];
       if (boundsDesc) parts.push(boundsDesc);
       if (executionLog) {
-        const profile = getProfile4(auth.profileId) ?? getProfile4(shortName2);
+        const profile = getProfile5(auth.profileId) ?? getProfile5(shortName2);
         const consumption = getConsumptionState(auth, executionLog, profile);
         const compact = formatConsumptionCompact(consumption);
         if (compact) parts.push(compact);
@@ -6064,7 +6348,7 @@ function buildMandateBrief(opts) {
 }
 
 // src/tools/authorizations.ts
-import { getProfile as getProfile5 } from "@hap/core";
+import { getProfile as getProfile6 } from "@hap/core";
 function shortProfileName2(profileId) {
   const withoutVersion = profileId.replace(/@.*$/, "");
   const parts = withoutVersion.split("/");
@@ -6182,7 +6466,7 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
         } catch {
         }
         const shortName2 = shortProfileName2(auth.profileId);
-        const profile = getProfile5(auth.profileId) ?? getProfile5(shortName2);
+        const profile = getProfile6(auth.profileId) ?? getProfile6(shortName2);
         if (profile) {
           const consumption = getConsumptionState(auth, state2.executionLog, profile);
           const consumptionText = formatConsumptionFull(consumption);
@@ -6242,7 +6526,7 @@ function listAuthorizationsHandler(state2, integrationManager2, contextDir) {
           lines.push("    Mode: review (each action requires your approval)");
         }
         const shortName2 = shortProfileName2(auth.profileId);
-        const profile = getProfile5(auth.profileId) ?? getProfile5(shortName2);
+        const profile = getProfile6(auth.profileId) ?? getProfile6(shortName2);
         if (profile) {
           const consumption = getConsumptionState(auth, state2.executionLog, profile);
           const compact = formatConsumptionCompact(consumption);
@@ -6435,6 +6719,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.`;
 }
@@ -6701,12 +6997,19 @@ async function executeCommitted(proposal, state2, integrationManager2) {
     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}`,
@@ -6714,6 +7017,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,
@@ -6724,6 +7029,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
@@ -6732,11 +7043,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
@@ -7083,21 +7405,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 {
@@ -7120,9 +7442,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);
@@ -7157,16 +7479,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 ───────────────────────────────────────────────────────────────
@@ -7197,12 +7519,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)) {
@@ -7231,15 +7553,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";
@@ -7369,8 +7691,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) {
@@ -7378,7 +7700,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;
 }
@@ -7387,12 +7709,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) {
@@ -7481,19 +7803,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;
@@ -7508,9 +7830,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;
@@ -7524,7 +7846,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
@@ -7614,8 +7936,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 });
@@ -8204,7 +8526,18 @@ var IntegrationManager = class {
         simulationOnly: ext.simulationOnly,
         approvalView: ext.approvalView,
         contextKeys: ext.contextKeys,
-        sourceFromArg: ext.sourceFromArg
+        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 {
@@ -8335,7 +8668,7 @@ async function buildTicketDetails(archive, ticketIds) {
 }
 
 // src/lib/report/window.ts
-import { getProfile as getProfile6 } 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;
@@ -8349,7 +8682,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) => getProfile6(id);
+var defaultLookup = (id) => getProfile7(id);
 function reportingMandateRefusal(m, lookup = defaultLookup) {
   const schema = lookup(m.profileId)?.boundsSchema;
   const field = resolveAgeBoundField(schema, REPORT_AGE_FIELD);
@@ -8559,28 +8892,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) {
@@ -8921,20 +9254,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/);
@@ -8945,14 +9278,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;
     }
@@ -9087,7 +9420,7 @@ function unifiedLineDiff(before, after) {
 }
 
 // src/lib/builtins/setup.ts
-import { getProfile as getProfile7 } 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.",
@@ -9139,7 +9472,7 @@ function delegationItselfRefusal(args) {
 }
 function delegationMandateRefusal(auth) {
   if (isSimulationMode()) return void 0;
-  const profile = getProfile7(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.`;
 }
@@ -9197,7 +9530,7 @@ function delegationChecks(deps, args, targetShortName, targetDisplayName) {
   );
   const first = governing[0];
   if (first) {
-    const delegationProfile = getProfile7(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}`);
@@ -9207,7 +9540,7 @@ function delegationChecks(deps, args, targetShortName, targetDisplayName) {
 }
 function resolveTargetProfile(input) {
   if (typeof input !== "string" || !input.trim()) return void 0;
-  const profile = getProfile7(input.trim());
+  const profile = getProfile8(input.trim());
   if (!profile) return void 0;
   return { profile, shortName: shortName(profile.id) };
 }
@@ -9358,7 +9691,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: getProfile7(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")
             )
@@ -9500,8 +9833,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}`;
@@ -9533,7 +9866,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() {
@@ -9541,9 +9874,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 };
   }
@@ -9559,15 +9892,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;
@@ -9584,20 +9917,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;
@@ -9605,12 +9938,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);
@@ -9696,7 +10029,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);
@@ -10079,6 +10413,24 @@ app.get("/internal/skipped-commitments", internalOnly, async (_req, res) => {
     res.status(502).json({ error: err instanceof Error ? err.message : "Could not reach the Authority Server" });
   }
 });
+app.get("/internal/my-pending-proposals", internalOnly, async (_req, res) => {
+  try {
+    const submitted = state.proposalSubmissions.list();
+    const resolved = await Promise.all(
+      submitted.map(async (s) => {
+        try {
+          return await state.spClient.getProposal(s.proposalId);
+        } catch {
+          return null;
+        }
+      })
+    );
+    const pending = resolved.filter((p) => p !== null && p.status === "pending");
+    res.json({ proposals: pending });
+  } catch (err) {
+    res.status(502).json({ error: err instanceof Error ? err.message : "Could not reach the Authority Server" });
+  }
+});
 app.get("/internal/evidence", internalOnly, (_req, res) => {
   if (state.receiptArchive.isLocked()) {
     res.status(503).json({ error: "Vault locked \u2014 the evidence archive is encrypted until sign-in." });
@@ -10364,7 +10716,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) {