@suveren/gateway 0.20.2 → 0.21.0

package/content/integrations/erp.json

@@ -6,7 +6,7 @@
   "icon": "briefcase",
   "profile": "sales",
   "npmPackage": "@humanagencyp/erp-mcp",
-  "npmVersion": "0.5.0",
+  "npmVersion": "0.6.0",
   "mcp": {
     "command": "erp-mcp",
     "args": [],

package/dist/mcp-server/http.mjs

@@ -1970,14 +1970,22 @@ var ExecutionJournal = class {
     return { ok: true };
   }
   /** Close an `intent` row. Missing row is a programming error, not a silent no-op. */
-  complete(ticketId, state2) {
+  complete(ticketId, state2, outcome) {
     const file = this.load();
     const row = file.entries.find((e) => e.ticketId === ticketId);
     if (!row) throw new Error(`execution journal: no row for ticket ${ticketId} to complete`);
     row.state = state2;
+    if (outcome) row.outcome = outcome;
     row.finishedAt = nowSec();
     this.persist(file);
   }
+  /** The newest row for a review-path proposal — what really happened when it
+   *  ran on this gateway (the AS marks a proposal "executed" when it issues the
+   *  ticket, before the action runs). Undefined when it never ran here. */
+  findByProposal(proposalId) {
+    const rows = this.load().entries.filter((e) => e.proposalId === proposalId);
+    return rows[rows.length - 1];
+  }
   /** All rows, newest last. Diagnostic. */
   getAll() {
     return [...this.load().entries];
@@ -3563,6 +3571,7 @@ function denyRead(state2, tool, reason, detail, target) {
       tool: tool.originalName,
       integrationId: tool.integrationId,
       profile: tool.gating?.profile ?? null,
+      kind: "read",
       reason,
       detail,
       target
@@ -3571,15 +3580,62 @@ function denyRead(state2, tool, reason, detail, target) {
   }
   return { content: [{ type: "text", text: `Read blocked by Gatekeeper: ${detail}` }], isError: true };
 }
+function recordBlocked(state2, tool, rec) {
+  state2.denialLog?.record({
+    ts: Date.now(),
+    tool: tool.originalName,
+    integrationId: tool.integrationId,
+    profile: tool.gating?.profile ?? null,
+    ...rec
+  });
+}
+function recordGatekeeperRefusal(state2, tool, refusals) {
+  if (refusals.length === 0) return;
+  const pick = refusals.find((r) => r.bound !== void 0 && r.actual !== void 0) ?? refusals[0];
+  const scoped = pick.field ? Boolean(getProfile2(pick.profileId)?.scopeSchema?.fields?.[pick.field]) : false;
+  const asValueOrString = (v) => typeof v === "number" || typeof v === "string" ? v : void 0;
+  recordBlocked(state2, tool, {
+    kind: scoped ? "scope" : "bound",
+    detail: "Refused locally by the Gatekeeper.",
+    mandateId: pick.authorizationId,
+    field: pick.field,
+    value: asValueOrString(pick.actual),
+    limit: asValueOrString(pick.bound),
+    who: "gateway",
+    code: pick.code
+  });
+}
+function recordAsRefusal(state2, tool, authorizationId, err) {
+  const code = typeof err?.code === "string" ? err.code : void 0;
+  const asValueOrString = (v) => typeof v === "number" || typeof v === "string" ? v : void 0;
+  recordBlocked(state2, tool, {
+    kind: code === "CUMULATIVE_LIMIT_EXCEEDED" ? "cumulative" : code === "BOUND_EXCEEDED" ? "bound" : "not_authorized",
+    detail: "Refused by the Authority Server.",
+    mandateId: authorizationId,
+    field: typeof err?.field === "string" ? err.field : void 0,
+    value: asValueOrString(err?.actual),
+    limit: asValueOrString(err?.expected),
+    who: "authority-server",
+    code
+  });
+}
 function createGatedToolHandler(tool, integrationManager2, state2) {
   if (isSimulationMode() && !integrationManager2.isSimulationSafe(tool.integrationId)) {
-    return async () => ({
-      content: [{
-        type: "text",
-        text: `Refused: "${tool.namespacedName}" is not available. No ticket was requested.`
-      }],
-      isError: true
-    });
+    return async () => {
+      recordBlocked(state2, tool, {
+        kind: "simulation",
+        detail: "Real systems are blocked while simulation mode is on.",
+        who: "gateway",
+        code: "SIMULATION_MODE"
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Refused: "${tool.namespacedName}" is not available. No ticket was requested.`
+        }],
+        isError: true
+      };
+    };
   }
   const gated = createGatedToolHandlerInner(tool, integrationManager2, state2);
   const gateable = !!tool.gating?.profile && tool.gating.category !== "disabled";
@@ -3642,6 +3698,15 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
   };
   const noEligibleMandate = (refusals) => {
     const reasons = [...new Set(refusals)].join(" ");
+    recordBlocked(state2, tool, {
+      kind: "not_authorized",
+      // Fixed text only: `reasons` can name resources or correspondents (read
+      // refusals), and a blocked-action record carries no content.
+      detail: `No active authorization matching profile "${profile}".`,
+      field: profile,
+      who: "gateway",
+      code: "NO_MATCHING_MANDATE"
+    });
     return {
       content: [{
         type: "text",
@@ -3847,6 +3912,13 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
     }
     const declaredActionType = typeof execution.action_type === "string" && execution.action_type.length > 0 ? execution.action_type : void 0;
     if (!declaredActionType) {
+      recordBlocked(state2, tool, {
+        kind: "bound",
+        detail: `${tool.namespacedName} declares no action_type in its manifest's staticExecution.`,
+        field: "action_type",
+        who: "gateway",
+        code: "MISSING_ACTION_TYPE"
+      });
       return {
         content: [{
           type: "text",
@@ -3859,6 +3931,14 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       const profileDef = getProfile2(profile);
       const registry = profileDef?.boundsSchema?.actionTypes;
       if (Array.isArray(registry) && registry.length > 0 && !registry.includes(declaredActionType)) {
+        recordBlocked(state2, tool, {
+          kind: "bound",
+          detail: `action_type "${declaredActionType}" is not in profile ${profile}'s actionTypes registry.`,
+          field: "action_type",
+          value: declaredActionType,
+          who: "gateway",
+          code: "INVALID_ACTION_TYPE"
+        });
         return {
           content: [{
             type: "text",
@@ -3872,6 +3952,7 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
     if (matchingAuths.length === 0) return noEligibleMandate(refusals);
     const errors = [];
     const passers = [];
+    const structuredRefusals = [];
     for (const candidate of matchingAuths) {
       const { result } = await state2.gatekeeper.verifyExecution(candidate.authorizationId, execution, {
         bounds: candidate.bounds,
@@ -3880,6 +3961,13 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
       const capped = result.approved ? zeroCappedBound(candidate.profileId, candidate.bounds ?? candidate.frame, typeof execution.action_type === "string" ? execution.action_type : void 0) : null;
       if (result.approved && capped) {
         errors.push(`${candidate.path}: ${capped} is 0 \u2014 this mandate does not allow "${execution.action_type}"`);
+        structuredRefusals.push({
+          authorizationId: candidate.authorizationId,
+          profileId: candidate.profileId,
+          code: "BOUND_EXCEEDED",
+          field: typeof execution.action_type === "string" ? execution.action_type : void 0,
+          bound: 0
+        });
       } else if (result.approved) {
         passers.push(candidate);
       } else {
@@ -3890,9 +3978,20 @@ function createGatedToolHandlerInner(tool, integrationManager2, state2) {
           return `${candidate.path}: ${e.message}`;
         });
         errors.push(...reasons);
+        for (const e of result.errors) {
+          structuredRefusals.push({
+            authorizationId: candidate.authorizationId,
+            profileId: candidate.profileId,
+            code: e.code,
+            field: e.field,
+            bound: e.bound,
+            actual: e.actual
+          });
+        }
       }
     }
     if (passers.length === 0) {
+      recordGatekeeperRefusal(state2, tool, structuredRefusals);
       return {
         content: [{
           type: "text",
@@ -4044,6 +4143,7 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
           state2.cache.markNeedsReapproval(auth.authorizationId);
           const remaining = candidates.filter((c) => c.authorizationId !== auth.authorizationId);
           if (remaining.length === 0) {
+            recordAsRefusal(state2, tool, auth.authorizationId, { code: "VERSION_UNSUPPORTED" });
             return {
               content: [{
                 type: "text",
@@ -4059,9 +4159,11 @@ Proposal ID: ${proposal.id}. Check status with check-pending-commitments(proposa
         }
         if (err instanceof SPReceiptError && isStaleMandateRefusal(err)) {
           state2.cache.invalidate(auth.authorizationId);
-          const code = err.body?.errors?.[0]?.code ?? "unknown";
+          const staleErr = err.body?.errors?.[0];
+          const code = staleErr?.code ?? "unknown";
           const remaining = candidates.filter((c) => c.authorizationId !== auth.authorizationId);
           if (remaining.length === 0) {
+            recordAsRefusal(state2, tool, auth.authorizationId, staleErr);
             console.error(
               `[Suveren MCP] fallback(${tool.namespacedName}): mandate ${auth.authorizationId} invalid (${code}) \u2014 no remaining candidates`
             );
@@ -4141,6 +4243,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           }
         }
         if (err instanceof SPReceiptError && err.statusCode === 422) {
+          recordAsRefusal(state2, tool, auth.authorizationId, err.body?.errors?.[0]);
           return {
             content: [{ type: "text", text: `Action blocked: ${err.message} (hard team ceiling \u2014 contact the team admin)` }],
             isError: true
@@ -4151,6 +4254,7 @@ Proposal ID: ${proposal.id}. Use check-pending-commitments to track status.`
           if (errors403?.[0]?.code === "MANDATE_REVOKED") {
             state2.cache.invalidate(auth.authorizationId);
           }
+          recordAsRefusal(state2, tool, auth.authorizationId, errors403?.[0]);
           return {
             content: [{ type: "text", text: `Blocked by SP: ${err.message}` }],
             isError: true
@@ -4798,6 +4902,8 @@ async function executeCommitted(proposal, state2, integrationManager2) {
     if (err instanceof SPReceiptError) {
       const code = err.body.errors?.[0]?.code;
       if (code === "PROPOSAL_ALREADY_EXECUTED") {
+        const local = localOutcomeOfExecuted(proposal, state2);
+        if (local) return local;
         return {
           text: `Proposal ${proposal.id} has already been executed by another request.`
         };
@@ -4865,6 +4971,15 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       state2.executionJournal.complete(receiptId, "failed");
       throw err;
     }
+    const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
+    if (result.isError) {
+      state2.executionJournal.complete(receiptId, "failed", "refused");
+      return {
+        text: `Proposal ${proposal.id} was approved, but ${integrationId} refused to run it \u2014 nothing was done.
+Reason: ${resultText}`,
+        isError: true
+      };
+    }
     state2.executionJournal.complete(receiptId, "done");
     state2.executionLog.record({
       profileId: proposal.profileId,
@@ -4872,7 +4987,6 @@ async function executeCommitted(proposal, state2, integrationManager2) {
       execution: proposal.executionContext,
       timestamp: Math.floor(Date.now() / 1e3)
     });
-    const resultText = result.content?.[0]?.text ?? JSON.stringify(result);
     return { text: `Proposal ${proposal.id} committed and executed.
 Result: ${resultText}` };
   } catch (err) {
@@ -4883,6 +4997,21 @@ Result: ${resultText}` };
     };
   }
 }
+function localOutcomeOfExecuted(proposal, state2) {
+  const entry = state2.executionJournal?.findByProposal?.(proposal.id);
+  if (!entry || entry.state === "done") return null;
+  const integration = proposal.tool.split("__")[0];
+  if (entry.state === "failed") {
+    return {
+      text: entry.outcome === "refused" ? `Proposal ${proposal.id} was approved, but ${integration} refused to run it \u2014 nothing was done. Do not call the tool again with the same values; a new attempt needs a new request and approval.` : `Proposal ${proposal.id} was approved, but running it failed \u2014 whether anything happened in ${integration} is unknown. Check ${integration} before trying again; a new attempt needs a new request and approval.`,
+      isError: true
+    };
+  }
+  return {
+    text: `Proposal ${proposal.id} was approved and started running; the outcome is not known yet. Do not call the tool again.`,
+    isError: false
+  };
+}
 function checkPendingCommitmentsHandler(state2, integrationManager2) {
   return async (args) => {
     if (!state2.spClient.isUnlocked()) {
@@ -4907,6 +5036,13 @@ function checkPendingCommitmentsHandler(state2, integrationManager2) {
           };
         }
         if (match.status === "executed") {
+          const local = localOutcomeOfExecuted(match, state2);
+          if (local) {
+            return {
+              content: [{ type: "text", text: local.text }],
+              ...local.isError ? { isError: true } : {}
+            };
+          }
           const result = match.executionResult ? `
 Result: ${JSON.stringify(match.executionResult, null, 2)}` : " The action ran; the gateway did not retain its output.";
           return {