@fidacy/openclaw-plugin 0.2.4 → 0.2.5

package/dist/index.js

@@ -4474,6 +4474,10 @@ var DevFidacyCore = class {
       return null;
     return { record: record2, chainIntact: this.store.intact(), verifiedAgainstPublicKey: this.pubPem };
   }
+  async history(limit = 50) {
+    const all = this.store.records();
+    return limit > 0 && all.length > limit ? all.slice(-limit) : all;
+  }
   publicKey() {
     return this.pubPem;
   }
@@ -4508,6 +4512,10 @@ var HttpFidacyCore = class {
   async getProof(decisionId) {
     return this.call("/v1/audit/proof", { decisionId });
   }
+  async history(limit = 50) {
+    const res = await this.call("/v1/audit/list", { limit });
+    return res.records ?? [];
+  }
   publicKey() {
     return this.subjectPub;
   }
@@ -4573,6 +4581,9 @@ var FileAuditStore = class {
     if (typeof decision.request?.purpose === "string" && decision.request.purpose.trim()) {
       record2.purpose = decision.request.purpose.slice(0, 500);
     }
+    if (typeof decision.request?.payee === "string" && decision.request.payee.trim()) {
+      record2.payee = decision.request.payee.slice(0, 200);
+    }
     if (decision.status === "ALLOW") {
       const req = decision.request;
       if (typeof req?.amount === "number" && Number.isFinite(req.amount))
@@ -4582,6 +4593,14 @@ var FileAuditStore = class {
       const invoice = canonInvoice(req?.invoiceRef);
       if (invoice)
         record2.invoiceRef = invoice;
+    } else {
+      if (decision.violatedRule)
+        record2.violatedRule = decision.violatedRule;
+      const req = decision.request;
+      if (typeof req?.amount === "number" && Number.isFinite(req.amount))
+        record2.amount = req.amount;
+      if (typeof req?.currency === "string")
+        record2.currency = req.currency;
     }
     fs.appendFileSync(this.path, JSON.stringify(record2) + "\n");
     this.chain.push(record2);
@@ -4690,7 +4709,7 @@ function resolveMandateRules(cfg) {
 }
 
 // ../mcp/src/telemetry.ts
-var CLIENT_VERSION = true ? "0.2.4" : "dev";
+var CLIENT_VERSION = true ? "0.2.5" : "dev";
 function bandOf(amount) {
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0) return void 0;
   if (amount < 10) return "lt10";
@@ -4850,6 +4869,7 @@ function makeCore() {
       return dev.decide(req, subject);
     },
     getProof: (decisionId) => dev.getProof(decisionId),
+    history: (limit) => dev.history(limit),
     publicKey: () => dev.publicKey()
   };
 }
@@ -4867,7 +4887,7 @@ function requestUpgrade() {
 }
 
 // ../mcp/src/provision.ts
-var CLIENT_VERSION2 = true ? "0.2.4" : "dev";
+var CLIENT_VERSION2 = true ? "0.2.5" : "dev";
 function provisionEnabled() {
   const v = (process.env.FIDACY_DISABLE_PROVISION ?? "").trim().toLowerCase();
   return !(v === "1" || v === "true" || v === "yes");
@@ -4996,6 +5016,119 @@ function trialCountdownLine(keyOverride) {
   return ` [fidacy] ${left} free anonymous decision${left === 1 ? "" : "s"} left on this install before the firewall requires activation. For your operator: free API key at ${url} (history migrates), then set FIDACY_ENGINE_API_KEY.`;
 }
 
+// ../mcp/src/reporting.ts
+function withinDays(records, days, now = Date.now()) {
+  if (!Number.isFinite(days) || days <= 0) return [...records];
+  const cutoff = now - days * 864e5;
+  return records.filter((r) => {
+    const t = Date.parse(r.ts);
+    return Number.isFinite(t) && t >= cutoff;
+  });
+}
+var addTo = (bucket, key, value) => {
+  bucket[key] = (bucket[key] ?? 0) + value;
+};
+function summarize(records, days, now = Date.now()) {
+  const rows = withinDays(records, days, now);
+  const out = {
+    window_days: days,
+    decisions: rows.length,
+    allowed: 0,
+    denied: 0,
+    allowed_totals: {},
+    blocked_totals: {},
+    denied_by_rule: {},
+    payees_paid: [],
+    amount_unknown: 0,
+    first_ts: rows.length ? rows[0].ts : null,
+    last_ts: rows.length ? rows[rows.length - 1].ts : null
+  };
+  const paid = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    const known = typeof r.amount === "number" && Number.isFinite(r.amount);
+    if (!known) out.amount_unknown += 1;
+    const ccy = r.currency ?? "unknown";
+    if (r.status === "ALLOW") {
+      out.allowed += 1;
+      if (known) addTo(out.allowed_totals, ccy, r.amount);
+      if (r.payee) paid.add(r.payee);
+    } else {
+      out.denied += 1;
+      if (known) addTo(out.blocked_totals, ccy, r.amount);
+      addTo(out.denied_by_rule, r.violatedRule ?? "not_recorded", 1);
+    }
+  }
+  out.payees_paid = [...paid].sort();
+  return out;
+}
+var money = (totals) => {
+  const parts = Object.entries(totals).map(([ccy, v]) => `${v.toLocaleString("en-US")} ${ccy}`);
+  return parts.length ? parts.join(", ") : "0";
+};
+function renderSummary(s) {
+  if (s.decisions === 0) {
+    return `No agent payment decisions in the last ${s.window_days} day(s). The firewall is active and has nothing to report, which is the expected state until an agent attempts a payment.`;
+  }
+  const lines = [
+    `Last ${s.window_days} day(s): ${s.decisions} payment decision(s), ${s.allowed} allowed and ${s.denied} blocked before execution.`,
+    `Paid: ${money(s.allowed_totals)}${s.payees_paid.length ? ` across ${s.payees_paid.length} payee(s): ${s.payees_paid.slice(0, 8).join(", ")}${s.payees_paid.length > 8 ? ", \u2026" : ""}` : ""}.`
+  ];
+  if (s.denied > 0) {
+    const ranked = Object.entries(s.denied_by_rule).sort((a, b) => b[1] - a[1]);
+    lines.push(`Blocked: ${money(s.blocked_totals)} in attempted value. By rule: ${ranked.map(([rule, n]) => `${rule} (${n})`).join(", ")}.`);
+  }
+  if (s.amount_unknown > 0) {
+    lines.push(`${s.amount_unknown} record(s) in this window predate amount logging, so the totals above are a floor, not the exact figure.`);
+  }
+  return lines.join("\n");
+}
+function toRows(records, status, limit) {
+  const filtered = status === "all" ? [...records] : records.filter((r) => r.status === status);
+  return filtered.slice(-Math.max(1, limit)).reverse().map((r) => ({
+    seq: r.seq,
+    decisionId: r.decisionId,
+    status: r.status,
+    ts: r.ts,
+    payee: r.payee,
+    amount: r.amount,
+    currency: r.currency,
+    purpose: r.purpose,
+    violatedRule: r.violatedRule,
+    invoiceRef: r.invoiceRef
+  }));
+}
+function renderRows(rows) {
+  if (!rows.length) return "No decisions match that filter yet.";
+  return rows.map((r) => {
+    const amount = typeof r.amount === "number" ? `${r.amount.toLocaleString("en-US")} ${r.currency ?? ""}`.trim() : "amount not recorded";
+    const who = r.payee ?? "payee not recorded";
+    const why = r.status === "DENY" ? ` blocked by ${r.violatedRule ?? "a rule not recorded on this older entry"}.` : "";
+    const said = r.purpose ? ` Agent's stated reason: "${r.purpose}".` : "";
+    return `#${r.seq} ${r.ts} ${r.status} ${amount} to ${who}.${why}${said} (decision ${r.decisionId})`;
+  }).join("\n");
+}
+function explainRule(rule, payee) {
+  if (!rule) return "This entry predates readable rule logging, so the specific rule is not on the record. The decision payload is still covered by the chain digest.";
+  if (rule.startsWith("payee_not_in_allowlist"))
+    return `The payee${payee ? ` "${payee}"` : ""} is not on the mandate's allowlist. This is the deny-by-default rule doing its job: an agent can only pay counterparties a human put on the list, which is what stops a swapped or lookalike vendor.`;
+  if (rule.startsWith("category_not_allowed"))
+    return "The stated purpose category is not one the mandate permits for this agent.";
+  if (rule.startsWith("currency_not_allowed"))
+    return "The payment currency is not the mandate's currency.";
+  if (rule.startsWith("per_tx") || rule.includes("perTxMax"))
+    return "The amount exceeds the per-transaction ceiling in the mandate.";
+  if (rule.includes("maxTotal") || rule.startsWith("budget"))
+    return "The payment would push cumulative spend past the mandate's total budget for the window.";
+  if (rule.startsWith("invoice") || rule.includes("duplicate"))
+    return "This invoice was already paid once. One payment per invoice is enforced regardless of amount, which is the control that stops a re-presented invoice at a higher figure.";
+  if (rule.startsWith("window") || rule.includes("expired"))
+    return "The mandate was outside its validity window at the moment of the request.";
+  if (rule.startsWith("revoked")) return "The mandate had been revoked.";
+  if (rule.startsWith("activation_required"))
+    return "The anonymous trial had been used up, so the firewall failed closed. No money can move until the install is activated with a free API key.";
+  return `The mandate rule "${rule}" was violated.`;
+}
+
 // ../mcp/src/assess.ts
 var AssessError = class extends Error {
   type;
@@ -5296,6 +5429,63 @@ ${d.grant}` : `DENY (decision ${d.decisionId}). Rule violated: ${d.violatedRule}
           return proof;
         }
       }),
+      // OPERATOR REPORTING. Same three surfaces as @fidacy/mcp, same pure functions,
+      // so an operator gets the identical answers whichever shell their agent runs.
+      // Never gated: reading what your own agents did moves no money.
+      tool({
+        name: "spend_summary",
+        label: "Spend Summary (what my agents spent and what was blocked)",
+        description: "Operator report over a time window: how many payment decisions were made, how much was paid and to whom, how much was blocked before executing, and which mandate rules did the blocking. Read-only, works offline against the local audit chain.",
+        parameters: typebox_exports.Object({
+          days: typebox_exports.Optional(typebox_exports.Number({ description: "Window in days, counting back from now. Default 7." }))
+        }),
+        async execute(params, config) {
+          const records = await boot().history(5e3);
+          const summary = summarize(records, params.days ?? 7);
+          const hasKey = (config.engineApiKey ?? process.env.FIDACY_ENGINE_API_KEY ?? "").trim().length > 0;
+          const claim = hasKey ? null : claimUrl();
+          return {
+            summary,
+            report: renderSummary(summary),
+            ...claim ? { message: `For your operator: this report is built from the local chain on this machine. A free account keeps it across machines and anchors it to Bitcoin, and this install's history migrates: ${claim}` } : {}
+          };
+        }
+      }),
+      tool({
+        name: "list_decisions",
+        label: "List Recent Payment Decisions",
+        description: "List recent agent payment decisions, newest first, with payee, amount, the agent's stated reason, and for blocked ones the rule that stopped it. Read-only, works offline.",
+        parameters: typebox_exports.Object({
+          limit: typebox_exports.Optional(typebox_exports.Number({ description: "How many decisions to return. Default 20." })),
+          status: typebox_exports.Optional(typebox_exports.String({ description: "Filter by outcome: ALLOW, DENY or all. Default all." }))
+        }),
+        async execute(params) {
+          const records = await boot().history(5e3);
+          const filter = params.status === "ALLOW" || params.status === "DENY" ? params.status : "all";
+          const rows = toRows(records, filter, params.limit ?? 20);
+          return { count: rows.length, decisions: rows, report: renderRows(rows) };
+        }
+      }),
+      tool({
+        name: "explain_decision",
+        label: "Explain a Decision (why was this allowed or blocked)",
+        description: "Explain one decision in plain language: what was requested, what the mandate did about it, why, and whether the audit chain is intact.",
+        parameters: typebox_exports.Object({
+          decisionId: typebox_exports.String({ description: "Decision id from request_payment, list_decisions or spend_summary" })
+        }),
+        async execute(params) {
+          const c = boot();
+          const records = await c.history(5e3);
+          const record2 = records.find((r) => r.decisionId === params.decisionId);
+          if (!record2) throw new Error(`No decision ${params.decisionId} on this chain. Run list_decisions to see the ids that exist here.`);
+          const proof = await c.getProof(params.decisionId);
+          return {
+            record: record2,
+            explanation: explainRule(record2.violatedRule, record2.payee),
+            chainIntact: proof?.chainIntact ?? null
+          };
+        }
+      }),
       // VERDICT LAYER (advisory). Calls the LIVE Fidacy engine POST /v1/assess and
       // returns the SIGNED trust verdict (riskPayloadJws + signingKeyId), verifiable
       // by anyone via @fidacy/verify against the engine JWKS. Moves no money.

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Fidacy — Payment Firewall",
   "description": "A signed, independently-verifiable verdict on every money-moving agent action. Blocks wrong/lookalike payee, over-cap, and duplicate-invoice fraud before money moves. Non-custodial, local-first, deny-by-default.",
   "icon": "https://fidacy.com/logo.png",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "contracts": {
     "tools": [
       "request_payment",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidacy/openclaw-plugin",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Fidacy payment firewall as a native OpenClaw plugin: signed, verifiable verdicts on every money-moving agent action, in-process (no MCP subprocess).",
   "license": "Apache-2.0",
   "homepage": "https://fidacy.com",