altimate-receipts 0.7.0 → 0.8.0

package/dist/chunk-NPYC3NGR.js

@@ -0,0 +1,859 @@
+#!/usr/bin/env node
+import {
+  agentIds,
+  applyDiffScope,
+  buildReceipt,
+  deriveEvidence,
+  deriveFindings,
+  deriveSpans,
+  destructiveOutsideRepo,
+  findingSurface,
+  formatCostAlways,
+  formatTokens,
+  gradeLetter,
+  loadById,
+  narrowEffort,
+  privileged,
+  redact,
+  redactReceipt,
+  renderLedger,
+  windowedEffort
+} from "./chunk-SGVU3CGP.js";
+
+// src/receipt/canonical.ts
+function canonicalize(value) {
+  return serialize(value);
+}
+function serialize(value) {
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(serialize).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+    const body = keys.map((k) => `${JSON.stringify(k)}:${serialize(obj[k])}`).join(",");
+    return `{${body}}`;
+  }
+  return "null";
+}
+
+// src/report/prComment.ts
+import { createHash } from "crypto";
+
+// src/report/checks.ts
+var CHECK_CATALOG = [
+  {
+    key: "destructive",
+    icon: "\u{1F6E1}\uFE0F",
+    label: "destructive ops",
+    prefixes: ["destructive", "file-shrink"]
+  },
+  {
+    key: "git-history",
+    icon: "\u{1F33F}",
+    label: "git-history safety",
+    prefixes: ["force-push", "history-rewrite"]
+  },
+  { key: "secrets", icon: "\u{1F511}", label: "secret leaks", prefixes: ["secret"] },
+  { key: "cicd", icon: "\u2699\uFE0F", label: "CI/CD tampering", prefixes: ["ci-cd-touch"] },
+  { key: "lockfile", icon: "\u{1F4E6}", label: "lockfile integrity", prefixes: ["lockfile-edit"] },
+  {
+    key: "tests",
+    icon: "\u{1F9EA}",
+    label: "test integrity",
+    prefixes: [
+      "fake-green",
+      "test-focus",
+      "test-skipped",
+      "test-trivialised",
+      "grader-edit",
+      "eval-override"
+    ]
+  },
+  {
+    key: "weakening",
+    icon: "\u{1F513}",
+    label: "config/safety weakening",
+    prefixes: ["config-weaken", "hook-bypass", "pipe-sh"]
+  },
+  {
+    key: "blind-edits",
+    icon: "\u{1F441}\uFE0F",
+    label: "blind / unverified edits",
+    prefixes: ["blind-edit", "unverified-change", "edit-reversion"]
+  },
+  { key: "injection", icon: "\u{1F489}", label: "prompt-injection", prefixes: ["prompt-injection"] },
+  { key: "trojan", icon: "\u{1F575}\uFE0F", label: "hidden unicode", prefixes: ["trojan-source"] },
+  {
+    key: "duplication",
+    icon: "\u{1F4CB}",
+    label: "duplicated code",
+    prefixes: ["dup-file", "duplicated-code"]
+  },
+  { key: "swallowed", icon: "\u{1F92B}", label: "swallowed errors", prefixes: ["error-swallowed"] },
+  { key: "stubbed", icon: "\u{1F6A7}", label: "stubbed implementation", prefixes: ["impl-stubbed"] },
+  { key: "malformed", icon: "\u{1F9F1}", label: "malformed artifacts", prefixes: ["malformed-artifact"] },
+  { key: "truncated", icon: "\u2702\uFE0F", label: "truncated turns", prefixes: ["truncated-turn"] },
+  {
+    key: "promises",
+    icon: "\u{1F91D}",
+    label: "unfulfilled claims",
+    prefixes: ["claimed-commit-none", "unfulfilled-promise"]
+  },
+  {
+    key: "tool-calls",
+    icon: "\u{1F9EC}",
+    label: "tool-call integrity",
+    prefixes: ["tool-fabricated", "tool-malformed-args"]
+  }
+];
+function matches(id, check) {
+  return check.prefixes.some((p) => id === p || id.startsWith(`${p}-`));
+}
+function checkForId(id) {
+  return CHECK_CATALOG.find((c) => matches(id, c));
+}
+var SEV_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+function categorize(findings) {
+  const flagged = [];
+  const cleared = [];
+  for (const check of CHECK_CATALOG) {
+    const hits = findings.filter((f) => matches(f.id, check));
+    if (hits.length > 0) {
+      const severity = hits.map((f) => f.severity ?? "high").sort((a, b) => SEV_RANK[a] - SEV_RANK[b])[0];
+      flagged.push({ check, count: hits.length, severity });
+    } else {
+      cleared.push(check);
+    }
+  }
+  return { flagged, cleared, total: CHECK_CATALOG.length };
+}
+
+// src/report/prComment.ts
+var CLASS_ORDER = [
+  "mutating",
+  "vcs-history",
+  "transport",
+  "test",
+  "build",
+  "read-only",
+  "opaque"
+];
+var PR_COMMENT_MARKER = "<!-- verified-by-receipts -->";
+var TRUST_DOC_URL = "https://github.com/AltimateAI/altimate-receipts/blob/main/docs/trust.md";
+var ABOUT_DOC_URL = "https://github.com/AltimateAI/altimate-receipts/blob/main/docs/problems.md";
+var FEEDBACK_ISSUE_BASE = "https://github.com/AltimateAI/altimate-receipts/issues/new";
+var VISIBLE_ROWS = 7;
+function visibleMergeFindings(findings) {
+  return findings.filter(
+    (f) => findingSurface(f.id) === "merge" && f.severity !== "low" && !(f.id.startsWith("destructive-") && destructiveOutsideRepo(f.title))
+  );
+}
+function eventKey(f) {
+  return `${f.title} ${f.filePath ?? ""}`;
+}
+function eventId(f) {
+  const prefix = f.id.replace(/-tool-.*$/, "").replace(/-\d+(-\d+)?$/, "");
+  let h = 2166136261;
+  for (const ch of `${prefix}:${f.filePath ?? f.title}`) {
+    h ^= ch.charCodeAt(0);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function renderPrComment(receipt, opts = {}) {
+  const p = receipt.predicate;
+  const ev = p.evidence;
+  const operatorCount = p.findings.filter((f) => findingSurface(f.id) === "operator").length;
+  const main = visibleMergeFindings(p.findings);
+  const cats = categorize(main);
+  const files = p.scope?.kind === "diff" ? p.scope.files ?? [] : [];
+  const priv = main.filter((f) => privileged(f.id, f.filePath));
+  const rest = main.filter((f) => !privileged(f.id, f.filePath));
+  const cleared = p.prCleared ?? [];
+  const lastPush = p.prHistory?.[p.prHistory.length - 1];
+  const out = [];
+  out.push(PR_COMMENT_MARKER);
+  if (main.length === 0 && cleared.length === 0 && coverageFull(ev, files)) {
+    out.push(masthead(p, ev, files));
+    out.push("");
+    out.push(
+      `receipts \u2014 nothing detected${coverageCell(ev, files) ? ` \xB7 ${coverageCell(ev, files)}` : ""}${ev.diffCostUsd != null ? ` \xB7 \u2248 ${formatCostAlways(ev.diffCostUsd)}` : ""} \xB7 ${testsCell(ev)}`
+    );
+    out.push("");
+    out.push(recordDetails(p, ev, cats, operatorCount, opts, feedbackLine(p.session.agent, main)));
+    out.push(footer());
+    out.push(stateBlock(p, ev, files, main, cleared));
+    return `${out.join("\n")}
+`;
+  }
+  out.push(masthead(p, ev, files));
+  out.push("");
+  const status = [
+    lastPush && p.prHistory && p.prHistory.length > 1 ? `push ${lastPush.push}${lastPush.sha ? ` \xB7 \`${lastPush.sha}\`` : ""} \u2014 +${lastPush.new} new \xB7 ${lastPush.cleared} cleared \xB7 ${lastPush.open} open` : null,
+    coverageCell(ev, files)
+  ].filter(Boolean);
+  if (status.length) {
+    out.push(status.join(" \xB7 "));
+    out.push("");
+  }
+  if (priv.length) {
+    out.push("**Review as access control**");
+    for (const f of priv) {
+      out.push(eventRow(f, true, files, opts.diffLinkBase));
+    }
+    out.push("");
+  }
+  if (rest.length) {
+    out.push("**Sanity-check**");
+    for (const f of rest.slice(0, VISIBLE_ROWS)) {
+      out.push(eventRow(f, false, files, opts.diffLinkBase));
+    }
+    if (rest.length > VISIBLE_ROWS) {
+      out.push(`- _+${rest.length - VISIBLE_ROWS} more in the record below_`);
+    }
+    out.push("");
+  }
+  if (cleared.length) {
+    for (const c of cleared) {
+      const loc = c.filePath ? ` (\`${c.filePath}\`)` : "";
+      out.push(
+        `- ~~${c.title}~~${loc} \xB7 no longer detected${lastPush ? ` push ${lastPush.push}` : ""}`
+      );
+    }
+    out.push("");
+  }
+  const flaggedSet = new Set(
+    main.map((f) => f.filePath ? displayPath(f.filePath, files) : null).filter(Boolean)
+  );
+  if (files.length) {
+    out.push(`Other ${Math.max(0, files.length - flaggedSet.size)} files: nothing detected.`);
+    out.push("");
+  }
+  out.push(`<sub>tests: ${testsCell(ev)}</sub>`);
+  out.push("");
+  out.push(recordDetails(p, ev, cats, operatorCount, opts, feedbackLine(p.session.agent, main)));
+  out.push(footer());
+  out.push(stateBlock(p, ev, files, main, cleared));
+  return `${out.join("\n")}
+`;
+}
+function masthead(p, ev, files) {
+  const parts = [`Agent work record \u2014 ${p.session.agent}`];
+  if (files.length) {
+    parts.push(`${files.length} file${files.length === 1 ? "" : "s"}`);
+  }
+  if (p.prEffort && p.prEffort.sessions > 1) {
+    parts.push(`${p.prEffort.sessions} sessions`);
+    parts.push(`spent \u2248 ${formatCostAlways(p.prEffort.totalUsd)} on this PR`);
+  } else if (ev.diffCostUsd != null) {
+    parts.push(`spent \u2248 ${formatCostAlways(ev.diffCostUsd)} on this PR`);
+  }
+  return `### ${parts.join(" \xB7 ")}`;
+}
+function coverageCell(ev, files) {
+  if (ev.coveredFiles == null || !files.length) {
+    return null;
+  }
+  const gap = files.length - ev.coveredFiles;
+  if (gap > 0) {
+    return `\u26A0 ${gap} changed file${gap === 1 ? "" : "s"} ha${gap === 1 ? "s" : "ve"} no transcript activity (${ev.coveredFiles}/${files.length} covered)`;
+  }
+  return `transcript covers ${ev.coveredFiles}/${files.length} changed files`;
+}
+function coverageFull(ev, files) {
+  return ev.coveredFiles == null || !files.length || ev.coveredFiles >= files.length;
+}
+function displayPath(filePath, scopeFiles) {
+  for (const sf of scopeFiles) {
+    if (filePath === sf || filePath.endsWith(`/${sf}`)) {
+      return sf;
+    }
+  }
+  if (!filePath.startsWith("/") && !filePath.startsWith("~")) {
+    return filePath;
+  }
+  const segs = filePath.split("/").filter(Boolean);
+  return segs.length > 2 ? segs.slice(-2).join("/") : filePath;
+}
+function diffAnchor(base2, path, line) {
+  const h = createHash("sha256").update(path).digest("hex");
+  return `${base2}#diff-${h}${line ? `R${line}` : ""}`;
+}
+function eventRow(f, priv, scopeFiles, linkBase) {
+  const mark = priv ? "\u25B2 " : "";
+  const shown = f.filePath ? displayPath(f.filePath, scopeFiles) : void 0;
+  const chip = shown ? `\`${shown}${f.line ? `:${f.line}` : ""}\`` : "";
+  const file = chip ? `${linkBase && shown ? `[${chip}](${diffAnchor(linkBase, shown, f.line)})` : chip} \u2014 ` : "";
+  const base2 = f.filePath?.split("/").pop();
+  let fact = f.title;
+  if (base2) {
+    fact = fact.replace(new RegExp(`:\\s*\`?${escapeRe(base2)}\`?\\s*$`), "").trim();
+  }
+  const why = f.impactLabel ? ` \xB7 ${f.impactLabel}` : "";
+  const ref = f.evidenceRef ? linkBase && shown ? ` \xB7 [evidence \`${f.evidenceRef}\`](${diffAnchor(linkBase, shown, f.line)})` : ` \xB7 evidence \`${f.evidenceRef}\`` : "";
+  return `- ${mark}${file}**${fact}**${why}${ref}`;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function testsCell(ev) {
+  const tm = ev.testMetrics;
+  if (tm) {
+    const seg = [
+      tm.passed != null ? `${tm.passed} passed` : null,
+      tm.failed ? `**${tm.failed} failed**` : null,
+      tm.skipped ? `${tm.skipped} skipped` : null
+    ].filter(Boolean).join(", ");
+    return `${seg || tm.exitStatus} _(parsed from runner output in transcript)_`;
+  }
+  return ev.testsRan ? "test command observed \u2014 outcome not parsed" : "no test run detected in transcript";
+}
+function recordDetails(p, ev, cats, operatorCount, opts, feedback) {
+  const inner = [];
+  if (p.prHistory?.length) {
+    inner.push("| push | events | change cost |", "| :-- | :-- | :-- |");
+    for (const h of p.prHistory) {
+      const id = h.sha ? ` \xB7 \`${h.sha}\`` : "";
+      const cost = h.costUsd != null ? formatCostAlways(h.costUsd) : "\u2014";
+      inner.push(
+        `| ${h.push}${id}${dateCell(h.endedAt)} | +${h.new} new \xB7 ${h.cleared} cleared \xB7 ${h.open} open | ${cost} |`
+      );
+    }
+    inner.push(
+      "<sub>change cost per row = the attributed cost at that push (cumulative within a session).</sub>",
+      ""
+    );
+  }
+  const files = p.scope?.kind === "diff" ? p.scope.files ?? [] : [];
+  if (files.length) {
+    inner.push(changedFilesBlock(files), "");
+  }
+  const ledger = renderLedger(ev.claims ?? []);
+  if (ledger) {
+    inner.push(ledger, "");
+  }
+  inner.push(
+    `**Checks** _("not detected" means this check found nothing \u2014 not that nothing exists)_`,
+    "",
+    checksTable(cats),
+    ""
+  );
+  const cl = diffCostLine(ev, p.prEffort);
+  if (cl) {
+    inner.push(cl);
+  }
+  inner.push(`<sub>${effortLine(ev, operatorCount)}</sub>`);
+  const signed = opts.signed ? `Signed (Sigstore \u2192 Rekor)${opts.attestationUrl ? ` \xB7 [attestation](${opts.attestationUrl})` : ""} \xB7 ` : "";
+  inner.push(
+    `<sub>${signed}Re-derivable (L1: \`receipts verify <receipt> --transcript <t>\`) \xB7 pull any event's tape: \`npx altimate-receipts log --ref <evidence-id>\` \xB7 deterministic \xB7 0 model calls \xB7 evidence, not judgement \xB7 [trust model](${TRUST_DOC_URL}).</sub>`
+  );
+  const hint = upgradeHint(p.generator?.version, opts.compareVersion);
+  if (hint) {
+    inner.push(hint);
+  }
+  inner.push(feedback);
+  return [
+    "<details><summary>Record \u2014 pushes, files, checks, custody (append-only)</summary>",
+    "",
+    ...inner,
+    "",
+    "</details>"
+  ].join("\n");
+}
+function dateCell(endedAt) {
+  if (!endedAt || !Number.isFinite(endedAt)) {
+    return "";
+  }
+  return ` \xB7 ${new Date(endedAt).toISOString().slice(0, 10)}`;
+}
+function footer() {
+  return `
+<sub>[what is this? \u203A](${ABOUT_DOC_URL}) \u2014 a record of the agent's process, not a code review \xB7 entries are never edited or removed</sub>`;
+}
+function stateBlock(p, ev, files, main, cleared) {
+  const lastPush = p.prHistory?.[p.prHistory.length - 1]?.push ?? 1;
+  const events = [
+    ...main.map((f) => ({
+      file: f.filePath ? displayPath(f.filePath, files) : "",
+      id: eventId({ ...f, filePath: f.filePath ? displayPath(f.filePath, files) : void 0 }),
+      privileged: privileged(f.id, f.filePath),
+      state: "open",
+      type: f.id.replace(/-tool-.*$/, "").replace(/-\d+(-\d+)?$/, "")
+    })),
+    ...cleared.map((c) => ({
+      file: c.filePath ? displayPath(c.filePath, files) : "",
+      id: eventId({
+        id: "cleared",
+        title: c.title,
+        filePath: c.filePath ? displayPath(c.filePath, files) : void 0
+      }),
+      privileged: false,
+      state: "cleared",
+      type: "cleared"
+    }))
+  ];
+  const state = {
+    cost_cents: ev.diffCostUsd != null ? Math.round((p.prEffort?.totalUsd ?? ev.diffCostUsd) * 100) : null,
+    coverage: ev.coveredFiles != null ? { covered: ev.coveredFiles, total: files.length } : null,
+    events,
+    push: lastPush,
+    schema_version: 1
+  };
+  return `<!-- receipts-state v1 ${JSON.stringify(state)} -->`;
+}
+function changedFilesBlock(files) {
+  if (files.length <= 12) {
+    return `**Changed** ${files.map((f) => `\`${f}\``).join(", ")}`;
+  }
+  const byDir = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const top = f.includes("/") ? `${f.split("/")[0]}/` : "(root)";
+    byDir.set(top, (byDir.get(top) ?? 0) + 1);
+  }
+  const dirs = [...byDir.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([d, n]) => `\`${d}\` ${n}`).join(" \xB7 ");
+  const moreDirs = byDir.size > 8 ? ` \xB7 _+${byDir.size - 8} more dirs_` : "";
+  const sample = files.slice(0, 60).map((f) => `\`${f}\``).join(", ");
+  const moreFiles = files.length > 60 ? ` _\u2026+${files.length - 60} more (full set in the receipt JSON)_` : "";
+  return [
+    `**Changed ${files.length} files** by area: ${dirs}${moreDirs}`,
+    "",
+    "<details><summary>file list</summary>",
+    "",
+    `${sample}${moreFiles}`,
+    "",
+    "</details>"
+  ].join("\n");
+}
+function parseSemver(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(String(v ?? "").trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+function semverLt(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return false;
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] < pb[i];
+  return false;
+}
+function upgradeHint(receiptVer, compareVer) {
+  if (!compareVer || !semverLt(receiptVer, compareVer)) return null;
+  return `<sub>Receipt generated by \`receipts@${receiptVer}\` \xB7 this check runs \`@${compareVer}\` \u2014 \`npm i -g altimate-receipts@latest\` (or \`npx altimate-receipts@latest\`) for the newer checks.</sub>`;
+}
+function feedbackLine(agent, flagged) {
+  const findingLines = flagged.length ? flagged.slice(0, 8).map((f) => `- ${f.title} (\`${f.id}\`)`) : ["- (nothing was flagged \u2014 describe what you expected)"];
+  const body = [
+    "**Repo / PR:** __PR_URL__",
+    `**Agent:** ${agent}`,
+    "",
+    "**Flagged event(s) being disputed:**",
+    ...findingLines,
+    "",
+    "**Why this is a false positive / noise:**",
+    "_(your notes \u2014 what should it have done instead?)_"
+  ].join("\n");
+  const title = flagged.length ? `False positive: ${flagged[0].title}` : "Receipts feedback";
+  const qs = `labels=${encodeURIComponent("false-positive,dogfooding")}&title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`;
+  const url = `${FEEDBACK_ISSUE_BASE}?${qs}`;
+  return `<sub>Wrong or noisy event? [Report it \u2014 prefilled \u203A](${url}) \xB7 or react \u{1F44D}/\u{1F44E} on this comment. It tunes the checks.</sub>`;
+}
+function checksTable(cats) {
+  const sev = new Map(cats.flagged.map((fl) => [fl.check.key, fl]));
+  const rows = [...cats.flagged.map((fl) => fl.check), ...cats.cleared].map((c) => {
+    const fl = sev.get(c.key);
+    const result = fl ? `${fl.count} detected` : "not detected";
+    return `| ${c.label} | ${result} |`;
+  });
+  rows.sort((a, b) => (a.includes("not detected") ? 1 : 0) - (b.includes("not detected") ? 1 : 0));
+  return ["| check | reading |", "| :-- | :-- |", ...rows].join("\n");
+}
+function diffCostLine(ev, pr) {
+  if (ev.diffCostUsd == null) return null;
+  const turns = ev.diffTurns ?? 0;
+  const t = `${turns} turn${turns === 1 ? "" : "s"}`;
+  const push = `\u2248 ${formatCostAlways(ev.diffCostUsd)} \xB7 ${formatTokens(ev.diffTokens ?? 0)} tokens \xB7 ${t}`;
+  if (pr && pr.sessions > 1) {
+    return `**Cost** \u2248 ${formatCostAlways(pr.totalUsd)} _(this PR, ${pr.sessions} sessions)_ \xB7 this push ${push} _(upper bound; the turns that edited these files)_`;
+  }
+  return `**Cost** ${push} _(this change \u2014 upper bound; the turns that edited these files)_`;
+}
+function effortLine(ev, operatorCount) {
+  const cbc = ev.commandsByClass;
+  const brk = cbc ? ` _(${CLASS_ORDER.filter((c) => cbc[c]).map((c) => `${cbc[c]} ${c}`).join(", ")})_` : "";
+  const op = operatorCount > 0 ? ` \xB7 ${operatorCount} efficiency/behaviour finding${operatorCount === 1 ? "" : "s"}` : "";
+  return `Session totals (may span other work): ${ev.edits} edits \xB7 ${ev.commands} commands${brk} \xB7 ${formatCostAlways(ev.costUsd)} \xB7 ${formatTokens(ev.tokens.total)} tokens${op}.`;
+}
+
+// src/share/clipboard.ts
+import { spawnSync } from "child_process";
+function candidates() {
+  if (process.platform === "darwin") {
+    return [{ cmd: "pbcopy", args: [] }];
+  }
+  if (process.platform === "win32") {
+    return [{ cmd: "clip", args: [] }];
+  }
+  return [
+    { cmd: "wl-copy", args: [] },
+    { cmd: "xclip", args: ["-selection", "clipboard"] },
+    { cmd: "xsel", args: ["--clipboard", "--input"] }
+  ];
+}
+function copyToClipboard(text) {
+  for (const { cmd, args } of candidates()) {
+    try {
+      const res = spawnSync(cmd, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+      if (!res.error && res.status === 0) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+
+// src/share/markdown.ts
+var ICON = {
+  critical: "\u26D4",
+  high: "\u26A0\uFE0F",
+  medium: "\u{1F50D}",
+  low: "\xB7"
+};
+var base = (p) => p.split("/").pop() ?? p;
+function renderShareMarkdown(args) {
+  const { summary, session, derived, findings } = args;
+  const { main, minor } = findings;
+  const g = gradeLetter(main);
+  const ev = deriveEvidence(session, derived);
+  const counts = ["critical", "high", "medium"].map((s) => {
+    const n = main.filter((f) => f.severity === s).length;
+    return n ? `${n} ${s}` : null;
+  }).filter(Boolean).join(" \xB7 ") || "no findings";
+  const title = redact(summary.title || "untitled session");
+  const out = [];
+  out.push(`## \u{1F9FE} Receipt \u2014 ${title}  \xB7  Grade ${g}`);
+  out.push("");
+  out.push(
+    `**${main.length ? `${main.length} EVENT${main.length === 1 ? "" : "S"} ON RECORD` : "NOTHING DETECTED"}**  \xB7  ${counts}  \xB7  _${summary.source}_`
+  );
+  out.push("");
+  if (main.length) {
+    out.push("### Findings");
+    const order = { critical: 0, high: 1, medium: 2, low: 3 };
+    const sorted = [...main].sort(
+      (a, b) => order[a.severity] - order[b.severity] || b.score - a.score
+    );
+    for (const f of sorted.slice(0, 12)) {
+      const tag = f.impactLabel ? ` \u2014 ${redact(f.impactLabel)}` : "";
+      const loc = f.filePath ? ` (\`${redact(base(f.filePath))}\`)` : "";
+      out.push(`- ${ICON[f.severity]} **${redact(f.title)}**${tag}${loc}`);
+    }
+    if (minor.length) {
+      out.push(`- _+${minor.length} minor (collapsed)_`);
+    }
+    out.push("");
+  }
+  out.push("### Evidence");
+  out.push(
+    `${ev.filesChanged} files \xB7 ${ev.edits} edits \xB7 ${ev.commands} commands \xB7 ${ev.testsRan ? "tests ran \u2713" : "no test run detected"} \xB7 ${ev.destructiveOps} destructive ops`
+  );
+  out.push("");
+  out.push("_Verified by Receipts \xB7 deterministic \xB7 0 model calls \xB7 evidence, not judgement_");
+  return `${out.join("\n")}
+`;
+}
+
+// src/sign/envelope.ts
+var DSSE_PAYLOAD_TYPE = "application/vnd.in-toto+json";
+function pae(payloadType, payload) {
+  const typeBytes = Buffer.from(payloadType, "utf8");
+  const bodyBytes = Buffer.from(payload, "utf8");
+  const header = `DSSEv1 ${typeBytes.length} ${payloadType} ${bodyBytes.length} `;
+  return Buffer.concat([Buffer.from(header, "utf8"), bodyBytes]);
+}
+function toDsseEnvelope(receipt) {
+  const canonical = canonicalize(receipt);
+  return {
+    payloadType: DSSE_PAYLOAD_TYPE,
+    payload: Buffer.from(canonical, "utf8").toString("base64"),
+    signatures: []
+  };
+}
+function envelopePae(env) {
+  const raw = Buffer.from(env.payload, "base64").toString("utf8");
+  return pae(env.payloadType, raw);
+}
+
+// src/trace/commitMatch.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/trace/gitCommand.ts
+var WRAPPERS = /* @__PURE__ */ new Set(["command", "exec", "nohup", "time", "env"]);
+var GIT_VALUE_FLAGS = /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "--exec-path"]);
+function gitInvocations(command) {
+  const blanked = command.replace(/\\["']/g, "  ").replace(/'[^']*'/g, " ").replace(/"[^"]*"/g, " ");
+  const out = [];
+  for (const simple of blanked.split(/(?:&&|\|\||[;|\n])/)) {
+    const tokens = simple.trim().split(/\s+/).filter(Boolean);
+    let i = 0;
+    while (i < tokens.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i]) || WRAPPERS.has(tokens[i]))) {
+      i++;
+    }
+    if (tokens[i] !== "git") {
+      continue;
+    }
+    i++;
+    while (i < tokens.length && tokens[i].startsWith("-")) {
+      const flag = tokens[i];
+      i++;
+      if (GIT_VALUE_FLAGS.has(flag)) {
+        i++;
+      }
+    }
+    const sub = tokens[i];
+    if (sub) {
+      out.push({ sub, rest: tokens.slice(i + 1) });
+    }
+  }
+  return out;
+}
+
+// src/trace/commitMatch.ts
+var SHA_CAP = 200;
+function branchShas(base2, cwd) {
+  if (!base2) {
+    return [];
+  }
+  const r = spawnSync2("git", ["log", `--max-count=${SHA_CAP}`, "--format=%H", `${base2}..HEAD`], {
+    encoding: "utf8",
+    cwd
+  });
+  if (r.status !== 0) {
+    return [];
+  }
+  return r.stdout.split("\n").filter((s) => /^[0-9a-f]{40}$/.test(s));
+}
+var HEX_RUN = /\b[0-9a-f]{7,40}\b/g;
+function commandOf(input) {
+  if (typeof input === "string") {
+    const t = input.trim();
+    if (t.startsWith("{")) {
+      try {
+        return commandOf(JSON.parse(t));
+      } catch {
+        return input;
+      }
+    }
+    return input;
+  }
+  if (input && typeof input === "object") {
+    const o = input;
+    for (const key of ["command", "cmd"]) {
+      const v = o[key];
+      if (typeof v === "string") {
+        return v;
+      }
+      if (Array.isArray(v)) {
+        return v.filter((t) => typeof t === "string").join(" ");
+      }
+    }
+  }
+  return "";
+}
+function isGitWrite(command) {
+  return gitInvocations(command).some((g) => g.sub === "commit" || g.sub === "push");
+}
+function authoredBranch(spans, shas) {
+  if (shas.length === 0) {
+    return false;
+  }
+  for (const s of spans) {
+    if (s.kind !== "tool" || typeof s.output !== "string") {
+      continue;
+    }
+    if (!isGitWrite(commandOf(s.input))) {
+      continue;
+    }
+    for (const token of s.output.match(HEX_RUN) ?? []) {
+      if (shas.some((full) => full.startsWith(token))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function shaWindow(spans, shas) {
+  if (shas.length === 0) {
+    return null;
+  }
+  let firstOwn = -1;
+  let lastOwn = -1;
+  let lastForeignBeforeOwn = -1;
+  spans.forEach((s, i) => {
+    if (s.kind !== "tool" || typeof s.output !== "string") {
+      return;
+    }
+    if (!isGitWrite(commandOf(s.input))) {
+      return;
+    }
+    const tokens = s.output.match(HEX_RUN) ?? [];
+    if (tokens.length === 0) {
+      return;
+    }
+    const own = tokens.some((t) => shas.some((full) => full.startsWith(t)));
+    if (own) {
+      if (firstOwn === -1) {
+        firstOwn = i;
+      }
+      lastOwn = i;
+    } else if (firstOwn === -1) {
+      lastForeignBeforeOwn = i;
+    }
+  });
+  if (lastOwn === -1) {
+    return null;
+  }
+  return { start: lastForeignBeforeOwn + 1, end: lastOwn };
+}
+
+// src/trace/slice.ts
+function branchesIn(session) {
+  const seen = [];
+  for (const m of session.messages) {
+    if (m.gitBranch && !seen.includes(m.gitBranch)) {
+      seen.push(m.gitBranch);
+    }
+  }
+  return seen;
+}
+function effectiveBranches(messages) {
+  const firstTagged = messages.find((m) => m.gitBranch)?.gitBranch;
+  let current = firstTagged;
+  return messages.map((m) => {
+    if (m.gitBranch) {
+      current = m.gitBranch;
+    }
+    return current;
+  });
+}
+function sliceByBranch(session, branch) {
+  if (!branchesIn(session).includes(branch)) {
+    return null;
+  }
+  const eff = effectiveBranches(session.messages);
+  const messages = session.messages.filter((_, i) => eff[i] === branch);
+  if (messages.length === 0) {
+    return null;
+  }
+  const timestamps = messages.map((m) => m.timestamp).filter((t) => typeof t === "number");
+  const startedAt = timestamps.length ? Math.min(...timestamps) : session.startedAt;
+  const endedAt = timestamps.length ? Math.max(...timestamps) : session.endedAt;
+  return {
+    ...session,
+    id: `${session.id}#${branch}`,
+    gitBranch: branch,
+    startedAt,
+    endedAt,
+    messages,
+    // Scope the subject digest to this branch's slice (reproducible by re-slicing).
+    digestSource: JSON.stringify({ id: session.id, branch, messages })
+  };
+}
+
+// src/sign/rederive.ts
+function sourceFromReceipt(receipt) {
+  const prefix = receipt.subject?.[0]?.name?.split("/")[0];
+  return agentIds().find((id) => id === prefix);
+}
+async function rederiveFromTranscript(path, opts = {}) {
+  const loaded = await loadById(opts.source ?? "claude-code", path);
+  if (!loaded) {
+    return null;
+  }
+  const scope = opts.scope;
+  const branch = scope?.kind === "branch" ? scope.branch : opts.branch;
+  const session = branch ? sliceByBranch(loaded, branch) ?? loaded : loaded;
+  let derived = deriveSpans(session);
+  let findings = deriveFindings(derived);
+  if (scope?.kind === "diff" && scope.files) {
+    const scoped = applyDiffScope(derived, findings, scope.files, session.projectPath);
+    derived = scoped.derived;
+    findings = scoped.findings;
+    if (scope.branch) {
+      const slice = sliceByBranch(loaded, scope.branch);
+      let eff = narrowEffort(slice ? deriveSpans(slice) : null, scope.files);
+      if (!eff && scope.shas?.length) {
+        const win = shaWindow(derived.spans, scope.shas);
+        if (win) {
+          eff = windowedEffort(derived, scope.files, win);
+        }
+      }
+      if (eff) {
+        derived = {
+          ...derived,
+          diffCostUsd: eff.cost,
+          diffTokens: eff.tokens,
+          diffTurns: eff.turns
+        };
+      }
+    }
+  }
+  const receipt = await buildReceipt(session, derived, findings, { scope });
+  return opts.redact ? redactReceipt(receipt) : receipt;
+}
+async function compareToTranscript(committed, transcriptPath, opts = {}) {
+  const fresh = await rederiveFromTranscript(transcriptPath, {
+    redact: true,
+    ...opts,
+    // Re-derive through the adapter the receipt names (its subject prefix), so a
+    // codex/cursor receipt isn't re-run through the Claude adapter. An explicit
+    // opts.source still wins.
+    source: opts.source ?? sourceFromReceipt(committed),
+    scope: committed.predicate.scope
+  });
+  if (!fresh) {
+    return { rederived: false, matches: false };
+  }
+  const strip = (r) => {
+    if (!r.predicate.prEffort && !r.predicate.prHistory && !r.predicate.prCleared) {
+      return r;
+    }
+    const { prEffort: _x, prHistory: _y, prCleared: _z, ...rest } = r.predicate;
+    return { ...r, predicate: rest };
+  };
+  return {
+    rederived: true,
+    matches: canonicalize(strip(committed)) === canonicalize(strip(fresh))
+  };
+}
+
+export {
+  gitInvocations,
+  canonicalize,
+  CHECK_CATALOG,
+  checkForId,
+  PR_COMMENT_MARKER,
+  visibleMergeFindings,
+  eventKey,
+  renderPrComment,
+  copyToClipboard,
+  renderShareMarkdown,
+  DSSE_PAYLOAD_TYPE,
+  pae,
+  toDsseEnvelope,
+  envelopePae,
+  branchShas,
+  authoredBranch,
+  shaWindow,
+  branchesIn,
+  sliceByBranch,
+  rederiveFromTranscript,
+  compareToTranscript
+};
+//# sourceMappingURL=chunk-NPYC3NGR.js.map