@suveren/gateway 0.29.1 → 0.30.0

package/dist/control-plane/index.mjs

@@ -5,9 +5,9 @@ import {
 
 // src/index.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync15, renameSync as renameSync3 } from "fs";
-import { dirname as dirname10, join as join15 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync13, readFileSync as readFileSync16, renameSync as renameSync4 } from "fs";
+import { dirname as dirname11, join as join16 } from "path";
+import { homedir as homedir9 } from "os";
 import express from "express";
 import { createProxyMiddleware } from "http-proxy-middleware";
 
@@ -643,6 +643,13 @@ async function getSkippedCommitments() {
   if (!res.ok) throw new Error("Failed to fetch skipped commitments");
   return res.json();
 }
+async function getMyPendingProposals() {
+  const res = await fetch(`${MCP_BASE}/internal/my-pending-proposals`, {
+    headers: internalHeaders()
+  });
+  if (!res.ok) throw new Error("Failed to fetch my pending proposals");
+  return res.json();
+}
 async function getLocalEvidence() {
   const res = await fetch(`${MCP_BASE}/internal/evidence`, {
     headers: internalHeaders()
@@ -2258,6 +2265,7 @@ function createAuthRouter(vault2, logoutAuth, loginRateLimit2, onSessionEstablis
         }
         vault2.wipe();
         await vault2.deriveAndSetKey(apiKey);
+        vault2.setSpCookie(sessionCookie);
       }
       const sessionExpiresAt = typeof data.sessionExpiresAt === "number" ? data.sessionExpiresAt : null;
       vault2.setSessionExpiresAt(sessionExpiresAt);
@@ -3376,15 +3384,15 @@ import { promisify } from "util";
 var run = promisify(execFile);
 var SUPPORTED = /* @__PURE__ */ new Set(["darwin", "win32", "linux"]);
 var MODULE_DIR = pathDirname(fileURLToPath(import.meta.url));
-function findCli(dirname11 = MODULE_DIR) {
+function findCli(dirname12 = MODULE_DIR) {
   const candidates = [
     // Bundled (the shipped layout): dist/control-plane → dist → root → bin
-    resolve(dirname11, "..", "..", "bin", "suveren-gateway.js"),
+    resolve(dirname12, "..", "..", "bin", "suveren-gateway.js"),
     // Bundled, were the routes/ directory ever preserved.
-    resolve(dirname11, "..", "..", "..", "bin", "suveren-gateway.js"),
+    resolve(dirname12, "..", "..", "..", "bin", "suveren-gateway.js"),
     // Dev, running from source: the repo's own bundle directory.
-    resolve(dirname11, "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js"),
-    resolve(dirname11, "..", "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js")
+    resolve(dirname12, "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js"),
+    resolve(dirname12, "..", "..", "..", "..", "..", "bundle", "bin", "suveren-gateway.js")
     // Deliberately NO process.cwd() fallback: it makes the result depend on
     // where the process happened to be launched from, so the same install
     // resolves differently between a shell and a login service — and it would
@@ -4622,10 +4630,62 @@ function createArchivedMandatesRouter(dataDir) {
   return router;
 }
 
-// src/routes/internal-events.ts
+// src/routes/blocked-seen.ts
 import { Router as Router19 } from "express";
+
+// src/lib/blocked-seen-store.ts
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync3 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join14, dirname as dirname10 } from "path";
+function storePath2(dataDir) {
+  const dir = dataDir ?? process.env.SUVEREN_DATA_DIR ?? join14(homedir8(), ".suveren");
+  return join14(dir, "blocked-seen.json");
+}
+function readLastSeenBlockedAt(dataDir) {
+  try {
+    const raw = JSON.parse(readFileSync14(storePath2(dataDir), "utf8"));
+    return typeof raw.lastSeenBlockedAt === "number" && Number.isFinite(raw.lastSeenBlockedAt) ? raw.lastSeenBlockedAt : 0;
+  } catch {
+    return 0;
+  }
+}
+function markBlockedSeen(ts, dataDir) {
+  const safeTs = typeof ts === "number" && Number.isFinite(ts) ? ts : Date.now();
+  const path = storePath2(dataDir);
+  mkdirSync9(dirname10(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync9(tmp, JSON.stringify({ lastSeenBlockedAt: safeTs }, null, 2) + "\n", "utf8");
+  renameSync3(tmp, path);
+  return safeTs;
+}
+
+// src/routes/blocked-seen.ts
+function createBlockedSeenRouter(dataDir) {
+  const router = Router19();
+  router.get("/", (_req, res) => {
+    res.json({ lastSeenBlockedAt: readLastSeenBlockedAt(dataDir) });
+  });
+  router.post("/", (req, res) => {
+    const body = req.body;
+    const ts = typeof body?.ts === "number" && Number.isFinite(body.ts) ? body.ts : Date.now();
+    try {
+      res.json({ lastSeenBlockedAt: markBlockedSeen(ts, dataDir) });
+    } catch (err) {
+      res.status(500).json({ error: `Could not save: ${err.message}` });
+    }
+  });
+  return router;
+}
+
+// src/routes/internal-events.ts
+import { Router as Router20 } from "express";
 import { timingSafeEqual as timingSafeEqual3 } from "crypto";
-var ALLOWED = ["proposal-added", "action-approval-needed", "execution-failed"];
+var ALLOWED = [
+  "proposal-added",
+  "action-approval-needed",
+  "execution-failed",
+  "denial-recorded"
+];
 var SESSION_EXPIRED = "session-expired";
 var AS_KEY_MISMATCH = "as-key-mismatch";
 var AS_TLS_MISMATCH = "as-tls-mismatch";
@@ -4638,7 +4698,7 @@ function secretMatches2(provided, expected) {
   return timingSafeEqual3(a, b);
 }
 function createInternalEventsRouter(getSecret, onSessionExpired, onAsKeyMismatch, onAsTlsMismatch) {
-  const router = Router19();
+  const router = Router20();
   router.post("/event", (req, res) => {
     if (!secretMatches2(req.headers["x-internal-secret"], getSecret())) {
       res.status(401).json({ error: "Unauthorized" });
@@ -4672,7 +4732,7 @@ function createInternalEventsRouter(getSecret, onSessionExpired, onAsKeyMismatch
 }
 
 // src/routes/internal-mandate.ts
-import { Router as Router20 } from "express";
+import { Router as Router21 } from "express";
 import { timingSafeEqual as timingSafeEqual4, randomUUID } from "crypto";
 
 // src/lib/mandate-ceremony.ts
@@ -4854,7 +4914,7 @@ function secretMatches3(provided, expected) {
   return a.length === b.length && timingSafeEqual4(a, b);
 }
 function createInternalMandateRouter(getSecret, deps) {
-  const router = Router20();
+  const router = Router21();
   router.post("/mandate", async (req, res) => {
     if (!secretMatches3(req.header("X-Internal-Secret") ?? void 0, getSecret())) {
       res.status(401).json({ error: "unauthorized" });
@@ -5057,17 +5117,17 @@ function buildSessionHealth(vault2) {
 }
 
 // src/lib/denials-reader.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
+import { join as join15 } from "path";
 function loadDenials(dataDir, decrypt) {
-  const encPath = join14(dataDir, "denials.enc.json");
-  const plainPath = join14(dataDir, "denials.json");
+  const encPath = join15(dataDir, "denials.enc.json");
+  const plainPath = join15(dataDir, "denials.json");
   if (existsSync12(encPath)) {
-    const { blob } = JSON.parse(readFileSync14(encPath, "utf-8"));
+    const { blob } = JSON.parse(readFileSync15(encPath, "utf-8"));
     return JSON.parse(decrypt(blob)).records ?? [];
   }
   if (existsSync12(plainPath)) {
-    return JSON.parse(readFileSync14(plainPath, "utf-8")).records ?? [];
+    return JSON.parse(readFileSync15(plainPath, "utf-8")).records ?? [];
   }
   return [];
 }
@@ -5091,11 +5151,11 @@ function isSimulationMode() {
 // src/index.ts
 (function migrateDataDir() {
   if (process.env.SUVEREN_DATA_DIR) return;
-  const oldDir = join15(homedir8(), ".hap");
-  const newDir = join15(homedir8(), ".suveren");
+  const oldDir = join16(homedir9(), ".hap");
+  const newDir = join16(homedir9(), ".suveren");
   if (!existsSync13(newDir) && existsSync13(oldDir)) {
     try {
-      renameSync3(oldDir, newDir);
+      renameSync4(oldDir, newDir);
       console.error(`[Control Plane] Migrated data directory: ${oldDir} \u2192 ${newDir}`);
     } catch (err) {
       console.error(`[Control Plane] FATAL: could not migrate data directory ${oldDir} \u2192 ${newDir}:`, err);
@@ -5103,7 +5163,7 @@ function isSimulationMode() {
     }
   }
 })();
-var DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join15(homedir8(), ".suveren");
+var DATA_DIR = process.env.SUVEREN_DATA_DIR ?? join16(homedir9(), ".suveren");
 var SP_URL = resolveAsUrl(DATA_DIR);
 validatePinTlsForUrl(resolvePinTls(DATA_DIR), SP_URL);
 var POLICY_LOCKED = [...readPolicy().locked];
@@ -5111,7 +5171,7 @@ var POLICY_LOCKED_INSTALL_METHOD = readPolicy().policy.installMethod;
 var POLICY_LOCKED_TEAM = readPolicy().policy.team;
 var port = parseInt(process.env.SUVEREN_CP_PORT ?? "3402", 10);
 var HAP_MODE = process.env.HAP_MODE ?? "personal";
-var UI_DIST = process.env.HAP_UI_DIST ?? join15(import.meta.dirname ?? __dirname, "../../ui/dist");
+var UI_DIST = process.env.HAP_UI_DIST ?? join16(import.meta.dirname ?? __dirname, "../../ui/dist");
 var vault = new Vault(DATA_DIR);
 var shownSnapshotStore = new ShownSnapshotStore(DATA_DIR);
 (function repairIfAsUrlChanged() {
@@ -5420,6 +5480,7 @@ app.use("/mcp", jsonParser, authGuard, createMCPRouter());
 app.use("/autostart", jsonParser, authGuard, createAutostartRouter());
 app.use("/api/gateway-settings", jsonParser, authGuard, createGatewaySettingsRouter());
 app.use("/api/archived-mandates", jsonParser, authGuard, createArchivedMandatesRouter());
+app.use("/api/blocked-seen", jsonParser, authGuard, createBlockedSeenRouter());
 app.use("/api/encrypt-intent", jsonParser, authGuard, createEncryptIntentRouter());
 app.use("/api/evidence-export", authGuard, createEvidenceExportRouter(SP_URL, vault, DATA_DIR, lockAsTlsMismatch));
 app.use("/proposal-status", jsonParser, authGuard, createProposalStatusRouter(SP_URL, vault, DATA_DIR, lockAsTlsMismatch, shownSnapshotStore));
@@ -5564,6 +5625,15 @@ app.get("/skipped-commitments", authGuard, async (_req, res) => {
     res.status(500).json({ error: "Failed to fetch skipped commitments from MCP server" });
   }
 });
+app.get("/my-pending-proposals", authGuard, async (_req, res) => {
+  try {
+    const data = await getMyPendingProposals();
+    res.json(data);
+  } catch (err) {
+    console.error("[Control Plane] My-pending-proposals retrieval error:", err);
+    res.status(500).json({ error: "Failed to fetch pending proposals from MCP server" });
+  }
+});
 app.get("/as-pairing", authGuard, (_req, res) => {
   const pairing = readPairing(DATA_DIR);
   const paired = pairing !== null && pairing.asUrl === SP_URL;
@@ -5587,7 +5657,7 @@ app.get("/as-pairing", authGuard, (_req, res) => {
 });
 app.get("/denials", authGuard, (req, res) => {
   try {
-    const dataDir = process.env.SUVEREN_DATA_DIR ?? join15(homedir8(), ".suveren");
+    const dataDir = process.env.SUVEREN_DATA_DIR ?? join16(homedir9(), ".suveren");
     const all = loadDenials(dataDir, (blob) => vault.decrypt(blob));
     const since = Number(req.query.since);
     const limit = Number(req.query.limit);
@@ -5646,12 +5716,12 @@ app.put("/agent-brief/context", jsonParser, authGuard, async (req, res) => {
       res.status(413).json({ error: `Context exceeds ${AGENT_CONTEXT_MAX_BYTES}-byte cap` });
       return;
     }
-    const { mkdirSync: mkdirSync9, writeFileSync: writeFileSync9, renameSync: renameSync4 } = await import("fs");
+    const { mkdirSync: mkdirSync10, writeFileSync: writeFileSync10, renameSync: renameSync5 } = await import("fs");
     const filePath = agentBriefPath();
-    mkdirSync9(dirname10(filePath), { recursive: true });
+    mkdirSync10(dirname11(filePath), { recursive: true });
     const tmpPath = `${filePath}.tmp`;
-    writeFileSync9(tmpPath, content, "utf-8");
-    renameSync4(tmpPath, filePath);
+    writeFileSync10(tmpPath, content, "utf-8");
+    renameSync5(tmpPath, filePath);
     res.json({ ok: true });
   } catch (err) {
     console.error("[Control Plane] agent-brief/context PUT failed:", err);
@@ -5743,10 +5813,10 @@ function detectRunningVersion() {
     return process.env.HAP_BUILD_SHA ?? "dev";
   }
   const dir = import.meta.dirname ?? __dirname;
-  const bundlePkg = join15(dir, "..", "..", "package.json");
+  const bundlePkg = join16(dir, "..", "..", "package.json");
   if (existsSync13(bundlePkg)) {
     try {
-      const pkg = JSON.parse(readFileSync15(bundlePkg, "utf8"));
+      const pkg = JSON.parse(readFileSync16(bundlePkg, "utf8"));
       if (pkg.name === "@suveren/gateway" && typeof pkg.version === "string") {
         return pkg.version;
       }
@@ -5798,7 +5868,7 @@ if (existsSync13(UI_DIST)) {
   }));
   app.get("*", (_req, res) => {
     res.setHeader("Cache-Control", "no-store, must-revalidate");
-    res.sendFile(join15(UI_DIST, "index.html"));
+    res.sendFile(join16(UI_DIST, "index.html"));
   });
 } else {
   app.get("/", (_req, res) => {

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) {
@@ -2374,6 +2421,18 @@ 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 (!existsSync10(this.filePath)) return { version: 1, entries: [] };
     try {
@@ -5523,10 +5582,12 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       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,
@@ -5976,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);
@@ -6011,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,
@@ -10347,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." });