calllint 0.9.3 → 1.0.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import { execFileSync } from "node:child_process";
 
 // src/args.ts
@@ -247,17 +247,17 @@ function loadPolicyFile(path) {
   let text;
   try {
     text = readFileSync(path, "utf8");
-  } catch (err) {
+  } catch (err2) {
     throw new PolicyLoadError(
-      `Could not read policy file ${path}: ${err instanceof Error ? err.message : String(err)}`
+      `Could not read policy file ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
   let parsed;
   try {
     parsed = JSON.parse(text);
-  } catch (err) {
+  } catch (err2) {
     throw new PolicyLoadError(
-      `Policy file ${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+      `Policy file ${path} is not valid JSON: ${err2 instanceof Error ? err2.message : String(err2)}`
     );
   }
   return validatePolicy(parsed);
@@ -771,7 +771,7 @@ var SECRET_HINTS = [
 ];
 function looksSecret(key) {
   const upper = key.toUpperCase();
-  return SECRET_HINTS.some((h) => upper.includes(h));
+  return SECRET_HINTS.some((h2) => upper.includes(h2));
 }
 function extractDockerEnvKeys(args) {
   const keys = [];
@@ -1095,14 +1095,14 @@ var MUTATION_HINTS = [
 function collectHints(text) {
   if (!text) return [];
   const lower = text.toLowerCase();
-  return MUTATION_HINTS.filter((h) => lower.includes(h));
+  return MUTATION_HINTS.filter((h2) => lower.includes(h2));
 }
 function detectExternalMutation(ctx) {
   const { server, binding } = ctx;
   const hints = /* @__PURE__ */ new Set();
   const evidence = [];
-  for (const h of collectHints(binding.packageName)) {
-    hints.add(h);
+  for (const h2 of collectHints(binding.packageName)) {
+    hints.add(h2);
     evidence.push({
       type: "runtime-binding",
       key: "package",
@@ -1110,8 +1110,8 @@ function detectExternalMutation(ctx) {
     });
   }
   for (const tool of server.providedTools) {
-    for (const h of collectHints(tool.name)) {
-      hints.add(h);
+    for (const h2 of collectHints(tool.name)) {
+      hints.add(h2);
       evidence.push({ type: "tool-metadata", key: "tool", value: tool.name });
     }
   }
@@ -1189,7 +1189,7 @@ var PAYMENT_ACTION_VERBS = [
 function collectHints2(text) {
   if (!text) return [];
   const lower = text.toLowerCase();
-  return FINANCIAL_HINTS.filter((h) => lower.includes(h));
+  return FINANCIAL_HINTS.filter((h2) => lower.includes(h2));
 }
 function collectActionVerbs(text) {
   if (!text) return [];
@@ -1244,8 +1244,8 @@ function detectFinancialAction(ctx) {
   }
   const hints = /* @__PURE__ */ new Set();
   const evidence = [];
-  for (const h of collectHints2(binding.packageName)) {
-    hints.add(h);
+  for (const h2 of collectHints2(binding.packageName)) {
+    hints.add(h2);
     evidence.push({
       type: "runtime-binding",
       key: "package",
@@ -1253,8 +1253,8 @@ function detectFinancialAction(ctx) {
     });
   }
   for (const tool of server.providedTools) {
-    for (const h of collectHints2(tool.name)) {
-      hints.add(h);
+    for (const h2 of collectHints2(tool.name)) {
+      hints.add(h2);
       evidence.push({ type: "tool-metadata", key: "tool", value: tool.name });
     }
   }
@@ -1393,7 +1393,7 @@ var SEND_PATTERNS = [
 function packageHint(name) {
   if (!name) return void 0;
   const lower = name.toLowerCase();
-  return MESSAGING_PACKAGE_HINTS.find((h) => lower.includes(h));
+  return MESSAGING_PACKAGE_HINTS.find((h2) => lower.includes(h2));
 }
 function textMatchesSend(text) {
   if (!text) return false;
@@ -1456,7 +1456,7 @@ function readOauth(raw) {
 function broadScope(scopes) {
   for (const s of scopes) {
     const lower = s.toLowerCase();
-    if (BROAD_SCOPE_HINTS.some((h) => lower === h || lower.includes(h))) return s;
+    if (BROAD_SCOPE_HINTS.some((h2) => lower === h2 || lower.includes(h2))) return s;
   }
   return void 0;
 }
@@ -1862,8 +1862,8 @@ var ConfigParseError = class extends Error {
 function parseJsonText(text, path) {
   try {
     return JSON.parse(text);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const reason = err2 instanceof Error ? err2.message : String(err2);
     throw new ConfigParseError(`Invalid JSON: ${reason}`, path);
   }
 }
@@ -2576,7 +2576,7 @@ function classifySurface(path, content) {
   if (/(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock)$/.test(n)) return "NOOP";
   const base = basename2(path);
   if (MCP_CONFIG_BASENAMES.has(base)) return "SCAN";
-  if (MCP_PATH_HINTS.some((h) => normalize(path).includes(normalize(h)))) return "SCAN";
+  if (MCP_PATH_HINTS.some((h2) => normalize(path).includes(normalize(h2)))) return "SCAN";
   if (base === "config.toml" && content && /\[mcp_servers?\.[^\]]+\]/.test(content)) {
     return "SCAN";
   }
@@ -3892,10 +3892,10 @@ function scanCommand(args, deps) {
   let policy;
   try {
     policy = loadPolicyOrDefault(policyPath);
-  } catch (err) {
+  } catch (err2) {
     return {
       stdout: "",
-      stderr: err instanceof Error ? err.message : String(err),
+      stderr: err2 instanceof Error ? err2.message : String(err2),
       exitCode: EXIT.ERROR
     };
   }
@@ -3918,15 +3918,15 @@ function scanOneConfig(text, configPath, policy, args, deps, allowReceipt = true
       extraFindings: deps.online?.extraFindings,
       surfaces
     });
-  } catch (err) {
-    if (err instanceof ConfigParseError) {
+  } catch (err2) {
+    if (err2 instanceof ConfigParseError) {
       return {
         stdout: "",
-        stderr: `Parse error in ${configPath}: ${err.message}`,
+        stderr: `Parse error in ${configPath}: ${err2.message}`,
         exitCode: EXIT.ERROR
       };
     }
-    throw err;
+    throw err2;
   }
   if (deps.writeCacheFile !== false) {
     try {
@@ -3936,8 +3936,8 @@ function scanOneConfig(text, configPath, policy, args, deps, allowReceipt = true
   }
   const stdout = renderSummary(summary, args);
   if (allowReceipt && flagBool(args.flags, "receipt")) {
-    const err = writeReceiptFile(summary, text, configPath, policy, args, deps);
-    if (err) return { stdout: "", stderr: err, exitCode: EXIT.ERROR };
+    const err2 = writeReceiptFile(summary, text, configPath, policy, args, deps);
+    if (err2) return { stdout: "", stderr: err2, exitCode: EXIT.ERROR };
   }
   const exitCode = flagBool(args.flags, "ci") ? exitCodeFor(summary, policy) : EXIT.OK;
   return { stdout, exitCode };
@@ -3982,10 +3982,10 @@ function scanChangedCommand(args, deps) {
   let policy;
   try {
     policy = loadPolicyOrDefault(policyPath);
-  } catch (err) {
+  } catch (err2) {
     return {
       stdout: "",
-      stderr: err instanceof Error ? err.message : String(err),
+      stderr: err2 instanceof Error ? err2.message : String(err2),
       exitCode: EXIT.ERROR
     };
   }
@@ -4114,7 +4114,7 @@ function genRuleCommand(args, deps) {
   const host = flagStr(args.flags, "host");
   if (!host) {
     const list = RULE_HOSTS.map(
-      (h) => `  ${h.padEnd(10)} \u2192 ${RULE_TARGETS[h].path}  (${RULE_TARGETS[h].label})`
+      (h2) => `  ${h2.padEnd(10)} \u2192 ${RULE_TARGETS[h2].path}  (${RULE_TARGETS[h2].label})`
     ).join("\n");
     return {
       stdout: `Usage: calllint gen-rule --host <host> [--write] [--out <path>]
@@ -4167,10 +4167,10 @@ function diagnosticsCommand(args, deps) {
   let policy;
   try {
     policy = loadPolicyOrDefault(flagStr(args.flags, "policy"));
-  } catch (err) {
+  } catch (err2) {
     return {
       stdout: "",
-      stderr: err instanceof Error ? err.message : String(err),
+      stderr: err2 instanceof Error ? err2.message : String(err2),
       exitCode: EXIT.ERROR
     };
   }
@@ -4187,15 +4187,15 @@ function diagnosticsCommand(args, deps) {
       generatedAt: deps.generatedAt,
       extraFindings: deps.online?.extraFindings
     });
-  } catch (err) {
-    if (err instanceof ConfigParseError) {
+  } catch (err2) {
+    if (err2 instanceof ConfigParseError) {
       return {
         stdout: "",
-        stderr: `Parse error in ${configPath}: ${err.message}`,
+        stderr: `Parse error in ${configPath}: ${err2.message}`,
         exitCode: EXIT.ERROR
       };
     }
-    throw err;
+    throw err2;
   }
   const stdout = renderDiagnostics(summary);
   const exitCode = flagBool(args.flags, "ci") ? exitCodeFor(summary, policy) : EXIT.OK;
@@ -4255,10 +4255,10 @@ function policyCommand(args, deps) {
     try {
       const policy = loadPolicyOrDefault(flagStr(args.flags, "policy"));
       return { stdout: JSON.stringify(policy, null, 2), exitCode: EXIT.OK };
-    } catch (err) {
+    } catch (err2) {
       return {
         stdout: "",
-        stderr: err instanceof Error ? err.message : String(err),
+        stderr: err2 instanceof Error ? err2.message : String(err2),
         exitCode: EXIT.ERROR
       };
     }
@@ -4275,8 +4275,8 @@ import { join as join10 } from "node:path";
 function loadPolicy(args) {
   try {
     return loadPolicyOrDefault(flagStr(args.flags, "policy"));
-  } catch (err) {
-    return { error: err instanceof Error ? err.message : String(err) };
+  } catch (err2) {
+    return { error: err2 instanceof Error ? err2.message : String(err2) };
   }
 }
 function baselinePathFor(args, cwd) {
@@ -4294,19 +4294,19 @@ function baselineCommand(args, deps) {
       generatedAt: deps.generatedAt,
       extraFindings: deps.online?.extraFindings
     });
-  } catch (err) {
-    if (err instanceof ConfigParseError) {
-      return { stdout: "", stderr: `Parse error in ${input.configPath}: ${err.message}`, exitCode: EXIT.ERROR };
+  } catch (err2) {
+    if (err2 instanceof ConfigParseError) {
+      return { stdout: "", stderr: `Parse error in ${input.configPath}: ${err2.message}`, exitCode: EXIT.ERROR };
     }
-    throw err;
+    throw err2;
   }
   const baseline = buildBaseline(summary, deps.generatedAt);
   const path = baselinePathFor(args, deps.cwd);
   if (deps.writeBaselineFile !== false) {
     try {
       writeBaseline(baseline, path);
-    } catch (err) {
-      return { stdout: "", stderr: `Could not write baseline: ${String(err)}`, exitCode: EXIT.ERROR };
+    } catch (err2) {
+      return { stdout: "", stderr: `Could not write baseline: ${String(err2)}`, exitCode: EXIT.ERROR };
     }
   }
   if (flagBool(args.flags, "json")) {
@@ -4342,11 +4342,11 @@ function verifyCommand(args, deps) {
       generatedAt: deps.generatedAt,
       extraFindings: deps.online?.extraFindings
     });
-  } catch (err) {
-    if (err instanceof ConfigParseError) {
-      return { stdout: "", stderr: `Parse error in ${input.configPath}: ${err.message}`, exitCode: EXIT.ERROR };
+  } catch (err2) {
+    if (err2 instanceof ConfigParseError) {
+      return { stdout: "", stderr: `Parse error in ${input.configPath}: ${err2.message}`, exitCode: EXIT.ERROR };
     }
-    throw err;
+    throw err2;
   }
   const drift = computeDrift(baseline, summary, deps.generatedAt);
   const stdout = flagBool(args.flags, "json") ? renderDriftJson(drift) : renderDrift(drift);
@@ -4391,8 +4391,8 @@ function approveCommand(args, deps) {
   if (deps.writeFile !== false) {
     try {
       writeApproved(state, path);
-    } catch (err) {
-      return { stdout: "", stderr: `Could not write approved state: ${String(err)}`, exitCode: EXIT.ERROR };
+    } catch (err2) {
+      return { stdout: "", stderr: `Could not write approved state: ${String(err2)}`, exitCode: EXIT.ERROR };
     }
   }
   if (flagBool(args.flags, "json")) {
@@ -4406,22 +4406,611 @@ function approveCommand(args, deps) {
 }
 
 // src/commands/receipt.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
-function receiptCommand(args, deps) {
-  const sub = args.positionals[0];
-  if (sub !== "verify") {
+
+// ../../packages/signature/src/ed25519.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// ../../node_modules/.pnpm/@noble+ed25519@2.3.0/node_modules/@noble/ed25519/index.js
+var ed25519_CURVE = {
+  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+  h: 8n,
+  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+};
+var { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
+var h = 8n;
+var L = 32;
+var L2 = 64;
+var err = (m = "") => {
+  throw new Error(m);
+};
+var isBig = (n) => typeof n === "bigint";
+var isStr = (s) => typeof s === "string";
+var isBytes = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+var abytes = (a, l) => !isBytes(a) || typeof l === "number" && l > 0 && a.length !== l ? err("Uint8Array expected") : a;
+var u8n = (len) => new Uint8Array(len);
+var u8fr = (buf) => Uint8Array.from(buf);
+var padh = (n, pad) => n.toString(16).padStart(pad, "0");
+var bytesToHex = (b) => Array.from(abytes(b)).map((e) => padh(e, 2)).join("");
+var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+var _ch = (ch) => {
+  if (ch >= C._0 && ch <= C._9)
+    return ch - C._0;
+  if (ch >= C.A && ch <= C.F)
+    return ch - (C.A - 10);
+  if (ch >= C.a && ch <= C.f)
+    return ch - (C.a - 10);
+  return;
+};
+var hexToBytes = (hex) => {
+  const e = "hex invalid";
+  if (!isStr(hex))
+    return err(e);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    return err(e);
+  const array = u8n(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = _ch(hex.charCodeAt(hi));
+    const n2 = _ch(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0)
+      return err(e);
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+};
+var toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+var cr = () => globalThis?.crypto;
+var subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined");
+var concatBytes = (...arrs) => {
+  const r = u8n(arrs.reduce((sum, a) => sum + abytes(a).length, 0));
+  let pad = 0;
+  arrs.forEach((a) => {
+    r.set(a, pad);
+    pad += a.length;
+  });
+  return r;
+};
+var randomBytes2 = (len = L) => {
+  const c = cr();
+  return c.getRandomValues(u8n(len));
+};
+var big = BigInt;
+var arange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+var M = (a, b = P) => {
+  const r = a % b;
+  return r >= 0n ? r : b + r;
+};
+var modN = (a) => M(a, N);
+var invert = (num, md) => {
+  if (num === 0n || md <= 0n)
+    err("no inverse n=" + num + " mod=" + md);
+  let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
+  while (a !== 0n) {
+    const q = b / a, r = b % a;
+    const m = x - u * q, n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  return b === 1n ? M(x, md) : err("no inverse");
+};
+var callHash = (name) => {
+  const fn = etc[name];
+  if (typeof fn !== "function")
+    err("hashes." + name + " not set");
+  return fn;
+};
+var apoint = (p) => p instanceof Point ? p : err("Point expected");
+var B256 = 2n ** 256n;
+var Point = class _Point {
+  static BASE;
+  static ZERO;
+  ex;
+  ey;
+  ez;
+  et;
+  constructor(ex, ey, ez, et) {
+    const max = B256;
+    this.ex = arange(ex, 0n, max);
+    this.ey = arange(ey, 0n, max);
+    this.ez = arange(ez, 1n, max);
+    this.et = arange(et, 0n, max);
+    Object.freeze(this);
+  }
+  static fromAffine(p) {
+    return new _Point(p.x, p.y, 1n, M(p.x * p.y));
+  }
+  /** RFC8032 5.1.3: Uint8Array to Point. */
+  static fromBytes(hex, zip215 = false) {
+    const d = _d;
+    const normed = u8fr(abytes(hex, L));
+    const lastByte = hex[31];
+    normed[31] = lastByte & ~128;
+    const y = bytesToNumLE(normed);
+    const max = zip215 ? B256 : P;
+    arange(y, 0n, max);
+    const y2 = M(y * y);
+    const u = M(y2 - 1n);
+    const v = M(d * y2 + 1n);
+    let { isValid, value: x } = uvRatio(u, v);
+    if (!isValid)
+      err("bad point: y not sqrt");
+    const isXOdd = (x & 1n) === 1n;
+    const isLastByteOdd = (lastByte & 128) !== 0;
+    if (!zip215 && x === 0n && isLastByteOdd)
+      err("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== isXOdd)
+      x = M(-x);
+    return new _Point(x, y, 1n, M(x * y));
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a = _a;
+    const d = _d;
+    const p = this;
+    if (p.is0())
+      throw new Error("bad point: ZERO");
+    const { ex: X, ey: Y, ez: Z, et: T } = p;
+    const X2 = M(X * X);
+    const Y2 = M(Y * Y);
+    const Z2 = M(Z * Z);
+    const Z4 = M(Z2 * Z2);
+    const aX2 = M(X2 * a);
+    const left = M(Z2 * M(aX2 + Y2));
+    const right = M(Z4 + M(d * M(X2 * Y2)));
+    if (left !== right)
+      throw new Error("bad point: equation left != right (1)");
+    const XY = M(X * Y);
+    const ZT = M(Z * T);
+    if (XY !== ZT)
+      throw new Error("bad point: equation left != right (2)");
+    return this;
+  }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { ex: X1, ey: Y1, ez: Z1 } = this;
+    const { ex: X2, ey: Y2, ez: Z2 } = apoint(other);
+    const X1Z2 = M(X1 * Z2);
+    const X2Z1 = M(X2 * Z1);
+    const Y1Z2 = M(Y1 * Z2);
+    const Y2Z1 = M(Y2 * Z1);
+    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+  }
+  is0() {
+    return this.equals(I);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new _Point(M(-this.ex), this.ey, this.ez, M(-this.et));
+  }
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { ex: X1, ey: Y1, ez: Z1 } = this;
+    const a = _a;
+    const A = M(X1 * X1);
+    const B = M(Y1 * Y1);
+    const C2 = M(2n * M(Z1 * Z1));
+    const D = M(a * A);
+    const x1y1 = X1 + Y1;
+    const E = M(M(x1y1 * x1y1) - A - B);
+    const G2 = D + B;
+    const F = G2 - C2;
+    const H = D - B;
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+  add(other) {
+    const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+    const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other);
+    const a = _a;
+    const d = _d;
+    const A = M(X1 * X2);
+    const B = M(Y1 * Y2);
+    const C2 = M(T1 * d * T2);
+    const D = M(Z1 * Z2);
+    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+    const F = M(D - C2);
+    const G2 = M(D + C2);
+    const H = M(B - a * A);
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n, safe = true) {
+    if (!safe && (n === 0n || this.is0()))
+      return I;
+    arange(n, 1n, N);
+    if (n === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF(n).p;
+    let p = I;
+    let f = G;
+    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+      if (n & 1n)
+        p = p.add(d);
+      else if (safe)
+        f = f.add(d);
+    }
+    return p;
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { ex: x, ey: y, ez: z } = this;
+    if (this.equals(I))
+      return { x: 0n, y: 1n };
+    const iz = invert(z, P);
+    if (M(z * iz) !== 1n)
+      err("invalid inverse");
+    return { x: M(x * iz), y: M(y * iz) };
+  }
+  toBytes() {
+    const { x, y } = this.assertValidity().toAffine();
+    const b = numTo32bLE(y);
+    b[31] |= x & 1n ? 128 : 0;
+    return b;
+  }
+  toHex() {
+    return bytesToHex(this.toBytes());
+  }
+  // encode to hex string
+  clearCofactor() {
+    return this.multiply(big(h), false);
+  }
+  isSmallOrder() {
+    return this.clearCofactor().is0();
+  }
+  isTorsionFree() {
+    let p = this.multiply(N / 2n, false).double();
+    if (N % 2n)
+      p = p.add(this);
+    return p.is0();
+  }
+  static fromHex(hex, zip215) {
+    return _Point.fromBytes(toU8(hex), zip215);
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  toRawBytes() {
+    return this.toBytes();
+  }
+};
+var G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+var I = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I;
+var numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+var bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes(b)).reverse()));
+var pow2 = (x, power) => {
+  let r = x;
+  while (power-- > 0n) {
+    r *= r;
+    r %= P;
+  }
+  return r;
+};
+var pow_2_252_3 = (x) => {
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, 2n) * b2 % P;
+  const b5 = pow2(b4, 1n) * x % P;
+  const b10 = pow2(b5, 5n) * b5 % P;
+  const b20 = pow2(b10, 10n) * b10 % P;
+  const b40 = pow2(b20, 20n) * b20 % P;
+  const b80 = pow2(b40, 40n) * b40 % P;
+  const b160 = pow2(b80, 80n) * b80 % P;
+  const b240 = pow2(b160, 80n) * b80 % P;
+  const b250 = pow2(b240, 10n) * b10 % P;
+  const pow_p_5_8 = pow2(b250, 2n) * x % P;
+  return { pow_p_5_8, b2 };
+};
+var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+var uvRatio = (u, v) => {
+  const v3 = M(v * v * v);
+  const v7 = M(v3 * v3 * v);
+  const pow = pow_2_252_3(u * v7).pow_p_5_8;
+  let x = M(u * v3 * pow);
+  const vx2 = M(v * x * x);
+  const root1 = x;
+  const root2 = M(x * RM1);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === M(-u);
+  const noRoot = vx2 === M(-u * RM1);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if ((M(x) & 1n) === 1n)
+    x = M(-x);
+  return { isValid: useRoot1 || useRoot2, value: x };
+};
+var modL_LE = (hash) => modN(bytesToNumLE(hash));
+var sha512a = (...m) => etc.sha512Async(...m);
+var sha512s = (...m) => callHash("sha512Sync")(...m);
+var hash2extK = (hashed) => {
+  const head = hashed.slice(0, L);
+  head[0] &= 248;
+  head[31] &= 127;
+  head[31] |= 64;
+  const prefix = hashed.slice(L, L2);
+  const scalar = modL_LE(head);
+  const point = G.multiply(scalar);
+  const pointBytes = point.toBytes();
+  return { head, prefix, scalar, point, pointBytes };
+};
+var getExtendedPublicKeyAsync = (priv) => sha512a(toU8(priv, L)).then(hash2extK);
+var getExtendedPublicKey = (priv) => hash2extK(sha512s(toU8(priv, L)));
+var getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
+var hashFinishS = (res) => res.finish(sha512s(res.hashable));
+var _sign = (e, rBytes, msg) => {
+  const { pointBytes: P2, scalar: s } = e;
+  const r = modL_LE(rBytes);
+  const R = G.multiply(r).toBytes();
+  const hashable = concatBytes(R, P2, msg);
+  const finish = (hashed) => {
+    const S = modN(r + modL_LE(hashed) * s);
+    return abytes(concatBytes(R, numTo32bLE(S)), L2);
+  };
+  return { hashable, finish };
+};
+var sign = (msg, privKey) => {
+  const m = toU8(msg);
+  const e = getExtendedPublicKey(privKey);
+  const rBytes = sha512s(e.prefix, m);
+  return hashFinishS(_sign(e, rBytes, m));
+};
+var veriOpts = { zip215: true };
+var _verify = (sig, msg, pub, opts = veriOpts) => {
+  sig = toU8(sig, L2);
+  msg = toU8(msg);
+  pub = toU8(pub, L);
+  const { zip215 } = opts;
+  let A;
+  let R;
+  let s;
+  let SB;
+  let hashable = Uint8Array.of();
+  try {
+    A = Point.fromHex(pub, zip215);
+    R = Point.fromHex(sig.slice(0, L), zip215);
+    s = bytesToNumLE(sig.slice(L, L2));
+    SB = G.multiply(s, false);
+    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
+  } catch (error) {
+  }
+  const finish = (hashed) => {
+    if (SB == null)
+      return false;
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = modL_LE(hashed);
+    const RkA = R.add(A.multiply(k, false));
+    return RkA.add(SB.negate()).clearCofactor().is0();
+  };
+  return { hashable, finish };
+};
+var verify = (s, m, p, opts = veriOpts) => hashFinishS(_verify(s, m, p, opts));
+var etc = {
+  sha512Async: async (...messages) => {
+    const s = subtle();
+    const m = concatBytes(...messages);
+    return u8n(await s.digest("SHA-512", m.buffer));
+  },
+  sha512Sync: void 0,
+  bytesToHex,
+  hexToBytes,
+  concatBytes,
+  mod: M,
+  invert,
+  randomBytes: randomBytes2
+};
+var utils = {
+  getExtendedPublicKeyAsync,
+  getExtendedPublicKey,
+  randomPrivateKey: () => randomBytes2(L),
+  precompute: (w = 8, p = G) => {
+    p.multiply(3n);
+    w;
+    return p;
+  }
+  // no-op
+};
+var W = 8;
+var scalarBits = 256;
+var pwindows = Math.ceil(scalarBits / W) + 1;
+var pwindowSize = 2 ** (W - 1);
+var precompute = () => {
+  const points = [];
+  let p = G;
+  let b = p;
+  for (let w = 0; w < pwindows; w++) {
+    b = p;
+    points.push(b);
+    for (let i = 1; i < pwindowSize; i++) {
+      b = b.add(p);
+      points.push(b);
+    }
+    p = b.double();
+  }
+  return points;
+};
+var Gpows = void 0;
+var ctneg = (cnd, p) => {
+  const n = p.negate();
+  return cnd ? n : p;
+};
+var wNAF = (n) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p = I;
+  let f = G;
+  const pow_2_w = 2 ** W;
+  const maxNum = pow_2_w;
+  const mask = big(pow_2_w - 1);
+  const shiftBy = big(W);
+  for (let w = 0; w < pwindows; w++) {
+    let wbits = Number(n & mask);
+    n >>= shiftBy;
+    if (wbits > pwindowSize) {
+      wbits -= maxNum;
+      n += 1n;
+    }
+    const off = w * pwindowSize;
+    const offF = off;
+    const offP = off + Math.abs(wbits) - 1;
+    const isEven = w % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f = f.add(ctneg(isEven, comp[offF]));
+    } else {
+      p = p.add(ctneg(isNeg, comp[offP]));
+    }
+  }
+  return { p, f };
+};
+
+// ../../packages/signature/src/base64url.ts
+function base64urlEncode(bytes) {
+  const base64 = Buffer.from(bytes).toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64urlDecode(str) {
+  const padded = str + "===".slice((str.length + 3) % 4);
+  const base64 = padded.replace(/-/g, "+").replace(/_/g, "/");
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+
+// ../../packages/signature/src/ed25519.ts
+etc.sha512Sync = (...messages) => {
+  const hash = createHash2("sha512");
+  hash.update(etc.concatBytes(...messages));
+  return new Uint8Array(hash.digest());
+};
+function generateKeypair(keyId) {
+  const privateKey = utils.randomPrivateKey();
+  const publicKey = getPublicKey(privateKey);
+  return {
+    privateKey,
+    publicKey,
+    keyId
+  };
+}
+function signReceipt(unsignedReceipt, keypair) {
+  const canonical = stableStringify(unsignedReceipt);
+  const hash = sha256(canonical);
+  const hashHex = hash.slice(7);
+  const hashBytes = Buffer.from(hashHex, "hex");
+  const signatureBytes = sign(hashBytes, keypair.privateKey);
+  const signatureBase64url = base64urlEncode(signatureBytes);
+  return {
+    algorithm: "ed25519",
+    key_id: keypair.keyId,
+    value: signatureBase64url,
+    signed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function verifyReceipt2(signedReceipt, publicKey) {
+  try {
+    const sig = signedReceipt.signature;
+    if (!sig) {
+      return { valid: false, error: "No signature field in receipt" };
+    }
+    if (sig.algorithm !== "ed25519") {
+      return { valid: false, error: `Unsupported algorithm: ${sig.algorithm}` };
+    }
+    const publicKeyBytes = typeof publicKey === "string" ? base64urlDecode(publicKey) : publicKey;
+    if (publicKeyBytes.length !== 32) {
+      return { valid: false, error: "Invalid public key length (expected 32 bytes)" };
+    }
+    const signatureBytes = base64urlDecode(sig.value);
+    if (signatureBytes.length !== 64) {
+      return { valid: false, error: "Invalid signature length (expected 64 bytes)" };
+    }
+    const { signature, ...unsignedReceipt } = signedReceipt;
+    const canonical = stableStringify(unsignedReceipt);
+    const hash = sha256(canonical);
+    const hashHex = hash.slice(7);
+    const hashBytes = Buffer.from(hashHex, "hex");
+    const valid = verify(signatureBytes, hashBytes, publicKeyBytes);
+    return { valid, key_id: sig.key_id };
+  } catch (error) {
     return {
-      stdout: "",
-      stderr: "Usage: calllint receipt verify <receipt.json>",
-      exitCode: EXIT.USAGE
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown verification error"
     };
   }
+}
+function exportKeypair(keypair) {
+  return {
+    key_id: keypair.keyId,
+    algorithm: "ed25519",
+    private_key: base64urlEncode(keypair.privateKey),
+    public_key: base64urlEncode(keypair.publicKey)
+  };
+}
+function importKeypair(json) {
+  if (json.algorithm !== "ed25519") {
+    throw new Error(`Unsupported algorithm: ${json.algorithm}`);
+  }
+  return {
+    keyId: json.key_id,
+    privateKey: base64urlDecode(json.private_key),
+    publicKey: base64urlDecode(json.public_key)
+  };
+}
+
+// src/commands/receipt.ts
+function receiptCommand(args, deps) {
+  const sub = args.positionals[0];
+  switch (sub) {
+    case "verify":
+      return receiptVerify(args, deps);
+    case "sign":
+      return receiptSign(args, deps);
+    case "keygen":
+      return receiptKeygen(args, deps);
+    default:
+      return {
+        stdout: "",
+        stderr: [
+          "Usage: calllint receipt <subcommand>",
+          "",
+          "Subcommands:",
+          "  verify <receipt.json>              Validate receipt structure and signature",
+          "  sign <receipt.json> --key <file>   Sign receipt locally (development only)",
+          "  keygen --out <file>                Generate test keypair (development only)"
+        ].join("\n"),
+        exitCode: EXIT.USAGE
+      };
+  }
+}
+function receiptVerify(args, deps) {
   const file = args.positionals[1];
   if (!file) {
     return {
       stdout: "",
-      stderr: "Usage: calllint receipt verify <receipt.json>",
+      stderr: "Usage: calllint receipt verify <receipt.json> [--public-key <keyfile>]",
       exitCode: EXIT.USAGE
     };
   }
@@ -4449,31 +5038,224 @@ function receiptCommand(args, deps) {
     return { stdout: "", stderr: `CallLint receipt: invalid
   - ${msg}`, exitCode: 1 };
   }
-  const result = verifyReceipt(parsed);
+  const structResult = verifyReceipt(parsed);
+  if (!structResult.valid) {
+    if (flagBool(args.flags, "json")) {
+      return {
+        stdout: JSON.stringify(structResult, null, 2),
+        exitCode: 1
+      };
+    }
+    const lines = ["CallLint receipt: invalid", ...structResult.errors.map((e) => `  - ${e}`)];
+    return { stdout: "", stderr: lines.join("\n"), exitCode: 1 };
+  }
+  const receipt = parsed;
+  if (receipt.signature) {
+    return verifySignature(receipt, args, deps);
+  }
+  if (flagBool(args.flags, "json")) {
+    return {
+      stdout: JSON.stringify(
+        {
+          valid: true,
+          receipt_id: receipt.receipt_id,
+          schema_version: receipt.schema_version,
+          verdict: receipt.verdict,
+          signed: false
+        },
+        null,
+        2
+      ),
+      exitCode: EXIT.OK
+    };
+  }
+  const stdout = [
+    "\u2713 CallLint receipt: valid",
+    `  Receipt ID: ${receipt.receipt_id}`,
+    `  Schema: ${receipt.schema_version}`,
+    `  Verdict: ${receipt.verdict}`,
+    `  Signature: unsigned local receipt`
+  ].join("\n");
+  return { stdout, exitCode: EXIT.OK };
+}
+function verifySignature(receipt, args, deps) {
+  const sig = receipt.signature;
+  const publicKeyUrl = sig.public_key_url || "https://calllint.com/.well-known/receipt-keys.json";
+  const publicKeyFlag = args.flags["public-key"];
+  if (!publicKeyFlag || typeof publicKeyFlag !== "string") {
+    return {
+      stdout: "",
+      stderr: [
+        "Receipt has a signature but no public key was provided.",
+        `  Signature key_id: ${sig.key_id}`,
+        `  Public key URL:   ${publicKeyUrl}`,
+        "",
+        "Verify offline by passing the public key:",
+        "  calllint receipt verify <receipt.json> --public-key <keyfile>"
+      ].join("\n"),
+      exitCode: EXIT.ERROR
+    };
+  }
+  let publicKey;
+  try {
+    const keyJson = JSON.parse(readFileSync8(resolve4(deps.cwd, publicKeyFlag), "utf8"));
+    publicKey = keyJson.public_key;
+    if (typeof publicKey !== "string") {
+      throw new Error("key file has no string 'public_key' field");
+    }
+  } catch (e) {
+    return {
+      stdout: "",
+      stderr: `Could not read public key from ${publicKeyFlag}: ${e instanceof Error ? e.message : String(e)}`,
+      exitCode: EXIT.ERROR
+    };
+  }
+  const cryptoResult = verifyReceipt2(receipt, publicKey);
   if (flagBool(args.flags, "json")) {
     return {
-      stdout: JSON.stringify(result, null, 2),
-      exitCode: result.valid ? EXIT.OK : 1
+      stdout: JSON.stringify(
+        {
+          valid: cryptoResult.valid,
+          receipt_id: receipt.receipt_id,
+          schema_version: receipt.schema_version,
+          verdict: receipt.verdict,
+          signed: true,
+          signature: {
+            valid: cryptoResult.valid,
+            key_id: sig.key_id,
+            algorithm: sig.algorithm,
+            signed_at: sig.signed_at,
+            error: cryptoResult.error
+          }
+        },
+        null,
+        2
+      ),
+      exitCode: cryptoResult.valid ? EXIT.OK : 1
     };
   }
-  if (!result.valid) {
-    const lines = ["CallLint receipt: invalid", ...result.errors.map((e) => `  - ${e}`)];
+  if (!cryptoResult.valid) {
+    const lines = [
+      "\u2717 CallLint receipt: signature INVALID",
+      `  Receipt ID: ${receipt.receipt_id}`,
+      `  Signature key: ${sig.key_id}`,
+      `  Error: ${cryptoResult.error || "signature verification failed"}`
+    ];
     return { stdout: "", stderr: lines.join("\n"), exitCode: 1 };
   }
-  const r = parsed;
-  const signature = r.signature ? "present (shape-only, not cryptographically verified)" : "unsigned local receipt";
   const stdout = [
-    "CallLint receipt: valid",
-    `receipt_id: ${r.receipt_id}`,
-    `schema: ${r.schema_version}`,
-    `verdict: ${r.verdict}`,
-    `signature: ${signature}`
+    "\u2713 CallLint receipt: valid",
+    `  Receipt ID: ${receipt.receipt_id}`,
+    `  Schema: ${receipt.schema_version}`,
+    `  Verdict: ${receipt.verdict}`,
+    `  Signature: valid (key: ${sig.key_id})`,
+    `  Signed at: ${sig.signed_at}`
   ].join("\n");
   return { stdout, exitCode: EXIT.OK };
 }
+function receiptSign(args, deps) {
+  const receiptFile = args.positionals[1];
+  const keyFile = args.flags["key"];
+  const outFile = args.flags["out"] || receiptFile;
+  if (!receiptFile || !keyFile || typeof keyFile !== "string") {
+    return {
+      stdout: "",
+      stderr: [
+        "Usage: calllint receipt sign <receipt.json> --key <keyfile> [--out <output>]",
+        "",
+        "Sign a receipt locally (development/testing only).",
+        "Production signing requires cloud service: calllint scan --sign"
+      ].join("\n"),
+      exitCode: EXIT.USAGE
+    };
+  }
+  let unsignedReceipt;
+  try {
+    unsignedReceipt = JSON.parse(readFileSync8(resolve4(deps.cwd, receiptFile), "utf8"));
+  } catch (e) {
+    return {
+      stdout: "",
+      stderr: `Could not read receipt ${receiptFile}: ${e instanceof Error ? e.message : String(e)}`,
+      exitCode: EXIT.ERROR
+    };
+  }
+  if (unsignedReceipt.signature) {
+    return {
+      stdout: "",
+      stderr: "Receipt already has a signature field. Cannot sign again.",
+      exitCode: EXIT.ERROR
+    };
+  }
+  let keypair;
+  try {
+    const keyJson = JSON.parse(readFileSync8(resolve4(deps.cwd, keyFile), "utf8"));
+    keypair = importKeypair(keyJson);
+  } catch (e) {
+    return {
+      stdout: "",
+      stderr: `Could not read key file ${keyFile}: ${e instanceof Error ? e.message : String(e)}`,
+      exitCode: EXIT.ERROR
+    };
+  }
+  try {
+    const signature = signReceipt(unsignedReceipt, keypair);
+    const signedReceipt = { ...unsignedReceipt, signature };
+    writeFileSync6(resolve4(deps.cwd, outFile), JSON.stringify(signedReceipt, null, 2) + "\n", "utf8");
+    const stdout = [
+      "\u2713 Receipt signed successfully",
+      `  Key ID: ${signature.key_id}`,
+      `  Algorithm: ${signature.algorithm}`,
+      `  Signed at: ${signature.signed_at}`,
+      `  Output: ${outFile}`
+    ].join("\n");
+    return { stdout, exitCode: EXIT.OK };
+  } catch (e) {
+    return {
+      stdout: "",
+      stderr: `Signing failed: ${e instanceof Error ? e.message : String(e)}`,
+      exitCode: EXIT.ERROR
+    };
+  }
+}
+function receiptKeygen(args, deps) {
+  const outFile = args.flags["out"];
+  if (!outFile || typeof outFile !== "string") {
+    return {
+      stdout: "",
+      stderr: [
+        "Usage: calllint receipt keygen --out <file>",
+        "",
+        "Generate a test ed25519 keypair (development/testing only).",
+        "Production keys are managed by cloud service."
+      ].join("\n"),
+      exitCode: EXIT.USAGE
+    };
+  }
+  const keyId = args.flags["key-id"] || "calllint-dev-2026-h2";
+  try {
+    const keypair = generateKeypair(keyId);
+    const exported = exportKeypair(keypair);
+    writeFileSync6(resolve4(deps.cwd, outFile), JSON.stringify(exported, null, 2) + "\n", "utf8");
+    const stdout = [
+      "\u2713 Keypair generated successfully",
+      `  Key ID: ${keyId}`,
+      `  Algorithm: ed25519`,
+      `  Output: ${outFile}`,
+      "",
+      "\u26A0\uFE0F  Development/testing only. Do NOT use for production."
+    ].join("\n");
+    return { stdout, exitCode: EXIT.OK };
+  } catch (e) {
+    return {
+      stdout: "",
+      stderr: `Keygen failed: ${e instanceof Error ? e.message : String(e)}`,
+      exitCode: EXIT.ERROR
+    };
+  }
+}
 
 // src/commands/action.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
 
 // ../../packages/action-analyzer/src/types.ts
@@ -5016,15 +5798,15 @@ Expected: calllint.action.v0`,
       exitCode: verdict === "SAFE" ? 0 : 1
     };
   } catch (error) {
-    const err = error;
+    const err2 = error;
     let stderr = "";
-    if (err.code === "ENOENT") {
+    if (err2.code === "ENOENT") {
       stderr = `Error: File not found: ${actionFile}`;
     } else if (error instanceof SyntaxError) {
       stderr = `Error: Invalid JSON in ${actionFile}
 ${error.message}`;
     } else {
-      stderr = `Error: ${err.message}`;
+      stderr = `Error: ${err2.message}`;
     }
     return {
       stdout: "",
@@ -5092,13 +5874,267 @@ function writeActionReceipt(descriptor, rawContent, actionReport, policy, args,
     args.flags["receipt-out"] ?? "calllint-action-receipt.json"
   );
   try {
-    writeFileSync6(outPath, JSON.stringify(receipt, null, 2) + "\n", "utf8");
+    writeFileSync7(outPath, JSON.stringify(receipt, null, 2) + "\n", "utf8");
   } catch (e) {
     return `Could not write action receipt to ${outPath}: ${e instanceof Error ? e.message : String(e)}`;
   }
   return void 0;
 }
 
+// src/commands/inbox.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+function inboxCommand(args, deps) {
+  const subcommand = args.positionals[0];
+  if (!subcommand || subcommand === "help") {
+    return {
+      stdout: inboxHelp(),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (subcommand === "inspect") {
+    return inboxInspect(args, deps);
+  }
+  return {
+    stdout: "",
+    stderr: `Unknown inbox subcommand: ${subcommand}
+Run \`calllint inbox help\`.`,
+    exitCode: 2
+  };
+}
+function inboxInspect(args, deps) {
+  const eventFile = args.positionals[1];
+  if (!eventFile) {
+    return {
+      stdout: "",
+      stderr: "Error: Missing event file\nUsage: calllint inbox inspect <normalized-event.json>",
+      exitCode: 2
+    };
+  }
+  try {
+    const absolutePath = resolve6(deps.cwd, eventFile);
+    const content = readFileSync10(absolutePath, "utf-8");
+    const event = JSON.parse(content);
+    if (event.schema_version !== "calllint.agent-inbox-event.v0") {
+      return {
+        stdout: "",
+        stderr: `Error: Unsupported schema version: ${event.schema_version}
+Expected: calllint.agent-inbox-event.v0`,
+        exitCode: 2
+      };
+    }
+    if (!event.event_type || !event.timestamp || !event.source || !event.normalized_content) {
+      return {
+        stdout: "",
+        stderr: "Error: Invalid inbox event - missing required fields (event_type, timestamp, source, normalized_content)",
+        exitCode: 2
+      };
+    }
+    const policyPath = args.flags["policy"];
+    const policy = loadPolicyOrDefault(policyPath ? resolve6(deps.cwd, policyPath) : void 0);
+    const actionCandidate = event.action_candidate;
+    let verdict;
+    let findings;
+    let stdout = "";
+    if (!actionCandidate) {
+      verdict = "SAFE";
+      findings = [];
+      if (args.flags["json"]) {
+        const report = {
+          schema_version: "calllint.inbox-report.v0",
+          verdict,
+          findings: [],
+          event: {
+            event_type: event.event_type,
+            provider: event.source.provider,
+            account_id: event.source.account_id,
+            timestamp: event.timestamp
+          },
+          action_candidate: null,
+          scan_timestamp: deps.generatedAt || (/* @__PURE__ */ new Date()).toISOString()
+        };
+        stdout = JSON.stringify(report, null, 2);
+      } else {
+        stdout = `
+\u{1F4EC} Inbox Event: ${event.event_type} (${event.source.provider})
+Verdict: \u2705 SAFE
+Action Candidate: None (informational only)
+`;
+      }
+    } else {
+      if (actionCandidate.schema_version !== "calllint.action.v0") {
+        return {
+          stdout: "",
+          stderr: `Error: Unsupported action_candidate schema: ${actionCandidate.schema_version}
+Expected: calllint.action.v0`,
+          exitCode: 2
+        };
+      }
+      findings = analyzeAction(actionCandidate);
+      verdict = computeActionVerdict2(findings, policy);
+      if (args.flags["json"]) {
+        const report = {
+          schema_version: "calllint.inbox-report.v0",
+          verdict,
+          findings,
+          event: {
+            event_type: event.event_type,
+            provider: event.source.provider,
+            account_id: event.source.account_id,
+            timestamp: event.timestamp
+          },
+          action_candidate: {
+            kind: actionCandidate.kind,
+            schema_version: actionCandidate.schema_version
+          },
+          scan_timestamp: deps.generatedAt || (/* @__PURE__ */ new Date()).toISOString()
+        };
+        stdout = JSON.stringify(report, null, 2);
+      } else {
+        const verdictEmoji = verdict === "SAFE" ? "\u2705" : verdict === "BLOCK" ? "\u26D4" : verdict === "REVIEW" ? "\u26A0\uFE0F" : "\u25C7";
+        stdout = `
+\u{1F4EC} Inbox Event: ${event.event_type} (${event.source.provider})
+\u{1F50D} Action Candidate: ${actionCandidate.kind}
+Verdict: ${verdictEmoji} ${verdict}
+Findings: ${findings.length}
+`;
+        if (findings.length > 0) {
+          stdout += "\n";
+          for (const f of findings) {
+            stdout += `  \u2022 ${f.id}: ${f.impact}
+`;
+          }
+        }
+      }
+    }
+    if (args.flags["receipt"]) {
+      const receiptError = writeInboxReceipt(event, content, verdict, findings, policy, args, deps);
+      if (receiptError) {
+        return { stdout: "", stderr: receiptError, exitCode: 2 };
+      }
+    }
+    return {
+      stdout,
+      stderr: "",
+      exitCode: verdict === "SAFE" ? 0 : 1
+    };
+  } catch (error) {
+    const err2 = error;
+    let stderr = "";
+    if (err2.code === "ENOENT") {
+      stderr = `Error: File not found: ${eventFile}`;
+    } else if (error instanceof SyntaxError) {
+      stderr = `Error: Invalid JSON in ${eventFile}
+${error.message}`;
+    } else {
+      stderr = `Error: ${err2.message}`;
+    }
+    return {
+      stdout: "",
+      stderr,
+      exitCode: 2
+    };
+  }
+}
+function computeActionVerdict2(findings, policy) {
+  if (findings.length === 0) {
+    return "SAFE";
+  }
+  const hasBlocker = findings.some((f) => f.blocker || f.severity === "critical");
+  if (hasBlocker) {
+    return "BLOCK";
+  }
+  const hasHigh = findings.some((f) => f.severity === "high");
+  if (hasHigh) {
+    return "REVIEW";
+  }
+  return "REVIEW";
+}
+function writeInboxReceipt(event, rawContent, verdict, findings, policy, args, deps) {
+  try {
+    const target = event.source.account_id ? `${event.source.provider}.${event.source.account_id}` : event.source.provider;
+    const inboxReport = {
+      schema_version: "calllint.inbox-report.v0",
+      verdict,
+      counts: {
+        SAFE: verdict === "SAFE" ? 1 : 0,
+        REVIEW: verdict === "REVIEW" ? 1 : 0,
+        BLOCK: verdict === "BLOCK" ? 1 : 0,
+        UNKNOWN: verdict === "UNKNOWN" ? 1 : 0
+      },
+      reports: [{ findings }]
+    };
+    const toolVersion = deps.toolVersion || "0.0.0-dev";
+    const receipt = createReceipt(
+      {
+        toolVersion,
+        subject: { type: "action", target },
+        // Use 'action' type (inbox extends action)
+        inputForHash: rawContent,
+        effectivePolicyForHash: policy || { policy: "default" },
+        scanReport: inboxReport,
+        rulesetForHash: { tool: "calllint", version: toolVersion },
+        networkUsed: false
+      },
+      deps.generatedAt || (/* @__PURE__ */ new Date()).toISOString()
+    );
+    const receiptOutPath = args.flags["receipt-out"] || "calllint-inbox-receipt.json";
+    const absoluteReceiptPath = resolve6(deps.cwd, receiptOutPath);
+    writeFileSync8(absoluteReceiptPath, JSON.stringify(receipt, null, 2) + "\n", "utf-8");
+    return null;
+  } catch (error) {
+    const err2 = error;
+    return `Error writing receipt: ${err2.message}`;
+  }
+}
+function inboxHelp() {
+  return `
+calllint inbox \u2014 Inspect normalized agent inbox events
+
+USAGE
+  calllint inbox inspect <normalized-event.json> [options]
+
+DESCRIPTION
+  Read a normalized agent inbox event (calllint.agent-inbox-event.v0),
+  extract the optional action_candidate field, and analyze it using the
+  R4 action analyzer. Returns SAFE/REVIEW/BLOCK/UNKNOWN verdict with
+  evidence-backed findings.
+
+  This command is a composition layer: it does NOT fetch messages, poll
+  providers, or implement OAuth. Caller provides pre-normalized events.
+
+OPTIONS
+  --receipt              Write a receipt (calllint.receipt.v0) with subject.type="inbox"
+  --receipt-out <path>   Receipt output path (default: calllint-receipt.json)
+  --policy <path>        Custom policy file
+  --json                 JSON output
+
+EXIT CODES
+  0  SAFE (no blockers observed)
+  1  REVIEW / BLOCK / UNKNOWN
+  2  Invalid input or schema violation
+
+EXAMPLES
+  # Inspect a normalized Gmail event with action candidate
+  calllint inbox inspect gmail-reply.normalized.json
+
+  # Generate receipt for audit trail
+  calllint inbox inspect resend-invoice.json --receipt
+
+  # JSON output for programmatic use
+  calllint inbox inspect slack-mention.json --json
+
+SEE ALSO
+  docs/AGENT_INBOX_PREFLIGHT.md  \u2014 Usage guide + worked examples
+  docs/AGENT_INBOX_ADAPTER_CONTRACT.md  \u2014 Provider \u2192 normalized transformation
+  packages/fixtures/agent-inbox/  \u2014 6 providers \xD7 2 examples (reference)
+  ADR 0031  \u2014 Agent Inbox Runtime design
+  ADR 0030  \u2014 Agent Inbox Spec (v0.10.0 design)
+  ADR 0029  \u2014 Unified External Action Preflight (R4)
+`;
+}
+
 // src/run.ts
 function run(argv, deps) {
   const args = parseArgs(argv);
@@ -5168,7 +6204,9 @@ function run(argv, deps) {
     case "receipt":
       return receiptCommand(args, { cwd: deps.cwd });
     case "action":
-      return actionCommand(args, { cwd: deps.cwd });
+      return actionCommand(args, { cwd: deps.cwd, toolVersion: deps.toolVersion, generatedAt: deps.generatedAt });
+    case "inbox":
+      return inboxCommand(args, { cwd: deps.cwd, toolVersion: deps.toolVersion, generatedAt: deps.generatedAt });
     case "gen-rule":
       return genRuleCommand(args, { cwd: deps.cwd });
     case "policy":
@@ -5442,13 +6480,13 @@ async function breathe(argv, deps = {}) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname as dirname4, join as join11 } from "node:path";
 function resolveToolVersion() {
   try {
     const pkgPath = join11(dirname4(fileURLToPath(import.meta.url)), "..", "package.json");
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
     return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -5458,7 +6496,7 @@ function resolveToolVersion() {
 // src/index.ts
 function readStdin() {
   try {
-    return readFileSync11(0, "utf8");
+    return readFileSync12(0, "utf8");
   } catch {
     return "";
   }
@@ -5479,8 +6517,8 @@ async function main() {
   let clock;
   try {
     clock = resolveClock(argv, () => /* @__PURE__ */ new Date());
-  } catch (err) {
-    process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+  } catch (err2) {
+    process.stderr.write(`${err2 instanceof Error ? err2.message : String(err2)}
 `);
     process.exitCode = 2;
     return;
@@ -5489,8 +6527,8 @@ async function main() {
   let online;
   try {
     online = await computeOnlineEnrichment(argv, { fetchedAt: generatedAt });
-  } catch (err) {
-    process.stderr.write(`--online failed: ${err instanceof Error ? err.message : String(err)}
+  } catch (err2) {
+    process.stderr.write(`--online failed: ${err2 instanceof Error ? err2.message : String(err2)}
 `);
     process.exitCode = 3;
     return;
@@ -5515,3 +6553,8 @@ async function main() {
   process.exitCode = result.exitCode;
 }
 void main();
+/*! Bundled license information:
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/