@fidacy/openclaw-plugin 0.4.3 → 0.5.1

package/dist/index.js

@@ -1310,8 +1310,8 @@ function CreateObject(types, value) {
 }
 function FromUnionKey(types, value) {
   const flattened = Flatten(types);
-  const record2 = TryBuildRecord(flattened, value);
-  return IsSchema(record2) ? record2 : CreateObject(flattened, value);
+  const record3 = TryBuildRecord(flattened, value);
+  return IsSchema(record3) ? record3 : CreateObject(flattened, value);
 }
 
 // ../../node_modules/.pnpm/typebox@1.1.39/node_modules/typebox/build/type/engine/record/from_key.mjs
@@ -4224,6 +4224,331 @@ __export(typebox_exports, {
 // src/index.ts
 import { defineToolPlugin } from "openclaw/plugin-sdk/tool-plugin";
 
+// src/observer.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/evidence.ts
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var GENESIS = "fidacy.observer.v1";
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+function canonical(obj) {
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => `${JSON.stringify(k)}:${JSON.stringify(obj[k])}`).join(",") + "}";
+}
+function chainStep(prevHead, a) {
+  return sha256(`${prevHead}|${sha256(canonical({ category: a.category, i: a.i, tool: a.tool, ts: a.ts }))}`);
+}
+function genesisHead() {
+  return sha256(GENESIS);
+}
+function fidacyDir() {
+  return join(process.env.FIDACY_HOME ?? join(homedir(), ".fidacy"), "sessions");
+}
+function writeSessionLog(sessionId, actions, head, meta) {
+  try {
+    const dir = fidacyDir();
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80) || "session";
+    const path = join(dir, `${safe}.json`);
+    const body = {
+      v: "fidacy.observer.v1",
+      recipe: 'h_0 = sha256("fidacy.observer.v1"); h_i = sha256(h_prev + "|" + sha256(canonical(action)))',
+      sessionId,
+      head,
+      ...meta,
+      actions
+    };
+    writeFileSync(path, JSON.stringify(body, null, 2), { mode: 384 });
+    return path;
+  } catch {
+    return null;
+  }
+}
+function queuePending(head, sessionId, at, total = 0, byCategory = {}) {
+  try {
+    const dir = fidacyDir();
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    appendFileSync(join(dir, "pending-anchors.jsonl"), JSON.stringify({ head, sessionId, at, total, byCategory }) + "\n", {
+      mode: 384
+    });
+  } catch {
+  }
+}
+function takePending(limit = 50) {
+  const dir = fidacyDir();
+  const path = join(dir, "pending-anchors.jsonl");
+  const taken = join(dir, "pending-anchors.taking");
+  try {
+    renameSync(path, taken);
+  } catch {
+    return [];
+  }
+  try {
+    const lines = readFileSync(taken, "utf8").split("\n").filter(Boolean);
+    const out = [];
+    for (const line of lines.slice(-limit)) {
+      try {
+        const p = JSON.parse(line);
+        if (typeof p.head === "string" && /^[0-9a-f]{64}$/.test(p.head)) out.push(p);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  } finally {
+    try {
+      writeFileSync(taken, "");
+    } catch {
+    }
+  }
+}
+function verifyUrl(head) {
+  return `https://fidacy.com/verify?sha256=${head}`;
+}
+var CODE = {
+  money: "m",
+  shell: "s",
+  file: "f",
+  network: "net",
+  message: "msg",
+  other: "o"
+};
+function sessionLabel(sessionId, total, byCategory) {
+  const id = sessionId.replace(/[^A-Za-z0-9-]/g, "").slice(0, 8) || "unknown";
+  const parts = [`session:${id}`, `n=${total}`];
+  for (const [cat, code] of Object.entries(CODE)) {
+    const n = byCategory[cat] ?? 0;
+    if (n > 0) parts.push(`${code}=${n}`);
+  }
+  return parts.join(" ").slice(0, 120);
+}
+
+// src/observer.ts
+var EXACT = {
+  // Fidacy's own money tools, so the report counts what we ourselves gated.
+  request_payment: "money",
+  assess_action: "money",
+  // The common OpenClaw / agent-host tool vocabulary.
+  bash: "shell",
+  shell: "shell",
+  exec: "shell",
+  run_command: "shell",
+  code_mode_exec: "shell",
+  read: "file",
+  read_file: "file",
+  write: "file",
+  write_file: "file",
+  edit: "file",
+  edit_file: "file",
+  apply_patch: "file",
+  glob: "file",
+  grep: "file",
+  ls: "file",
+  fetch: "network",
+  web_fetch: "network",
+  web_search: "network",
+  http_request: "network",
+  browser: "network",
+  send_message: "message",
+  reply: "message",
+  send_email: "message"
+};
+var FUZZY = [
+  ["payment", "money"],
+  ["invoice", "money"],
+  ["transfer", "money"],
+  ["charge", "money"],
+  ["file", "file"],
+  ["patch", "file"],
+  ["write", "file"],
+  ["read", "file"],
+  ["fetch", "network"],
+  ["http", "network"],
+  ["browser", "network"],
+  ["search", "network"],
+  ["exec", "shell"],
+  ["command", "shell"],
+  ["shell", "shell"],
+  ["mail", "message"],
+  ["message", "message"],
+  ["send", "message"]
+];
+function classify(toolName, derivedPaths) {
+  const name = toolName.toLowerCase();
+  const exact = EXACT[name];
+  if (exact) return exact;
+  if (derivedPaths && derivedPaths.length > 0) return "file";
+  for (const [needle, category] of FUZZY) if (name.includes(needle)) return category;
+  return "other";
+}
+function fingerprint(toolName, derivedPaths) {
+  const target = derivedPaths && derivedPaths.length > 0 ? [...derivedPaths].sort().join("\0") : toolName;
+  return createHash2("sha256").update(`${toolName}\0${target}`).digest("hex").slice(0, 16);
+}
+var ACTION_LOG_CAP = 5e3;
+function newLedger(sessionId, now) {
+  return {
+    sessionId,
+    startedAt: now,
+    byCategory: /* @__PURE__ */ new Map(),
+    total: 0,
+    toolsSeen: /* @__PURE__ */ new Set(),
+    head: genesisHead(),
+    actions: [],
+    truncated: false
+  };
+}
+function record(ledger, toolName, derivedPaths, failed = false, at = Date.now()) {
+  const category = classify(toolName, derivedPaths);
+  let tally = ledger.byCategory.get(category);
+  if (!tally) {
+    tally = { calls: 0, failures: 0, targets: /* @__PURE__ */ new Set() };
+    ledger.byCategory.set(category, tally);
+  }
+  tally.calls += 1;
+  if (failed) tally.failures += 1;
+  if (derivedPaths && derivedPaths.length > 0 && tally.targets.size < TARGET_CAP) {
+    tally.targets.add(fingerprint(toolName, derivedPaths));
+  }
+  ledger.total += 1;
+  if (ledger.toolsSeen.size < TOOLS_CAP) ledger.toolsSeen.add(toolName);
+  const action = {
+    i: ledger.total,
+    category,
+    tool: toolName,
+    ts: new Date(at).toISOString()
+  };
+  ledger.head = chainStep(ledger.head, action);
+  if (ledger.actions.length < ACTION_LOG_CAP) ledger.actions.push(action);
+  else ledger.truncated = true;
+}
+var TARGET_CAP = 500;
+var TOOLS_CAP = 200;
+var ORDER = ["money", "shell", "file", "network", "message", "other"];
+var LABEL = {
+  money: "moved money",
+  shell: "ran commands",
+  file: "touched files",
+  network: "reached the network",
+  message: "sent messages",
+  other: "other"
+};
+function renderReport(ledger, now, activated, logPath) {
+  if (ledger.total < MIN_ACTIONS_FOR_REPORT) return null;
+  const minutes = Math.max(1, Math.round((now - ledger.startedAt) / 6e4));
+  const lines = [];
+  lines.push(
+    `[fidacy] SESSION REPORT \xB7 ${ledger.total} agent actions watched over ${minutes} min \xB7 nothing left this machine`
+  );
+  for (const category of ORDER) {
+    const tally = ledger.byCategory.get(category);
+    if (!tally) continue;
+    const capped = tally.targets.size >= TARGET_CAP ? "+" : "";
+    const parts = [`${tally.calls} ${tally.calls === 1 ? "call" : "calls"}`];
+    if (tally.targets.size > 0) parts.push(`${tally.targets.size}${capped} distinct`);
+    if (tally.failures > 0) parts.push(`${tally.failures} failed`);
+    lines.push(`[fidacy]   ${LABEL[category].padEnd(20)} ${parts.join(" \xB7 ")}`);
+  }
+  const money2 = ledger.byCategory.get("money");
+  if (!money2) {
+    lines.push(`[fidacy]   no money-moving action was attempted \xB7 the firewall stayed armed and idle`);
+  }
+  lines.push(`[fidacy]   digest    ${ledger.head}`);
+  if (logPath) lines.push(`[fidacy]   log       ${logPath}${ledger.truncated ? " (partial: action cap reached)" : ""}`);
+  lines.push(
+    activated ? `[fidacy]   anchored to the audit chain \xB7 verify: ${verifyUrl(ledger.head)}` : `[fidacy]   activate free to anchor this digest so nobody can rewrite it later: https://fidacy.com/claim`
+  );
+  return lines.join("\n");
+}
+var MIN_ACTIONS_FOR_REPORT = 5;
+function installObserver(api, emit, isActivated, now = Date.now, anchor) {
+  if (typeof api?.on !== "function") return;
+  const ledgers = /* @__PURE__ */ new Map();
+  const LEDGER_CAP = 50;
+  const ledgerFor = (sessionId) => {
+    let ledger = ledgers.get(sessionId);
+    if (!ledger) {
+      if (ledgers.size >= LEDGER_CAP) ledgers.delete(ledgers.keys().next().value);
+      ledger = newLedger(sessionId, now());
+      ledgers.set(sessionId, ledger);
+    }
+    return ledger;
+  };
+  api.on(
+    "before_tool_call",
+    (event, ctx) => {
+      try {
+        const toolName = typeof event.toolName === "string" ? event.toolName : "unknown";
+        const paths = Array.isArray(event.derivedPaths) ? event.derivedPaths : void 0;
+        const sessionId = sessionIdOf(ctx);
+        record(ledgerFor(sessionId), toolName, paths, false);
+      } catch {
+      }
+    },
+    // Lowest priority on purpose: anything that actually decides should run first,
+    // and we only want to count what the host was really about to do.
+    { priority: 1 }
+  );
+  api.on("session_end", async (event, ctx) => {
+    try {
+      const sessionId = sessionIdOf(ctx) || (typeof event.sessionId === "string" ? event.sessionId : "");
+      const ledger = ledgers.get(sessionId);
+      if (!ledger) return;
+      ledgers.delete(sessionId);
+      if (ledger.total < MIN_ACTIONS_FOR_REPORT) return;
+      const logPath = persist(ledger, now());
+      let anchored = false;
+      if (anchor) {
+        anchored = await anchor(ledger.head, ledger.sessionId, rollup(ledger)).catch(() => false);
+      }
+      if (!anchored) queuePending(ledger.head, ledger.sessionId, now(), ledger.total, rollup(ledger));
+      const report = renderReport(ledger, now(), anchored, logPath);
+      if (report) emit(report);
+    } catch {
+    }
+  });
+  api.on("gateway_stop", () => drain());
+  process.on("exit", () => drain());
+  function drain() {
+    try {
+      for (const [id, ledger] of ledgers) {
+        ledgers.delete(id);
+        if (ledger.total < MIN_ACTIONS_FOR_REPORT) continue;
+        const logPath = persist(ledger, now());
+        queuePending(ledger.head, ledger.sessionId, now(), ledger.total, rollup(ledger));
+        const report = renderReport(ledger, now(), false, logPath);
+        if (report) emit(report);
+      }
+    } catch {
+    }
+  }
+  function rollup(ledger) {
+    const out = {};
+    for (const [cat, tally] of ledger.byCategory) out[cat] = tally.calls;
+    return out;
+  }
+  function persist(ledger, at) {
+    return writeSessionLog(ledger.sessionId, ledger.actions, ledger.head, {
+      startedAt: new Date(ledger.startedAt).toISOString(),
+      endedAt: new Date(at).toISOString(),
+      totalActions: ledger.total,
+      truncated: ledger.truncated,
+      byCategory: Object.fromEntries(
+        [...ledger.byCategory].map(([k, v]) => [k, { calls: v.calls, failures: v.failures, distinct: v.targets.size }])
+      )
+    });
+  }
+}
+function sessionIdOf(ctx) {
+  if (!ctx) return "default";
+  const id = ctx.sessionId ?? ctx.sessionKey;
+  return typeof id === "string" && id.length > 0 ? id : "default";
+}
+
 // ../firewall/dist/util.js
 function stableStringify(obj) {
   if (obj === null || typeof obj !== "object")
@@ -4253,7 +4578,7 @@ function publicKeyPem(publicKey) {
 function sign(privateKey, message) {
   return crypto.sign(null, Buffer.from(message, "utf8"), privateKey).toString("base64url");
 }
-function sha256(input) {
+function sha2562(input) {
   return crypto.createHash("sha256").update(input).digest("hex");
 }
 
@@ -4482,10 +4807,10 @@ var DevFidacyCore = class {
     return decision;
   }
   async getProof(decisionId) {
-    const record2 = this.store.find(decisionId);
-    if (!record2)
+    const record3 = this.store.find(decisionId);
+    if (!record3)
       return null;
-    return { record: record2, chainIntact: this.store.intact(), verifiedAgainstPublicKey: this.pubPem };
+    return { record: record3, chainIntact: this.store.intact(), verifiedAgainstPublicKey: this.pubPem };
   }
   async history(limit = 50) {
     const all = this.store.records();
@@ -4588,36 +4913,36 @@ var FileAuditStore = class {
     const prevHash = this.head();
     const seq = this.chain.length;
     const ts2 = decision.ts;
-    const digest = sha256(stableStringify({ decisionId: decision.decisionId, status: decision.status, request: decision.request, violatedRule: decision.violatedRule ?? null }));
-    const hash = sha256(`${prevHash}|${digest}|${seq}|${ts2}`);
-    const record2 = { seq, decisionId: decision.decisionId, status: decision.status, subject: decision.subject, digest, prevHash, hash, ts: ts2 };
+    const digest = sha2562(stableStringify({ decisionId: decision.decisionId, status: decision.status, request: decision.request, violatedRule: decision.violatedRule ?? null }));
+    const hash = sha2562(`${prevHash}|${digest}|${seq}|${ts2}`);
+    const record3 = { seq, decisionId: decision.decisionId, status: decision.status, subject: decision.subject, digest, prevHash, hash, ts: ts2 };
     if (typeof decision.request?.purpose === "string" && decision.request.purpose.trim()) {
-      record2.purpose = decision.request.purpose.slice(0, 500);
+      record3.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);
+      record3.payee = decision.request.payee.slice(0, 200);
     }
     if (decision.status === "ALLOW") {
       const req = decision.request;
       if (typeof req?.amount === "number" && Number.isFinite(req.amount))
-        record2.amount = req.amount;
+        record3.amount = req.amount;
       if (typeof req?.currency === "string")
-        record2.currency = req.currency;
+        record3.currency = req.currency;
       const invoice = canonInvoice(req?.invoiceRef);
       if (invoice)
-        record2.invoiceRef = invoice;
+        record3.invoiceRef = invoice;
     } else {
       if (decision.violatedRule)
-        record2.violatedRule = decision.violatedRule;
+        record3.violatedRule = decision.violatedRule;
       const req = decision.request;
       if (typeof req?.amount === "number" && Number.isFinite(req.amount))
-        record2.amount = req.amount;
+        record3.amount = req.amount;
       if (typeof req?.currency === "string")
-        record2.currency = req.currency;
+        record3.currency = req.currency;
     }
-    fs.appendFileSync(this.path, JSON.stringify(record2) + "\n");
-    this.chain.push(record2);
-    return record2;
+    fs.appendFileSync(this.path, JSON.stringify(record3) + "\n");
+    this.chain.push(record3);
+    return record3;
   }
   find(decisionId) {
     return this.chain.find((r) => r.decisionId === decisionId);
@@ -4629,7 +4954,7 @@ var FileAuditStore = class {
   intact() {
     let prev = "GENESIS";
     for (const r of this.chain) {
-      const expected = sha256(`${prev}|${r.digest}|${r.seq}|${r.ts}`);
+      const expected = sha2562(`${prev}|${r.digest}|${r.seq}|${r.ts}`);
       if (expected !== r.hash || r.prevHash !== prev)
         return false;
       prev = r.hash;
@@ -4643,37 +4968,37 @@ import { statSync } from "node:fs";
 
 // ../mcp/src/config.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 import {
   existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
 } from "node:fs";
 function hasEngineKey(keyOverride) {
   return Boolean((keyOverride ?? process.env.FIDACY_ENGINE_API_KEY ?? "").trim());
 }
 function configDir() {
-  return process.env.FIDACY_CONFIG_DIR ?? join(homedir(), ".fidacy");
+  return process.env.FIDACY_CONFIG_DIR ?? join2(homedir2(), ".fidacy");
 }
 function configPath() {
-  return join(configDir(), "config.json");
+  return join2(configDir(), "config.json");
 }
 function auditLogPath() {
   if (process.env.FIDACY_AUDIT_PATH) return process.env.FIDACY_AUDIT_PATH;
-  const dir = join(configDir(), "audit");
+  const dir = join2(configDir(), "audit");
   try {
-    mkdirSync(dir, { recursive: true, mode: 448 });
+    mkdirSync2(dir, { recursive: true, mode: 448 });
   } catch {
   }
-  return join(dir, "audit.log");
+  return join2(dir, "audit.log");
 }
 function readConfig() {
   const p = configPath();
   if (!existsSync(p)) return null;
   try {
-    const raw = JSON.parse(readFileSync(p, "utf8"));
+    const raw = JSON.parse(readFileSync2(p, "utf8"));
     if (!raw || typeof raw.anon_id !== "string") return null;
     return {
       anon_id: raw.anon_id,
@@ -4695,8 +5020,8 @@ function readConfig() {
 }
 function writeConfig(cfg) {
   const dir = configDir();
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  writeFileSync(configPath(), JSON.stringify(cfg, null, 2), { mode: 384 });
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  writeFileSync2(configPath(), JSON.stringify(cfg, null, 2), { mode: 384 });
 }
 function ensureState() {
   const existing = readConfig();
@@ -4741,7 +5066,7 @@ function resolveMandateRules(cfg) {
 }
 
 // ../mcp/src/telemetry.ts
-var CLIENT_VERSION = true ? "0.4.3" : "dev";
+var CLIENT_VERSION = true ? "0.5.1" : "dev";
 function bandOf(amount) {
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0) return void 0;
   if (amount < 10) return "lt10";
@@ -4800,7 +5125,7 @@ function resultOf(status, violatedRule) {
   if (r.startsWith("non_positive_amount") || r.startsWith("invalid_")) return "deny_invalid";
   return "deny_scope";
 }
-function record(type, result, band, capRatio, action) {
+function record2(type, result, band, capRatio, action) {
   if (!telemetryEnabled()) return;
   armExitFlush();
   buffer.push({
@@ -4820,10 +5145,10 @@ function record(type, result, band, capRatio, action) {
     if (typeof flushTimer.unref === "function") flushTimer.unref();
   }
 }
-var recordInstall = () => record("install");
-var recordAgentActive = () => record("agent_active");
-var recordDecision = (status, violatedRule, amount, perTxMax) => record("decision", resultOf(status, violatedRule), bandOf(amount), capRatioOf(amount, perTxMax));
-var recordUpgradeIntent = () => record("upgrade_intent");
+var recordInstall = () => record2("install");
+var recordAgentActive = () => record2("agent_active");
+var recordDecision = (status, violatedRule, amount, perTxMax) => record2("decision", resultOf(status, violatedRule), bandOf(amount), capRatioOf(amount, perTxMax));
+var recordUpgradeIntent = () => record2("upgrade_intent");
 async function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -4929,7 +5254,7 @@ function requestUpgrade() {
 }
 
 // ../mcp/src/provision.ts
-var CLIENT_VERSION2 = true ? "0.4.3" : "dev";
+var CLIENT_VERSION2 = true ? "0.5.1" : "dev";
 function provisionEnabled() {
   const v = (process.env.FIDACY_DISABLE_PROVISION ?? "").trim().toLowerCase();
   return !(v === "1" || v === "true" || v === "yes");
@@ -5071,7 +5396,7 @@ function trialCountdownLine(keyOverride) {
 }
 
 // ../mcp/src/register.ts
-var CLIENT_VERSION3 = true ? "0.4.3" : "dev";
+var CLIENT_VERSION3 = true ? "0.5.1" : "dev";
 function endpoint3() {
   const base = (process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com").replace(/\/$/, "");
   return `${base}/v1/register`;
@@ -5524,7 +5849,7 @@ async function postOnce(fetchImpl, url, headers, payload, timeoutMs) {
 }
 
 // ../mcp/src/artifacts.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { pipeline } from "node:stream/promises";
 var ARTIFACT_KINDS = [
@@ -5540,7 +5865,7 @@ var ARTIFACT_KINDS = [
   "custom"
 ];
 async function hashFile(path) {
-  const hash = createHash("sha256");
+  const hash = createHash3("sha256");
   await pipeline(createReadStream(path), async function* (source) {
     for await (const chunk of source) {
       hash.update(chunk);
@@ -5584,8 +5909,8 @@ async function engineFetch(method, pathAndQuery, cfg, body) {
 async function anchorArtifact(params, cfg) {
   return await engineFetch("POST", "/v1/artifacts", cfg, params);
 }
-async function findArtifacts(sha2562, cfg) {
-  return await engineFetch("GET", `/v1/artifacts?sha256=${sha2562}`, cfg);
+async function findArtifacts(sha2563, cfg) {
+  return await engineFetch("GET", `/v1/artifacts?sha256=${sha2563}`, cfg);
 }
 
 // src/index.ts
@@ -5618,7 +5943,7 @@ function maybeRegisterOperator(config) {
   });
 }
 var ASSESS_KINDS = ["ap2_payment", "message_send", "voice_call", "custom", "claim_document"];
-var index_default = defineToolPlugin({
+var entry = defineToolPlugin({
   id: "fidacy",
   name: "Fidacy \u2014 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.",
@@ -5800,12 +6125,12 @@ ${d.grant}` : `DENY (decision ${d.decisionId}). Rule violated: ${d.violatedRule}
         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 record3 = records.find((r) => r.decisionId === params.decisionId);
+          if (!record3) 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),
+            record: record3,
+            explanation: explainRule(record3.violatedRule, record3.payee),
             chainIntact: proof?.chainIntact ?? null
           };
         }
@@ -5983,6 +6308,82 @@ Your local protection keeps working meanwhile; your usage history migrates to th
     ];
   }
 });
+function machineSubject() {
+  try {
+    const id = ensureState().config.anon_id;
+    return id ? `agent:${String(id).slice(0, 8)}` : "agent:unknown";
+  } catch {
+    return "agent:unknown";
+  }
+}
+var registerTools = entry.register;
+entry.register = (api) => {
+  registerTools(api);
+  const creds = () => {
+    try {
+      const cfg = ensureState().config;
+      const apiKey = (cfg.api_key || process.env.FIDACY_ENGINE_API_KEY || "").trim();
+      if (!apiKey) return null;
+      return { engineUrl: process.env.FIDACY_ENGINE_URL ?? "https://api.fidacy.com", apiKey };
+    } catch {
+      return null;
+    }
+  };
+  const anchor = async (head, sessionId, byCategory = {}) => {
+    const cfg = creds();
+    if (!cfg) return false;
+    try {
+      const total = Object.values(byCategory).reduce((a, b) => a + b, 0);
+      await anchorArtifact(
+        {
+          sha256: head,
+          kind: "custom",
+          label: sessionLabel(sessionId, total, byCategory),
+          // Which install produced the session, so a fleet view can group by
+          // machine. The anon id is a random UUID minted on this machine and
+          // tied to no person, which is the point: the cockpit answers "which
+          // agent" without ever learning "which human".
+          subject: machineSubject()
+        },
+        cfg
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  installObserver(
+    api,
+    // Same channel as the boot banner: stderr is where the human operator looks,
+    // and stdout belongs to the MCP/JSON-RPC framing in the other shell.
+    (line) => console.error(line),
+    () => creds() !== null,
+    Date.now,
+    anchor
+  );
+  let drained = false;
+  if (typeof api?.on !== "function") return;
+  api.on(
+    "before_tool_call",
+    () => {
+      if (drained) return;
+      drained = true;
+      void (async () => {
+        if (!creds()) return;
+        for (const p of takePending()) {
+          if (!await anchor(p.head, p.sessionId, p.byCategory ?? {})) {
+            queuePending(p.head, p.sessionId, p.at, p.total ?? 0, p.byCategory ?? {});
+          }
+        }
+      })().catch(() => {
+      });
+    },
+    // Below the observer, which is itself the lowest: catch-up must never sit in
+    // front of anything that decides, and must never be what a tool call waits on.
+    { priority: 0 }
+  );
+};
+var index_default = entry;
 export {
   index_default as default
 };

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Fidacy AI Agent 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.4.3",
+  "version": "0.5.1",
   "contracts": {
     "tools": [
       "request_payment",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidacy/openclaw-plugin",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "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",
   "author": "Fidacy (ZeepCode Group Technology LLC) <hello@fidacy.com> (https://fidacy.com)",