madeby 0.1.0

package/dist/madeby.mjs

@@ -0,0 +1,2095 @@
+#!/usr/bin/env node
+
+// ../analyzer/src/git.ts
+import { execFileSync } from "node:child_process";
+var FIELD = "";
+var RECORD = "";
+function readGitLog(repoPath, limit, range) {
+  try {
+    const args = [
+      "-C",
+      repoPath,
+      "log",
+      "--no-merges",
+      // merge commits aren't authored content — exclude them from attribution
+      ...limit ? ["-n", String(limit)] : [],
+      // %G? is a signature-PRESENCE probe for the Disclosure Score: 'N' = unsigned; any other code
+      // (G/U/E/…) = a signature is present (E = present but unverifiable here — no keyring). We only
+      // read presence, never validity (that's the verified tier). If gpg is absent git returns 'N',
+      // which under-counts disclosure — the fail-safe direction (never a false "disclosed").
+      `--format=%H${FIELD}%an${FIELD}%ae${FIELD}%G?${FIELD}%B${RECORD}`,
+      // optional revision range, e.g. "origin/main..HEAD" — the PR's own commits for the gate
+      ...range ? [range] : []
+    ];
+    const out = execFileSync("git", args, { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+    return out.split(RECORD).map((r) => r.replace(/^\s+/, "")).filter((r) => r.length > 0).map((rec) => {
+      const parts = rec.split(FIELD);
+      const sha = parts[0] ?? "";
+      const authorName = parts[1] ?? "";
+      const authorEmail = parts[2] ?? "";
+      const sig = parts[3] ?? "N";
+      const message = parts.slice(4).join(FIELD).trimEnd();
+      return { sha, authorName, authorEmail, signed: sig !== "N" && sig !== "", message };
+    });
+  } catch {
+    return [];
+  }
+}
+
+// ../classify/src/classify.ts
+var KNOWN_BOTS = /\b(?:dependabot|renovate(?:-bot)?|greenkeeper|snyk-bot|github-actions|semantic-release-bot|stainless-app|allcontributors|mergify|codecov-commenter|pre-commit-ci|imgbot|whitesource-bot|copybara)\b/i;
+function isBotIdentity(name, email) {
+  const n = (name ?? "").trim();
+  const e = (email ?? "").trim();
+  if (/\[bot\]$/i.test(n) || /\[bot\]@/i.test(e)) return true;
+  if (e === "actions@github.com") return true;
+  return KNOWN_BOTS.test(n) || KNOWN_BOTS.test(e);
+}
+
+// ../classify/src/benchmark/benchmark-v0.json
+var benchmark_v0_default = {
+  version: "0",
+  cases: [
+    { message: "Fix off-by-one in pagination", authorName: "Mac", authorEmail: "mac@ex.com", expected: "human" },
+    { message: "Bump dependency versions", authorName: "Sam", authorEmail: "sam@ex.com", expected: "human" },
+    { message: "Update README with setup steps", authorName: "Lee", authorEmail: "lee@ex.com", expected: "human" },
+    { message: "Add unit tests for the parser", authorName: "Jo", authorEmail: "jo@ex.com", expected: "human" },
+    { message: "Refactor config loader for clarity", authorName: "Mac", authorEmail: "mac@ex.com", expected: "human" },
+    { message: "Add AI-provider enum to the schema", authorName: "Mac", authorEmail: "mac@ex.com", expected: "human", note: "prose mentions 'AI' but no co-author \u2014 must NOT false-positive" },
+    { message: "Document how Claude Code integrates", authorName: "Lee", authorEmail: "lee@ex.com", expected: "human", note: "prose mentions 'Claude' in the subject, not a trailer \u2014 must NOT false-positive" },
+    { message: "Implement billing webhook\n\nCo-authored-by: Sam Dev <sam@ex.com>", authorName: "Mac", authorEmail: "mac@ex.com", expected: "human", note: "human co-author, not AI" },
+    { message: "Refactor registration form\n\nCo-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>", authorName: "Mac", authorEmail: "mac@ex.com", expected: "with_ai" },
+    { message: "Add tests\n\nCo-authored-by: GitHub Copilot <copilot@github.com>", authorName: "Dev", authorEmail: "dev@ex.com", expected: "with_ai" },
+    { message: "Generate boilerplate\n\nCo-authored-by: Cursor <cursor@cursor.com>", authorName: "Mac", authorEmail: "mac@ex.com", expected: "with_ai" },
+    { message: "Draft API docs\n\nCo-authored-by: Gemini <gemini@google.com>", authorName: "Lee", authorEmail: "lee@ex.com", expected: "with_ai" },
+    { message: "Implement the parser\n\nCo-authored-by: ChatGPT <assistant@openai.com>", authorName: "Jo", authorEmail: "jo@ex.com", expected: "with_ai" },
+    { message: "Scaffold the module\n\nCo-Authored-By: Claude <noreply@anthropic.com>", authorName: "Mac", authorEmail: "mac@ex.com", expected: "with_ai" },
+    { message: "Add export endpoint\n\nGenerated-by: aider", authorName: "Sam", authorEmail: "sam@ex.com", expected: "with_ai", note: "#78: Generated-by trailer + named AI tool \u2014 a miss before evidence-grade signals" },
+    { message: "Refine the dashboard\n\nAssisted-by: Codeium", authorName: "Lee", authorEmail: "lee@ex.com", expected: "with_ai", note: "#78: Assisted-by trailer + Codeium" },
+    { message: "Automated dependency bump", authorName: "Claude", authorEmail: "noreply@anthropic.com", expected: "ai" },
+    { message: "Auto-generated migration", authorName: "Copilot", authorEmail: "copilot@github.com", expected: "ai" },
+    { message: "Regenerate types", authorName: "Cursor Agent", authorEmail: "agent@cursor.com", expected: "ai" },
+    { message: "Automated changelog", authorName: "Claude", authorEmail: "noreply@anthropic.com", expected: "ai" },
+    { message: "Implement caching layer", authorName: "Mac", authorEmail: "mac@ex.com", expected: "with_ai", note: "AI-assisted in reality, trailer omitted \u2192 EXPECTED MISS (untrailered AI; addressed by span-level evidence #2/#10)" },
+    { message: "Rewrite the serializer", authorName: "Mac", authorEmail: "mac@ex.com", expected: "with_ai", note: "untrailered AI assist \u2192 EXPECTED MISS" },
+    { message: "Add retry logic to the client", authorName: "Lee", authorEmail: "lee@ex.com", expected: "with_ai", note: "untrailered AI assist \u2192 EXPECTED MISS" }
+  ]
+};
+
+// ../classify/src/eval.ts
+var BENCHMARK_VERSION = benchmark_v0_default.version;
+var CASES = benchmark_v0_default.cases;
+
+// ../classify/src/benchmark/ground-truth-v0.json
+var ground_truth_v0_default = {
+  version: "0",
+  note: "INDEPENDENT ground truth (TESTING.md \xA76, review 2026-06-29; corpus grown 2026-08-13 with REAL cited public commits). Unlike the synthetic benchmark and the dogfood canary, each label here is established by provenance OTHER than the AI trailer the classifier reads: the commit's ERA (predates LLM coding assistants), an autonomous-agent ACCOUNT, or a build the developer PUBLICLY documented as AI-generated. `untrailered: true` marks the real-world blind spot \u2014 AI the classifier fails to flag as AI-involved despite no trailer. This is now purely the no-signal class: inline autocomplete / stripped trailers / AI committed under a human's name \u2014 irrecoverable without session-log evidence (#68). (A second sub-cause once lived here \u2014 an AI-agent identity DISCARDED because its GitHub noreply email embeds '[bot]', so bot-precedence beat the AI-identity match, e.g. real Devin commits \u2014 but that was RECOVERED on 2026-08-13 by a classify.ts precedence refinement, so those cases are now `ai`/detected, not blind.) Real cited cases (repo@sha) are preferred over representative stand-ins and are replacing them over time; the label basis (never the trailer) is documented per case. The corpus grows via captured corrections (#69) and real labeled repos.",
+  cases: [
+    {
+      message: 'Initial revision of "git", the information manager from hell',
+      authorName: "Linus Torvalds",
+      authorEmail: "torvalds@ppc970.osdl.org",
+      expected: "human",
+      provenanceBasis: "the 2005 initial commit of git \u2014 predates LLM coding assistants by ~15 years"
+    },
+    {
+      message: "Fix memory leak in request handler",
+      authorName: "Jane Cooper",
+      authorEmail: "jane@example.org",
+      expected: "human",
+      provenanceBasis: "representative pre-2021 OSS commit; predates mainstream AI coding tools"
+    },
+    {
+      message: "Bump version to 2.4.1 and update changelog",
+      authorName: "Marco Rossi",
+      authorEmail: "marco@example.com",
+      expected: "human",
+      provenanceBasis: "representative pre-2021 release commit; no AI tooling existed"
+    },
+    {
+      message: "Refactor auth middleware for clarity",
+      authorName: "Priya Nair",
+      authorEmail: "priya@example.net",
+      expected: "human",
+      provenanceBasis: "representative human OSS contribution, hand-written (no AI assistance)"
+    },
+    {
+      message: "Add integration tests for the payments flow",
+      authorName: "Tom Becker",
+      authorEmail: "tom@example.com",
+      expected: "human",
+      provenanceBasis: "representative human-authored commit, no AI tooling"
+    },
+    {
+      message: "Correct typo in README installation steps",
+      authorName: "Aiko Tanaka",
+      authorEmail: "aiko@example.jp",
+      expected: "human",
+      provenanceBasis: "representative human-authored docs fix"
+    },
+    {
+      message: "Add an AI-provider field to the schema",
+      authorName: "Sam Reed",
+      authorEmail: "sam@example.com",
+      expected: "human",
+      provenanceBasis: "human-authored; message MENTIONS 'AI' but there is no AI co-author \u2014 must not false-positive"
+    },
+    {
+      message: "Document how Claude Code integrates with our CI",
+      authorName: "Dana Liu",
+      authorEmail: "dana@example.com",
+      expected: "human",
+      provenanceBasis: "human-authored docs; 'Claude' appears in prose only \u2014 must not false-positive"
+    },
+    {
+      message: "Implement webhook retries\n\nCo-authored-by: Pat Singh <pat@example.com>",
+      authorName: "Sam Reed",
+      authorEmail: "sam@example.com",
+      expected: "human",
+      provenanceBasis: "human co-author (not an AI) \u2014 must not false-positive"
+    },
+    {
+      message: "Refactor login form\n\nCo-Authored-By: Claude <noreply@anthropic.com>",
+      authorName: "Mac",
+      authorEmail: "mac@example.com",
+      expected: "with_ai",
+      provenanceBasis: "carries an explicit AI co-author trailer \u2014 the trailered case the classifier should catch",
+      untrailered: false
+    },
+    {
+      message: "Generate API client\n\nCo-authored-by: GitHub Copilot <copilot@github.com>",
+      authorName: "Dev",
+      authorEmail: "dev@example.com",
+      expected: "with_ai",
+      provenanceBasis: "explicit Copilot trailer \u2014 trailered case",
+      untrailered: false
+    },
+    {
+      message: "Automated dependency upgrade",
+      authorName: "Devin",
+      authorEmail: "devin@cognition.ai",
+      expected: "ai",
+      provenanceBasis: "authored by the Devin autonomous-agent account (no human co-author) \u2014 agent-authored",
+      untrailered: false
+    },
+    {
+      message: "Regenerate API client and types",
+      authorName: "Cursor Agent",
+      authorEmail: "agent@cursor.com",
+      expected: "ai",
+      provenanceBasis: "authored by the Cursor agent account \u2014 agent-authored (evidence-grade identity, #78)",
+      untrailered: false
+    },
+    {
+      message: "Add pagination to the list endpoint\n\nGenerated-by: aider",
+      authorName: "Devon Park",
+      authorEmail: "devon@example.com",
+      expected: "with_ai",
+      provenanceBasis: "explicit Generated-by trailer naming the aider AI tool (#78) \u2014 identifiable, not untrailered",
+      untrailered: false
+    },
+    {
+      message: "Add dark mode toggle to settings",
+      authorName: "Alex Kim",
+      authorEmail: "alex@example.com",
+      expected: "with_ai",
+      provenanceBasis: "developer publicly documented this feature as generated by an AI assistant; commit carries NO trailer (the real-world blind spot)",
+      untrailered: true
+    },
+    {
+      message: "Implement CSV export endpoint",
+      authorName: "Jordan Vega",
+      authorEmail: "jordan@example.com",
+      expected: "with_ai",
+      provenanceBasis: "AI-generated via inline autocomplete (accepted + committed under the human's name); no trailer emitted",
+      untrailered: true
+    },
+    {
+      message: "Add rate limiting to the public API",
+      authorName: "Chris Obi",
+      authorEmail: "chris@example.com",
+      expected: "with_ai",
+      provenanceBasis: "built with an AI coding agent the developer credited in a blog post; commit has no trailer",
+      untrailered: true
+    },
+    {
+      message: "Wire up Stripe checkout",
+      authorName: "Lena Vogt",
+      authorEmail: "lena@example.de",
+      expected: "with_ai",
+      provenanceBasis: "vibe-coded with an AI IDE assistant; trailer stripped on squash-merge",
+      untrailered: true
+    },
+    {
+      message: "Scaffold the admin dashboard",
+      authorName: "Omar Haddad",
+      authorEmail: "omar@example.com",
+      expected: "with_ai",
+      provenanceBasis: "scaffold generated by an AI tool, documented in the PR description; no co-author trailer",
+      untrailered: true
+    },
+    {
+      message: "Add unit tests for the parser",
+      authorName: "Sofia Marin",
+      authorEmail: "sofia@example.com",
+      expected: "with_ai",
+      provenanceBasis: "tests generated by an AI assistant (tab-completion); committed under the human's name, no trailer",
+      untrailered: true
+    },
+    {
+      message: "zmalloc fix, return NULL or real malloc failure",
+      authorName: "antirez",
+      authorEmail: "antirez@gmail.com",
+      expected: "human",
+      provenanceBasis: "REAL cited commit: redis@8d196ebac255 (2009-04-30, Salvatore Sanfilippo) \u2014 predates LLM coding assistants; verifiable public history"
+    },
+    {
+      message: "fix scaffolding template paths (Pathname does weird things)",
+      authorName: "Leon Breedt",
+      authorEmail: "bitserf@gmail.com",
+      expected: "human",
+      provenanceBasis: "REAL cited commit: rails/rails@46e68538c08d (2005-05-31) \u2014 pre-LLM era; verifiable public history"
+    },
+    {
+      message: "Fixed #6820: flush no longer fails under PostgreSQL 8.3",
+      authorName: "Jacob Kaplan-Moss",
+      authorEmail: "jacob@jacobian.org",
+      expected: "human",
+      provenanceBasis: "REAL cited commit: django/django@3de70a10c066 (2008-05-31) \u2014 pre-LLM era; verifiable public history"
+    },
+    {
+      message: "not needed",
+      authorName: "Blake Mizerany",
+      authorEmail: "blakemizerany@blake-mizeranys-computer.local",
+      expected: "human",
+      provenanceBasis: "REAL cited commit: sinatra/sinatra@95287a1b5514 (2007-12-03) \u2014 pre-LLM era; verifiable public history"
+    },
+    {
+      message: "Fix magic-link sign-in: token_hash verify and confirm step\n\nCo-authored-by: ksg-spidy <ksg-spidy@users.noreply.github.com>",
+      authorName: "Cursor Agent",
+      authorEmail: "cursoragent@cursor.com",
+      expected: "with_ai",
+      provenanceBasis: "REAL cited commit: ksg-spidy/Bookmyslot@7a140859 \u2014 authored by the Cursor agent account with a human co-author trailer; agent-authored (identity is evidence-grade, #78). DETECTED via author identity.",
+      untrailered: false
+    },
+    {
+      message: "Add live DSC/HD95 metrics panel for full-3d-mask guidance",
+      authorName: "Copilot",
+      authorEmail: "198982749+Copilot@users.noreply.github.com",
+      expected: "ai",
+      provenanceBasis: "REAL cited commit: LMUK-RADONC-PHYS-RES/beacon@492668ba \u2014 authored by GitHub's Copilot coding agent, NO trailer of any kind. DETECTED anyway because the agent is the git AUTHOR (its identity is the signal) \u2014 proof that untrailered AI is not always invisible when the agent authors directly.",
+      untrailered: false
+    },
+    {
+      message: "feat(phase0): scaffold backend, dashboard, nginx, docker compose",
+      authorName: "Devin AI",
+      authorEmail: "158243242+devin-ai-integration[bot]@users.noreply.github.com",
+      expected: "ai",
+      provenanceBasis: "REAL cited commit: Moksha89/trade@627b2b5d \u2014 authored by the Devin autonomous-agent account, NO trailer; the GitHub noreply email embeds '[bot]'. DETECTED via the disclosed agent identity ('devin' is a known AI pattern): a [bot] identity that is itself a named AI agent classifies 'ai', not generic 'bot'. Previously lost to bot-precedence \u2014 recovered by the classify.ts precedence refinement (2026-08-13). The old representative Devin case (devin@cognition.ai) never exercised the [bot]-email path this real commit does.",
+      untrailered: false
+    }
+  ]
+};
+
+// ../classify/src/ground-truth.ts
+var GROUND_TRUTH_VERSION = ground_truth_v0_default.version;
+var CASES2 = ground_truth_v0_default.cases;
+
+// ../core/src/canonicalize.ts
+function compact(obj) {
+  const out = {};
+  for (const [k, val] of Object.entries(obj)) {
+    if (val !== void 0) out[k] = val;
+  }
+  return out;
+}
+function claimPayload(claim) {
+  return compact({
+    subject: {
+      algorithm: claim.subject.algorithm,
+      target: claim.subject.target,
+      value: claim.subject.value
+    },
+    attribution: compact({
+      identityId: claim.attribution.identityId,
+      role: claim.attribution.role,
+      aiProvider: claim.attribution.aiProvider,
+      aiModel: claim.attribution.aiModel,
+      operatorId: claim.attribution.operatorId
+    }),
+    assertedTier: claim.assertedTier,
+    sworn: claim.sworn ? {
+      representationCode: claim.sworn.representationCode,
+      signatureName: claim.sworn.signatureName,
+      signedAt: claim.sworn.signedAt
+    } : void 0,
+    createdAt: claim.createdAt
+  });
+}
+
+// ../core/src/carriers.ts
+function sigToJson(sig) {
+  return sig ? { signerKeyId: sig.signerKeyId, value: sig.value, carrierId: sig.carrierId, signedAt: sig.signedAt } : void 0;
+}
+function sigFromJson(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
+  const s = v;
+  return { signerKeyId: s.signerKeyId, value: s.value, carrierId: s.carrierId, signedAt: s.signedAt };
+}
+var PREDICATE_TYPE = "https://madeby.fyi/attestation/v0";
+var inToto = {
+  id: "in-toto",
+  verificationCapable: true,
+  serialize(claim, signature) {
+    const payload = claimPayload(claim);
+    return {
+      carrier: "in-toto",
+      _type: "https://in-toto.io/Statement/v1",
+      predicateType: PREDICATE_TYPE,
+      subject: [{ digest: { [claim.subject.algorithm]: claim.subject.value } }],
+      predicate: payload,
+      ...sigToJson(signature) ? { signatures: [sigToJson(signature)] } : {}
+    };
+  },
+  parse(env) {
+    const sigs = env.signatures;
+    return { payload: env.predicate, signature: sigFromJson(sigs?.[0]) };
+  }
+};
+var gitNotes = {
+  id: "git-notes",
+  verificationCapable: true,
+  serialize(claim, signature) {
+    return {
+      carrier: "git-notes",
+      madeby: "v0",
+      claim: claimPayload(claim),
+      ...sigToJson(signature) ? { sig: sigToJson(signature) } : {}
+    };
+  },
+  parse(env) {
+    return { payload: env.claim, signature: sigFromJson(env.sig) };
+  }
+};
+var spdx = {
+  id: "spdx",
+  verificationCapable: true,
+  serialize(claim, signature) {
+    return {
+      carrier: "spdx",
+      spdxVersion: "SPDX-3.0",
+      profile: "ai",
+      madebyPayload: claimPayload(claim),
+      ...sigToJson(signature) ? { madebySignature: sigToJson(signature) } : {}
+    };
+  },
+  parse(env) {
+    return { payload: env.madebyPayload, signature: sigFromJson(env.madebySignature) };
+  }
+};
+var CARRIER_REGISTRY = /* @__PURE__ */ new Map([
+  [inToto.id, inToto],
+  [gitNotes.id, gitNotes],
+  [spdx.id, spdx]
+]);
+
+// ../core/src/edges.ts
+var EDGE_TYPES = new Map(
+  [
+    { id: "PART_OF", category: "composition", description: "A is contained in B (span\u2282file\u2282commit\u2282release); attribution rolls up." },
+    { id: "DERIVED_FROM", category: "derivation", description: "A is derived from B (fork/refactor/snippet/AI-generated-by-model)." },
+    { id: "DISPUTES", category: "contradiction", description: "A contests B's claim (\xA711) \u2014 a counter-claim, ranked like any claim." },
+    { id: "IMPLEMENTS", category: "relation", description: "Code A implements artifact B (ticket/spec)." },
+    { id: "MOTIVATED_BY", category: "relation", description: "A exists because of artifact B (the why)." },
+    { id: "DECIDED_BY", category: "relation", description: "A is governed by decision record B (ADR/RFC)." },
+    { id: "DISCUSSED_IN", category: "relation", description: "A was discussed in B (issue/thread)." }
+  ].map((d) => [d.id, d])
+);
+
+// ../core/src/manifest.ts
+var SPAN_MANIFEST_VERSION = "0";
+var MADEBY_SPANS_TAG = `spans/${SPAN_MANIFEST_VERSION}`;
+var fingerprintToString = (fp) => `${fp.algorithm}:${fp.target}:${fp.value}`;
+function fingerprintFromString(s) {
+  const i1 = s.indexOf(":");
+  const i2 = s.indexOf(":", i1 + 1);
+  if (i1 < 1 || i2 <= i1) return null;
+  const value = s.slice(i2 + 1);
+  if (!value) return null;
+  return { algorithm: s.slice(0, i1), target: s.slice(i1 + 1, i2), value };
+}
+function linesToString(hint) {
+  if (!hint || hint.startLine === void 0) return void 0;
+  return hint.endLine !== void 0 && hint.endLine !== hint.startLine ? `${hint.startLine}-${hint.endLine}` : `${hint.startLine}`;
+}
+function linesFromString(v) {
+  if (typeof v !== "string") return {};
+  const m = /^(\d+)(?:-(\d+))?$/.exec(v);
+  if (!m) return {};
+  const startLine = Number(m[1]);
+  return m[2] ? { startLine, endLine: Number(m[2]) } : { startLine };
+}
+function spanToFlat(a) {
+  const o = {};
+  if (a.anchor.hint?.path) o.file = a.anchor.hint.path;
+  const lines = linesToString(a.anchor.hint);
+  if (lines) o.lines = lines;
+  o.model = a.attribution.model;
+  o.provider = a.attribution.provider;
+  if (a.attribution.modelVersion !== void 0) o.modelVersion = a.attribution.modelVersion;
+  o.source = a.attribution.source;
+  o.operator = a.attribution.operatorId;
+  o.fingerprint = fingerprintToString(a.anchor.fingerprint);
+  return o;
+}
+function serializeSpanManifest(m) {
+  const flat = {
+    madeby: MADEBY_SPANS_TAG,
+    commit: m.commit,
+    recorded: m.generatedAt,
+    spans: m.attestations.map(spanToFlat)
+  };
+  if (m.signature) flat.signature = m.signature;
+  return JSON.stringify(flat, null, 2) + "\n";
+}
+function parseSpanManifest(text) {
+  const raw = JSON.parse(text);
+  if (typeof raw.madeby !== "string" || !raw.madeby.startsWith("spans/")) {
+    throw new Error("span manifest: not a madeby spans file (expected 'madeby': 'spans/N')");
+  }
+  const version = raw.madeby.slice("spans/".length);
+  if (typeof raw.commit !== "string" || raw.commit.length === 0) throw new Error("span manifest: missing commit");
+  if (typeof raw.recorded !== "string") throw new Error("span manifest: missing recorded");
+  if (!Array.isArray(raw.spans)) throw new Error("span manifest: spans must be an array");
+  const attestations = raw.spans.map((s, i) => {
+    const o = s;
+    const fp = typeof o.fingerprint === "string" ? fingerprintFromString(o.fingerprint) : null;
+    if (!fp) throw new Error(`span manifest: span ${i} has a malformed fingerprint`);
+    if (typeof o.model !== "string" || typeof o.provider !== "string" || typeof o.operator !== "string" || typeof o.source !== "string") {
+      throw new Error(`span manifest: span ${i} has a malformed attribution`);
+    }
+    const anchor = {
+      fingerprint: fp,
+      ...typeof o.file === "string" ? { hint: { path: o.file, ...linesFromString(o.lines) } } : {}
+    };
+    const attribution = {
+      provider: o.provider,
+      model: o.model,
+      operatorId: o.operator,
+      source: o.source,
+      ...typeof o.modelVersion === "string" ? { modelVersion: o.modelVersion } : {}
+    };
+    return { anchor, attribution };
+  });
+  return {
+    version,
+    commit: raw.commit,
+    generatedAt: raw.recorded,
+    attestations,
+    ...raw.signature ? { signature: raw.signature } : {}
+  };
+}
+
+// ../core/src/fingerprint.ts
+var enc = new TextEncoder();
+
+// ../core/src/private-fingerprint.ts
+var enc2 = new TextEncoder();
+
+// ../core/src/structural.ts
+var DIM = 256;
+var K = 5;
+var WINDOW = 4;
+function normalizeSource(src) {
+  return src.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ").replace(/#[^\n]*/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize(s) {
+  return s.match(/[A-Za-z_]\w*|\d+|[^\sA-Za-z0-9_]/g) ?? [];
+}
+function canonicalizeTokens(tokens) {
+  return tokens.map((t) => /^[A-Za-z_]\w*$/.test(t) ? "ID" : /^\d+$/.test(t) ? "NUM" : t);
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function kgramHashes(tokens) {
+  if (tokens.length < K) return tokens.length ? [fnv1a(tokens.join("\0"))] : [];
+  const out = [];
+  for (let i = 0; i + K <= tokens.length; i++) out.push(fnv1a(tokens.slice(i, i + K).join("\0")));
+  return out;
+}
+function winnow(hashes, w = WINDOW) {
+  if (hashes.length <= w) return [...new Set(hashes)];
+  const selected = /* @__PURE__ */ new Set();
+  for (let i = 0; i + w <= hashes.length; i++) {
+    let min = hashes[i];
+    let idx = i;
+    for (let j = i; j < i + w; j++) {
+      if (hashes[j] <= min) {
+        min = hashes[j];
+        idx = j;
+      }
+    }
+    selected.add(hashes[idx]);
+  }
+  return [...selected];
+}
+function structuralFingerprint(source, target = "FILE") {
+  const tokens = canonicalizeTokens(tokenize(normalizeSource(source)));
+  const fps = winnow(kgramHashes(tokens));
+  const embedding = new Array(DIM).fill(0);
+  for (const fp of fps) embedding[fp % DIM] += 1;
+  const norm = Math.sqrt(embedding.reduce((s, x) => s + x * x, 0)) || 1;
+  for (let i = 0; i < DIM; i++) embedding[i] = embedding[i] / norm;
+  const value = fnv1a([...fps].sort((a, b) => a - b).join(",")).toString(16).padStart(8, "0");
+  return { fingerprint: { algorithm: "structural-v1", target, value }, embedding };
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) dot += a[i] * b[i];
+  return dot;
+}
+
+// ../core/src/vectors/conformance-v0.json
+var conformance_v0_default = {
+  version: "0",
+  jcs: [
+    { name: "sorts object keys", input: { b: 1, a: 2 }, expected: '{"a":2,"b":1}' },
+    {
+      name: "nested objects + arrays, order-independent",
+      input: { a: [1, true, null], b: { d: 4, c: 3 } },
+      expected: '{"a":[1,true,null],"b":{"c":3,"d":4}}'
+    },
+    { name: "ADVERSARIAL: non-integer number must error", input: 1.5, expectError: true }
+  ],
+  canonicalize: [
+    {
+      name: "claim payload excludes id and signature",
+      claim: {
+        id: "ignored",
+        subject: { algorithm: "sha256", target: "FILE", value: "abc" },
+        attribution: { identityId: "alice", role: "creator" },
+        assertedTier: "asserted",
+        signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" },
+        createdAt: "2026-01-01T00:00:00Z"
+      },
+      expected: '{"assertedTier":"asserted","attribution":{"identityId":"alice","role":"creator"},"createdAt":"2026-01-01T00:00:00Z","subject":{"algorithm":"sha256","target":"FILE","value":"abc"}}'
+    }
+  ],
+  fingerprint: [
+    {
+      name: "git-blob-sha1 of 'hello\\n' (== git hash-object)",
+      algorithm: "git-blob-sha1",
+      content: "hello\n",
+      expected: "ce013625030ba8dba906f756967f9e9ca394464a"
+    },
+    {
+      name: "sha256 of 'abc'",
+      algorithm: "sha256",
+      content: "abc",
+      expected: "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+    }
+  ],
+  tierResolution: [
+    {
+      name: "asserted is the floor",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "asserted", createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "verified: valid sig in known carrier + verified signer",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "verified"
+    },
+    {
+      name: "bound: verified + exact fingerprint",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "bound", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "bound"
+    },
+    {
+      name: "ADVERSARIAL: unknown carrier caps at asserted (even for bound)",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "bound", signature: { signerKeyId: "k", value: "v", carrierId: "mystery", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: forged/invalid signature caps at asserted",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "bound", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: false, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: anonymous (unverified) signer caps at asserted",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: false },
+      expected: "asserted"
+    },
+    {
+      name: "bound over a fuzzy fingerprint degrades to verified",
+      claim: { id: "c", subject: { algorithm: "structural-v1", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "bound", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "verified"
+    },
+    {
+      name: "sworn without an overlay degrades to asserted",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "sworn", createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: verified/bound with no signature caps at asserted",
+      claim: { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "bound", createdAt: "2026-01-01T00:00:00Z" },
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    }
+  ],
+  edgeTierResolution: [
+    {
+      name: "declared + valid sig + verified signer + known type \u2192 verified (the cap)",
+      edge: { type: "DERIVED_FROM", fromClaimId: "a", toClaimId: "b", method: "declared", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" } },
+      env: { knownEdgeTypes: ["PART_OF", "DERIVED_FROM", "DISPUTES", "IMPLEMENTS", "MOTIVATED_BY", "DECIDED_BY", "DISCUSSED_IN"], verifySignature: true, signerVerified: true },
+      expected: "verified"
+    },
+    {
+      name: "inferred edge caps at asserted (even signed + known)",
+      edge: { type: "IMPLEMENTS", fromClaimId: "a", toClaimId: "b", method: "inferred", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" } },
+      env: { knownEdgeTypes: ["IMPLEMENTS"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: unrecognized edge type caps at asserted",
+      edge: { type: "TOTALLY_MADE_UP", fromClaimId: "a", toClaimId: "b", method: "declared", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" } },
+      env: { knownEdgeTypes: ["PART_OF", "DERIVED_FROM"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: declared but unsigned edge caps at asserted",
+      edge: { type: "PART_OF", fromClaimId: "a", toClaimId: "b", method: "declared" },
+      env: { knownEdgeTypes: ["PART_OF"], verifySignature: true, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: declared + forged signature caps at asserted",
+      edge: { type: "PART_OF", fromClaimId: "a", toClaimId: "b", method: "declared", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" } },
+      env: { knownEdgeTypes: ["PART_OF"], verifySignature: false, signerVerified: true },
+      expected: "asserted"
+    },
+    {
+      name: "ADVERSARIAL: declared + anonymous signer caps at asserted",
+      edge: { type: "PART_OF", fromClaimId: "a", toClaimId: "b", method: "declared", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" } },
+      env: { knownEdgeTypes: ["PART_OF"], verifySignature: true, signerVerified: false },
+      expected: "asserted"
+    }
+  ],
+  contention: [
+    {
+      name: "single claim is the uncontested origin",
+      claims: [
+        { id: "c", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "asserted", createdAt: "2026-01-01T00:00:00Z" }
+      ],
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: { open: false, originIndex: 0, divergence: false }
+    },
+    {
+      name: "verified owner outranks an asserted squatter (index 1 wins)",
+      claims: [
+        { id: "sq", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "sq", role: "creator" }, assertedTier: "asserted", createdAt: "2026-01-01T00:00:00Z" },
+        { id: "own", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "own", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-02-01T00:00:00Z" }
+      ],
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: { open: false, originIndex: 1, divergence: false }
+    },
+    {
+      name: "ADVERSARIAL: earlier squatter does NOT override a later verified owner (priority \u2260 proof)",
+      claims: [
+        { id: "sq", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "sq", role: "creator" }, assertedTier: "asserted", createdAt: "2020-01-01T00:00:00Z" },
+        { id: "own", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "own", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" }
+      ],
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: { open: false, originIndex: 1, divergence: false }
+    },
+    {
+      name: "ADVERSARIAL: signed copied bytes do not establish origin \u2192 open + divergence (invariant #10)",
+      claims: [
+        { id: "imp", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "imp", role: "creator" }, assertedTier: "bound", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" },
+        { id: "org", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "org", role: "creator" }, assertedTier: "asserted", createdAt: "2026-01-01T00:00:00Z" }
+      ],
+      inputs: [{ isDerivative: true }, { isDerivative: false }],
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: { open: true, originIndex: null, divergence: true }
+    },
+    {
+      name: "ADVERSARIAL: priority alone never crowns \u2014 equal evidence, different timestamps stays open",
+      claims: [
+        { id: "a", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "a", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2024-01-01T00:00:00Z" }, createdAt: "2024-01-01T00:00:00Z" },
+        { id: "b", subject: { algorithm: "sha256", target: "FILE", value: "x" }, attribution: { identityId: "b", role: "creator" }, assertedTier: "verified", signature: { signerKeyId: "k", value: "v", carrierId: "in-toto", signedAt: "2026-01-01T00:00:00Z" }, createdAt: "2026-01-01T00:00:00Z" }
+      ],
+      env: { knownCarriers: ["in-toto"], verifySignature: true, signerVerified: true },
+      expected: { open: true, originIndex: null, divergence: false }
+    }
+  ]
+};
+
+// ../core/src/conformance.ts
+var CONFORMANCE_VERSION = conformance_v0_default.version;
+
+// ../core/src/disclosure.ts
+var AI_TRAILER_RE = /^[ \t]*(?:Co-authored-by|Generated-by|Assisted-by)[ \t]*:[ \t]*(.+?)[ \t]*$/gim;
+var AI_MARKER_RE = /\b(?:claude|copilot|cursor(?:agent)?|devin|gemini|chatgpt|openai|codex|gpt-|codeium|windsurf|aider|codewhisperer|tabnine)\b/i;
+function hasAiTrailer(message) {
+  AI_TRAILER_RE.lastIndex = 0;
+  for (const m of message.matchAll(AI_TRAILER_RE)) if (AI_MARKER_RE.test(m[1])) return true;
+  return false;
+}
+var DCO_RE = /^[ \t]*Signed-off-by[ \t]*:[ \t]*(.+?)[ \t]*$/gim;
+function hasDcoSignoff(message) {
+  DCO_RE.lastIndex = 0;
+  return DCO_RE.test(message);
+}
+var HUMAN_ATTEST_RE = /^[ \t]*(?:Authored-by-human|Human-authored(?:-by)?)[ \t]*:[ \t]*(.+?)[ \t]*$/gim;
+function hasHumanAttestation(message) {
+  HUMAN_ATTEST_RE.lastIndex = 0;
+  return HUMAN_ATTEST_RE.test(message);
+}
+function commitDisclosureKinds(commit) {
+  const kinds = [];
+  if (hasAiTrailer(commit.message)) kinds.push("ai-trailer");
+  if (hasHumanAttestation(commit.message)) kinds.push("human-attestation");
+  if (hasDcoSignoff(commit.message)) kinds.push("dco-signoff");
+  if (commit.signed === true) kinds.push("commit-signature");
+  return kinds;
+}
+
+// ../core/src/policy.ts
+var DEFAULT_POLICY = { version: 0, mode: "advisory" };
+var MODES = ["required", "advisory"];
+function parseDisclosurePolicy(input) {
+  if (!input || typeof input !== "object") return DEFAULT_POLICY;
+  const o = input;
+  const mode = MODES.includes(o.mode) ? o.mode : "advisory";
+  const version = typeof o.version === "number" ? o.version : 0;
+  const accept = Array.isArray(o.accept) ? o.accept.filter((k) => typeof k === "string") : void 0;
+  return accept && accept.length > 0 ? { version, mode, accept } : { version, mode };
+}
+function evaluateDisclosurePolicy(policy, commits) {
+  const accept = policy.accept;
+  const isAccepted = (k) => !accept || accept.includes(k);
+  const verdicts = commits.map((c) => {
+    const satisfiedBy = c.kinds.filter(isAccepted);
+    return { ref: c.ref, compliant: satisfiedBy.length > 0, satisfiedBy };
+  });
+  const nonCompliant = verdicts.filter((v) => !v.compliant);
+  const compliant = verdicts.length - nonCompliant.length;
+  const pass = policy.mode !== "required" || nonCompliant.length === 0;
+  const wanted = accept ? accept.join(", ") : "any recognized disclosure";
+  const summary = `${compliant}/${verdicts.length} commits disclose origin (${policy.mode}; accepts: ${wanted}).` + (nonCompliant.length ? ` ${nonCompliant.length} undisclosed.` : "");
+  return { mode: policy.mode, pass, total: verdicts.length, compliant, nonCompliant, summary };
+}
+
+// ../analyzer/src/host/github.ts
+import { readFileSync } from "node:fs";
+
+// ../analyzer/src/host/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerHostAdapter(adapter) {
+  registry.set(adapter.id, adapter);
+}
+function detectCiRange(env = process.env) {
+  for (const adapter of registry.values()) {
+    const range = adapter.ciRange?.(env);
+    if (range) return { range, host: adapter.id };
+  }
+  return null;
+}
+
+// ../analyzer/src/host/github.ts
+var NOREPLY = /^(?:(\d+)\+)?([A-Za-z0-9](?:[A-Za-z0-9-]{0,38}))@users\.noreply\.github\.com$/i;
+var githubAdapter = {
+  id: "github",
+  name: "GitHub",
+  handleFromEmail(email) {
+    const m = (email ?? "").trim().match(NOREPLY);
+    return m ? m[2].toLowerCase() : null;
+  },
+  handleKey(handle2) {
+    return `gh:${handle2.toLowerCase()}`;
+  },
+  profileUrl(handle2) {
+    return `https://github.com/${handle2}`;
+  },
+  // On a `pull_request` event GitHub sets GITHUB_EVENT_NAME + GITHUB_EVENT_PATH (a JSON payload with
+  // the PR's base/head SHAs). Reading base..head here replaces the bash range computation the Action
+  // used to carry — the range logic now lives once, in the adapter. Needs the PR history present
+  // (the quickstart's `fetch-depth: 0`). Any absence/parse failure → null (fall back to recent
+  // history); never throws.
+  ciRange(env) {
+    const event = env.GITHUB_EVENT_NAME;
+    if (event !== "pull_request" && event !== "pull_request_target") return null;
+    const path = env.GITHUB_EVENT_PATH;
+    if (!path) return null;
+    try {
+      const payload = JSON.parse(readFileSync(path, "utf8"));
+      const base = payload.pull_request?.base?.sha;
+      const head = payload.pull_request?.head?.sha;
+      if (base && head) return `${base}..${head}`;
+    } catch {
+    }
+    return null;
+  }
+};
+registerHostAdapter(githubAdapter);
+
+// ../analyzer/src/read-disclosures.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+function readDisclosures(root, opts = {}) {
+  const commits = readGitLog(root, opts.range ? void 0 : opts.limit ?? 200, opts.range);
+  return commits.map((c) => ({
+    sha: c.sha ?? "",
+    subject: c.message.split("\n")[0] ?? "",
+    disclosures: commitDisclosureKinds({ message: c.message, signed: c.signed })
+  }));
+}
+function evaluateRepoDisclosure(root, opts = {}) {
+  let policy = DEFAULT_POLICY;
+  let warning;
+  const policyPath = join(root, ".madeby", "policy.json");
+  if (existsSync(policyPath)) {
+    try {
+      policy = parseDisclosurePolicy(JSON.parse(readFileSync2(policyPath, "utf8")));
+    } catch {
+      warning = ".madeby/policy.json is not valid JSON \u2014 degrading to advisory (report-only, never blocks).";
+    }
+  }
+  const commits = readDisclosures(root, opts);
+  const disclosures = commits.map((c) => ({ ref: (c.sha || "").slice(0, 8) || "(unknown)", kinds: c.disclosures }));
+  const result = evaluateDisclosurePolicy(policy, disclosures);
+  const subjectFor = (ref) => commits.find((c) => (c.sha || "").startsWith(ref))?.subject ?? "";
+  return {
+    mode: policy.mode,
+    pass: result.pass,
+    summary: result.summary,
+    total: disclosures.length,
+    undisclosed: result.nonCompliant.map((v) => ({ ref: v.ref, subject: subjectFor(v.ref) })),
+    ...warning ? { warning } : {}
+  };
+}
+
+// ../analyzer/src/path-provenance.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+
+// ../analyzer/src/provenance.ts
+import { readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+function parseAll(texts) {
+  const out = [];
+  for (const t of texts) {
+    try {
+      out.push(parseSpanManifest(t));
+    } catch {
+    }
+  }
+  return out;
+}
+function readSpanManifestsFromDir(repoDir) {
+  let files;
+  try {
+    files = readdirSync(join2(repoDir, ".madeby", "spans")).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return parseAll(
+    files.map((f) => {
+      try {
+        return readFileSync3(join2(repoDir, ".madeby", "spans", f), "utf8");
+      } catch {
+        return "";
+      }
+    }).filter(Boolean)
+  );
+}
+
+// ../analyzer/src/path-provenance.ts
+var overlaps = (aS, aE, bS, bE) => bS === void 0 || bE === void 0 || aS <= bE && aE >= bS;
+function git(root, args) {
+  return execFileSync2("git", ["-C", root, "-c", "core.quotePath=false", ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+}
+var US = "";
+function commitMeta(root, sha) {
+  try {
+    const out = git(root, ["show", "-s", `--format=%G?${US}%an${US}%ae${US}%B`, sha]);
+    const parts = out.split(US);
+    const sig = parts[0] ?? "N";
+    return { signed: sig !== "N" && sig !== "", name: parts[1] ?? "", email: parts[2] ?? "", message: (parts.slice(3).join(US) ?? "").trim() };
+  } catch {
+    return null;
+  }
+}
+function blameGroups(porcelain) {
+  const header = /^([0-9a-f]{40}) \d+ (\d+)(?: \d+)?$/;
+  const perLine = [];
+  for (const ln of porcelain.split("\n")) {
+    const m = header.exec(ln);
+    if (m) perLine.push({ line: Number(m[2]), sha: m[1] });
+  }
+  perLine.sort((a, b) => a.line - b.line);
+  const groups = [];
+  for (const { line, sha } of perLine) {
+    const last = groups[groups.length - 1];
+    if (last && last.sha === sha && line === last.end + 1) last.end = line;
+    else groups.push({ start: line, end: line, sha });
+  }
+  return groups;
+}
+function provenanceOf(root, path, opts = {}) {
+  const records = [];
+  for (const manifest of readSpanManifestsFromDir(root)) {
+    for (const a of manifest.attestations) {
+      const hint = a.anchor.hint;
+      if (!hint || hint.path !== path) continue;
+      const s = hint.startLine ?? 1;
+      const e = hint.endLine ?? s;
+      if (!overlaps(s, e, opts.startLine, opts.endLine)) continue;
+      records.push({
+        source: "span",
+        granularity: "region",
+        startLine: hint.startLine,
+        endLine: hint.endLine,
+        ai: true,
+        bot: false,
+        provider: a.attribution.provider,
+        model: a.attribution.model,
+        confidence: "witnessed",
+        evidence: `witnessed AI span \u2014 ${a.attribution.model} (${a.attribution.source})`
+      });
+    }
+  }
+  if (opts.useBlame !== false) {
+    try {
+      const range = opts.startLine !== void 0 ? [`-L`, `${opts.startLine},${opts.endLine ?? opts.startLine}`] : [];
+      const porcelain = git(root, ["blame", "--porcelain", ...range, "--", path]);
+      const metaCache = /* @__PURE__ */ new Map();
+      for (const g of blameGroups(porcelain)) {
+        let meta = metaCache.get(g.sha);
+        if (meta === void 0) {
+          meta = commitMeta(root, g.sha);
+          metaCache.set(g.sha, meta);
+        }
+        if (!meta) continue;
+        const kinds = commitDisclosureKinds({ message: meta.message, signed: meta.signed });
+        const bot = isBotIdentity(meta.name, meta.email);
+        const ai = kinds.includes("ai-trailer");
+        const disclosed = kinds.length > 0 || bot;
+        const short = g.sha.slice(0, 8);
+        records.push({
+          source: "blame",
+          granularity: "commit",
+          startLine: g.start,
+          endLine: g.end,
+          ai,
+          bot,
+          commit: short,
+          disclosures: kinds,
+          confidence: disclosed ? "disclosed" : "none",
+          evidence: disclosed ? `last-touch: ${short} disclosed via ${bot ? "bot" : kinds.join(", ")}` : `last-touch: ${short} \u2014 undisclosed (origin unknown)`
+        });
+      }
+    } catch {
+    }
+  }
+  records.sort((a, b) => (a.startLine ?? 0) - (b.startLine ?? 0) || (a.source === "span" ? -1 : 1));
+  return {
+    path,
+    resolution: "default: witnessed spans (region) + git-blame last-touch (commit); unknown otherwise. Granularity is a configurable convention \u2014 query a line range from your own resolver (ARCH \xA712).",
+    records
+  };
+}
+function provenanceMap(root, opts = {}) {
+  const prefix = opts.prefix;
+  const byPath = /* @__PURE__ */ new Map();
+  for (const m of readSpanManifestsFromDir(root)) {
+    for (const a of m.attestations) {
+      const p = a.anchor.hint?.path;
+      if (!p || prefix && !p.startsWith(prefix)) continue;
+      let wf = byPath.get(p);
+      if (!wf) {
+        wf = { path: p, models: [], regions: [] };
+        byPath.set(p, wf);
+      }
+      wf.regions.push({ startLine: a.anchor.hint?.startLine, endLine: a.anchor.hint?.endLine, model: a.attribution.model });
+      if (!wf.models.includes(a.attribution.model)) wf.models.push(a.attribution.model);
+    }
+  }
+  const witnessed = [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+  let trackedFiles = 0;
+  try {
+    trackedFiles = git(root, ["ls-files", ...prefix ? ["--", prefix] : []]).split("\n").filter(Boolean).length;
+  } catch {
+  }
+  const commits = readDisclosures(root, { limit: opts.commitLimit ?? 500 });
+  const disclosed = commits.filter((c) => c.disclosures.length > 0).length;
+  const pct = commits.length ? Math.round(disclosed / commits.length * 100) : 0;
+  const scope = prefix ?? "repo";
+  const allModels = [...new Set(witnessed.flatMap((w) => w.models))];
+  return {
+    scope,
+    trackedFiles,
+    witnessedFiles: witnessed.length,
+    witnessed,
+    commitCoverage: { disclosed, total: commits.length },
+    summary: `${scope}: ${trackedFiles} tracked file${trackedFiles === 1 ? "" : "s"}; ${witnessed.length} with witnessed AI provenance${allModels.length ? ` (${allModels.join(", ")})` : ""}; ${pct}% of the last ${commits.length} commits disclose origin.`,
+    note: "Witnessed spans are precise (region-level, model-named); commit coverage is commit-level, not per-file authorship. Files without a witnessed span have unknown origin \u2014 disclosure, not detection: we report what's disclosed and never infer origin we can't see. Resolution is a configurable convention (ARCH \xA712)."
+  };
+}
+
+// ../analyzer/src/record-spans.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join as join3 } from "node:path";
+
+// ../analyzer/src/capture-local.ts
+var MATCH_THRESHOLD = 0.52;
+function repoRelative(recorded, repoRoot2) {
+  const p = recorded.replace(/\\/g, "/");
+  const root = repoRoot2.replace(/\\/g, "/");
+  if (p.startsWith(root + "/")) return p.slice(root.length + 1);
+  if (p.startsWith("/")) return null;
+  if (p === ".." || p.startsWith("../")) return null;
+  return p.replace(/^\.\//, "");
+}
+function groupEdits(edits, repoRoot2) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of edits) {
+    const rel = repoRelative(e.path, repoRoot2);
+    if (rel === null) continue;
+    if (rel.startsWith(".madeby/") || rel.includes("node_modules/")) continue;
+    if (!e.content) continue;
+    const cur = out.get(rel) ?? { content: [], models: /* @__PURE__ */ new Set() };
+    cur.content.push(e.content);
+    cur.models.add(e.model);
+    out.set(rel, cur);
+  }
+  return out;
+}
+function captureLocalSpans(input) {
+  const threshold = input.threshold ?? MATCH_THRESHOLD;
+  const parser = input.parser;
+  const empty = {
+    manifest: { version: "0", commit: input.commit, generatedAt: input.now, attestations: [] },
+    tool: null,
+    matched: [],
+    discarded: []
+  };
+  if (!parser) return empty;
+  const byFile = groupEdits(parser.parse(input.transcript), input.repoRoot);
+  const attestations = [];
+  const matched = [];
+  const discarded = [];
+  for (const [rel, ai] of byFile) {
+    const current = input.readFile(rel);
+    if (current === null) {
+      discarded.push(rel);
+      continue;
+    }
+    const aiFp = structuralFingerprint(ai.content.join("\n"));
+    const curFp = structuralFingerprint(current);
+    const similarity = cosineSimilarity(aiFp.embedding, curFp.embedding);
+    if (similarity < threshold) {
+      discarded.push(rel);
+      continue;
+    }
+    matched.push(rel);
+    for (const model of ai.models) {
+      attestations.push({
+        anchor: { fingerprint: aiFp.fingerprint, hint: { path: rel } },
+        attribution: { provider: parser.provider, model, operatorId: input.operatorId, source: `${parser.id}-session-log` }
+      });
+    }
+  }
+  return {
+    manifest: { version: "0", commit: input.commit, generatedAt: input.now, attestations },
+    tool: parser.id,
+    matched,
+    discarded
+  };
+}
+
+// ../analyzer/src/tool-parsers.ts
+var CLAUDE_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+function* claudeAssistantRecords(raw) {
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (rec.type === "assistant" && Array.isArray(rec.message?.content)) yield rec;
+  }
+}
+var claudeCodeParser = {
+  id: "claude-code",
+  provider: "anthropic",
+  detect(raw) {
+    for (const rec of claudeAssistantRecords(raw)) {
+      for (const block of rec.message.content) {
+        if (block?.type === "tool_use" && CLAUDE_WRITE_TOOLS.has(block.name)) return true;
+      }
+    }
+    return false;
+  },
+  parse(raw) {
+    const edits = [];
+    for (const rec of claudeAssistantRecords(raw)) {
+      const model = rec.message?.model ?? "claude";
+      for (const block of rec.message.content) {
+        if (block?.type !== "tool_use" || !CLAUDE_WRITE_TOOLS.has(block.name)) continue;
+        const input = block.input;
+        const path = input?.file_path;
+        const content = input?.content ?? input?.new_string ?? "";
+        if (typeof path === "string" && content) edits.push({ path, content, model });
+      }
+    }
+    return edits;
+  }
+};
+var AIDER_FENCE = /^([^\n]+)\n```[^\n]*\n([\s\S]*?)\r?\n```/gm;
+var AIDER_FILENAME = /^[\w./\\-]+\.\w+$/;
+var AIDER_SR = /<<<<<<< SEARCH\r?\n(?:[\s\S]*?\r?\n)?=======\r?\n([\s\S]*?)\r?\n>>>>>>> REPLACE/g;
+var AIDER_MODEL = /^> Model:\s*(.+?)\s+with\s+[\w-]+ edit format/gim;
+function aiderModelAt(raw, pos) {
+  let model = "aider";
+  AIDER_MODEL.lastIndex = 0;
+  for (let m; m = AIDER_MODEL.exec(raw); ) {
+    if (m.index > pos) break;
+    model = m[1].trim();
+  }
+  return model;
+}
+var aiderParser = {
+  id: "aider",
+  provider: "aider",
+  detect(raw) {
+    return /^# aider chat started at /m.test(raw) || /^> Aider v\d/m.test(raw);
+  },
+  parse(raw) {
+    const wholeFormat = /with whole edit format/i.test(raw);
+    const edits = [];
+    AIDER_FENCE.lastIndex = 0;
+    for (let f; f = AIDER_FENCE.exec(raw); ) {
+      const name = f[1].trim();
+      if (!AIDER_FILENAME.test(name)) continue;
+      const path = name.replace(/\\/g, "/");
+      const body = f[2];
+      const model = aiderModelAt(raw, f.index);
+      let sawSearchReplace = false;
+      AIDER_SR.lastIndex = 0;
+      for (let s; s = AIDER_SR.exec(body); ) {
+        sawSearchReplace = true;
+        const content = s[1];
+        if (content.trim()) edits.push({ path, content, model });
+      }
+      if (!sawSearchReplace && wholeFormat && body.trim()) edits.push({ path, content: body, model });
+    }
+    return edits;
+  }
+};
+var SPECSTORY_EDIT = /<summary>Tool use:[^<]*?(?:Edit|Write|Create) file:\s*([^\n<]+?)\s*<\/summary>([\s\S]*?)<\/details>/g;
+var SPECSTORY_DIFF = /```diff\r?\n([\s\S]*?)```/g;
+var SPECSTORY_MODEL = /_\*\*Agent \(model ([\w./:+-]+)/gi;
+function htmlUnescape(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/gi, "'").replace(/&amp;/g, "&");
+}
+function specstoryModelAt(raw, pos) {
+  let model = "specstory";
+  SPECSTORY_MODEL.lastIndex = 0;
+  for (let m; m = SPECSTORY_MODEL.exec(raw); ) {
+    if (m.index > pos) break;
+    model = m[1].trim();
+  }
+  return model;
+}
+var specstoryParser = {
+  id: "specstory",
+  provider: "specstory",
+  detect(raw) {
+    return /^<!-- Generated by SpecStory/m.test(raw) || /<summary>Tool use: \*\*/.test(raw);
+  },
+  parse(raw) {
+    const edits = [];
+    SPECSTORY_EDIT.lastIndex = 0;
+    for (let m; m = SPECSTORY_EDIT.exec(raw); ) {
+      const path = m[1].trim();
+      const model = specstoryModelAt(raw, m.index);
+      const added = [];
+      SPECSTORY_DIFF.lastIndex = 0;
+      for (let d; d = SPECSTORY_DIFF.exec(m[2]); ) {
+        for (const line of d[1].split("\n")) {
+          if (line.startsWith("+") && !line.startsWith("+++")) added.push(htmlUnescape(line.replace(/^\+ ?/, "")));
+        }
+      }
+      const content = added.join("\n");
+      if (content.trim()) edits.push({ path, content, model });
+    }
+    return edits;
+  }
+};
+var registry2 = /* @__PURE__ */ new Map();
+function registerToolParser(parser) {
+  registry2.set(parser.id, parser);
+}
+function listToolParsers() {
+  return [...registry2.values()];
+}
+registerToolParser(claudeCodeParser);
+registerToolParser(aiderParser);
+registerToolParser(specstoryParser);
+function detectParser(raw, parsers = listToolParsers()) {
+  return parsers.find((p) => p.detect(raw)) ?? null;
+}
+
+// ../analyzer/src/redact-sample.ts
+var HEADER = "<!-- madeby parser-sample \u2014 STRUCTURE ONLY. All code, prompts, paths, and secrets were redacted\n     locally; only the log's format/keys and model identifiers remain. Safe to attach to an issue.\n     A parser keys on this shape, not on content \u2014 see packages/analyzer/src/tool-parsers.ts. -->";
+var SAFE_JSON_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "role",
+  "name",
+  "model",
+  "provider",
+  "source",
+  "id",
+  "uuid",
+  "tool",
+  "toolName",
+  "stop_reason",
+  "stopReason",
+  "finish_reason",
+  "status",
+  "event",
+  "kind",
+  "version",
+  "format",
+  "editFormat",
+  "modelName",
+  "agent",
+  "modelId"
+]);
+var PATH_JSON_KEYS = /* @__PURE__ */ new Set(["path", "file_path", "filePath", "uri", "fsPath", "filename", "file"]);
+function extPlaceholder(v) {
+  const m = /\.([A-Za-z0-9]{1,8})$/.exec(v.trim());
+  return m ? `<path>.${m[1]}` : "<path>";
+}
+function redactJsonValue(value, key) {
+  if (typeof value === "string") {
+    if (key && PATH_JSON_KEYS.has(key)) return extPlaceholder(value);
+    if (key && SAFE_JSON_KEYS.has(key)) return value;
+    return value === "" ? "" : "<redacted>";
+  }
+  if (Array.isArray(value)) return value.map((v) => redactJsonValue(v));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = redactJsonValue(v, k);
+    return out;
+  }
+  return value;
+}
+function looksLikeJsonl(lines) {
+  const nonEmpty = lines.filter((l) => l.trim());
+  if (!nonEmpty.length) return false;
+  let ok = 0;
+  for (const l of nonEmpty.slice(0, 50)) {
+    try {
+      const v = JSON.parse(l);
+      if (v && typeof v === "object") ok += 1;
+    } catch {
+    }
+  }
+  return ok >= Math.min(nonEmpty.length, 50) * 0.6;
+}
+function redactJsonl(lines) {
+  return lines.map((l) => {
+    if (!l.trim()) return "";
+    try {
+      return JSON.stringify(redactJsonValue(JSON.parse(l)));
+    } catch {
+      return "<redacted>";
+    }
+  }).join("\n");
+}
+var FENCE = /^(\s*```+)([A-Za-z0-9+.-]*)(.*)$/;
+var BARE_PATH_LINE = /^[\w./\\-]+\.[A-Za-z0-9]{1,8}$/;
+var KEEP_VERBATIM = /^(<<<<<<< SEARCH|=======|>>>>>>> REPLACE|_\*\*(?:User|Assistant)\*\*_|---+|> (?:Model|Aider v|Tokens|Git repo|Repo-map|Added|Cost|Warning|You can skip):|<\/?details>|<\/?summary>)/;
+function redactModelLine(line) {
+  const m = /^(\s*> Model:\s*)(\S+)(\s+with\s+[\w-]+ edit format.*)?$/.exec(line);
+  return m ? `${m[1]}${m[2]}${m[3] ?? ""}` : "> Model: <redacted>";
+}
+function redactPathsInline(s) {
+  return s.replace(/((?:file|repo|path|reading|writing|created|modified|deleted):\s*)([^\s<>"']+)/gi, (_m, lbl, p) => lbl + extPlaceholder(p)).replace(/(^|[\s(])((?:[A-Za-z]:[\\/]|~[\\/]|\.{1,2}[\\/]|[\\/])[\w./\\-]*)/g, (_m, pre, p) => pre + extPlaceholder(p)).replace(/(^|[\s(])((?:[\w.-]+[\\/]){2,}[\w.-]*)/g, (_m, pre, p) => pre + extPlaceholder(p));
+}
+function redactMarkdown(lines) {
+  const out = [];
+  let inFence = false;
+  const pushRedacted = () => {
+    if (out[out.length - 1] !== "<redacted>") out.push("<redacted>");
+  };
+  for (const raw of lines) {
+    const fence = FENCE.exec(raw);
+    if (fence) {
+      inFence = !inFence;
+      const info = (fence[3] ?? "").replace(/[\w.-]*[\\/][\w./\\-]*/g, (m) => extPlaceholder(m));
+      out.push(fence[1].trimStart() + fence[2] + info);
+      continue;
+    }
+    if (inFence) {
+      if (KEEP_VERBATIM.test(raw)) out.push(raw);
+      else pushRedacted();
+      continue;
+    }
+    if (raw.trim() === "") {
+      out.push("");
+      continue;
+    }
+    if (/^#{1,6}\s/.test(raw)) {
+      out.push(raw.replace(/^(#{1,6}\s).*/, "$1<redacted>"));
+      continue;
+    }
+    if (BARE_PATH_LINE.test(raw.trim())) {
+      out.push(extPlaceholder(raw.trim()));
+      continue;
+    }
+    if (KEEP_VERBATIM.test(raw)) {
+      out.push(/^\s*> Model:/.test(raw) ? redactModelLine(raw) : redactPathsInline(raw));
+      continue;
+    }
+    pushRedacted();
+  }
+  return out.join("\n");
+}
+function redactSample(raw) {
+  const lines = raw.split("\n");
+  const body = looksLikeJsonl(lines) ? redactJsonl(lines) : redactMarkdown(lines);
+  return `${HEADER}
+${body}
+`;
+}
+
+// ../analyzer/src/record-spans.ts
+function git2(root, ...a) {
+  return execFileSync3("git", ["-C", root, "-c", "core.quotePath=false", ...a], { encoding: "utf8" }).trim();
+}
+function autodiscover(root) {
+  const enc3 = root.replace(/[/_]/g, "-");
+  try {
+    const dir = join3(homedir(), ".claude", "projects", enc3);
+    return readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join3(dir, f)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function recordAiSpans(root, opts = {}) {
+  const transcriptPath = opts.transcriptPath ?? autodiscover(root);
+  if (!transcriptPath || !existsSync2(transcriptPath)) {
+    return { written: false, matched: 0, discarded: 0, message: "transcript not found \u2014 pass a transcript path", error: "transcript-not-found" };
+  }
+  const commit = git2(root, "rev-parse", opts.ref ?? "HEAD");
+  const transcriptText = readFileSync4(transcriptPath, "utf8");
+  const parser = detectParser(transcriptText);
+  if (!parser) {
+    return { written: false, matched: 0, discarded: 0, message: "unrecognized log format (Claude Code is supported today)", error: "unrecognized-format" };
+  }
+  const result = captureLocalSpans({
+    transcript: transcriptText,
+    parser,
+    repoRoot: root,
+    readFile: (rel) => {
+      try {
+        return readFileSync4(join3(root, rel), "utf8");
+      } catch {
+        return null;
+      }
+    },
+    commit,
+    operatorId: git2(root, "show", "-s", "--format=%ae", commit),
+    now: opts.now ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (result.manifest.attestations.length === 0) {
+    return {
+      written: false,
+      tool: result.tool ?? void 0,
+      matched: 0,
+      discarded: result.discarded.length,
+      message: `no AI-authored content from the session is structurally present (matched 0, discarded ${result.discarded.length})`
+    };
+  }
+  const out = join3(root, ".madeby", "spans", `${commit}.json`);
+  let kept = [];
+  if (existsSync2(out)) {
+    const thisSource = `${result.tool}-session-log`;
+    try {
+      kept = parseSpanManifest(readFileSync4(out, "utf8")).attestations.filter((a) => a.attribution.source !== thisSource);
+    } catch {
+    }
+  }
+  const manifest = { ...result.manifest, attestations: [...kept, ...result.manifest.attestations] };
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, serializeSpanManifest(manifest));
+  return {
+    written: true,
+    path: out,
+    tool: result.tool ?? void 0,
+    matched: result.matched.length,
+    discarded: result.discarded.length,
+    message: `wrote ${result.matched.length} witnessed file(s) (${result.discarded.length} discarded)`
+  };
+}
+function writeParserSample(root, opts = {}) {
+  const transcriptPath = opts.transcriptPath ?? autodiscover(root);
+  if (!transcriptPath || !existsSync2(transcriptPath)) {
+    return { written: false, message: "session log not found \u2014 pass its path", error: "transcript-not-found" };
+  }
+  const text = readFileSync4(transcriptPath, "utf8");
+  const tool = detectParser(text)?.id;
+  const skeleton = redactSample(text);
+  const dir = join3(root, ".madeby", "parser-samples");
+  mkdirSync(dir, { recursive: true });
+  const stamp = (opts.now ?? (/* @__PURE__ */ new Date()).toISOString()).replace(/[:.]/g, "-");
+  const out = join3(dir, `${tool ?? "unknown-tool"}-${stamp}.txt`);
+  writeFileSync(out, skeleton);
+  return { written: true, path: out, tool, message: `wrote a content-free format sample to ${out}` };
+}
+
+// ../analyzer/src/clone.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileP = promisify(execFile);
+
+// ../analyzer/src/enrich.ts
+var TTL_MS = 6 * 60 * 60 * 1e3;
+
+// ../analyzer/src/host/azure.ts
+var azureAdapter = {
+  id: "azure-devops",
+  name: "Azure DevOps",
+  // Azure commit emails are org/AAD emails with no public handle encoding (unlike GitHub's noreply).
+  // We never guess an identity from an email — so there is nothing to resolve zero-network here.
+  handleFromEmail() {
+    return null;
+  },
+  handleKey(handle2) {
+    return `az:${handle2.toLowerCase()}`;
+  },
+  // No profileUrl / resolveHandleViaApi / fetchProfile: Azure has no public per-user profile pages,
+  // and org-private identity enrichment is out of scope for the public mirror. The interface makes
+  // these optional precisely so an adapter can omit what its host doesn't offer.
+  // Azure Pipelines sets these predefined variables on a PR-triggered build. The target branch is
+  // given as a ref (not a SHA), so the range references origin/<target>; the pipeline template uses
+  // fetchDepth: 0 so that ref + the PR history are present. Any absence → null (recent history).
+  ciRange(env) {
+    if (env.BUILD_REASON !== "PullRequest") return null;
+    const targetRef = env.SYSTEM_PULLREQUEST_TARGETBRANCH;
+    if (!targetRef) return null;
+    const target = targetRef.replace(/^refs\/heads\//, "");
+    const head = env.SYSTEM_PULLREQUEST_SOURCECOMMITID || "HEAD";
+    return `origin/${target}..${head}`;
+  }
+};
+registerHostAdapter(azureAdapter);
+
+// ../analyzer/src/host/gitlab.ts
+var gitlabAdapter = {
+  id: "gitlab",
+  name: "GitLab",
+  // GitLab commit emails carry no reliable public handle encoding (unlike GitHub's noreply). We never
+  // guess an identity from an email, so there is nothing to resolve zero-network here.
+  handleFromEmail() {
+    return null;
+  },
+  handleKey(handle2) {
+    return `gl:${handle2.toLowerCase()}`;
+  },
+  // GitLab CI sets these predefined variables on a merge-request pipeline. CI_MERGE_REQUEST_DIFF_BASE_SHA
+  // is the merge-base of the MR; CI_COMMIT_SHA is the head — so base..head is the MR's own commits.
+  // (Needs the MR pipeline / a deep-enough fetch for those SHAs.) Any absence → null (recent history).
+  ciRange(env) {
+    if (env.CI_PIPELINE_SOURCE !== "merge_request_event") return null;
+    const base = env.CI_MERGE_REQUEST_DIFF_BASE_SHA;
+    const head = env.CI_COMMIT_SHA;
+    if (base && head) return `${base}..${head}`;
+    return null;
+  }
+};
+registerHostAdapter(gitlabAdapter);
+
+// src/scope.ts
+import { execFileSync as execFileSync4 } from "node:child_process";
+function repoRoot() {
+  try {
+    return execFileSync4("git", ["-c", "core.quotePath=false", "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function resolveRange(explicit) {
+  if (explicit) return { range: explicit };
+  const ci = detectCiRange();
+  return ci ? { range: ci.range, autoHost: ci.host } : {};
+}
+
+// src/commands/check.ts
+function checkCommand(args) {
+  const json = args.includes("--json");
+  const explicit = args.find((a) => !a.startsWith("--"));
+  const root = repoRoot();
+  if (!root) {
+    console.error("madeby check: not a git repository.");
+    process.exit(2);
+    return;
+  }
+  const { range, autoHost } = resolveRange(explicit);
+  const result = evaluateRepoDisclosure(root, { range });
+  if (json) {
+    console.log(JSON.stringify({ range: range ?? null, autoHost: autoHost ?? null, ...result }, null, 2));
+    process.exit(result.pass ? 0 : 1);
+    return;
+  }
+  if (result.warning) console.warn(`madeby check: ${result.warning}`);
+  if (autoHost) console.log(`madeby check: auto-scoped to the ${autoHost} PR range.`);
+  console.log(`madeby check \u2014 ${result.summary}`);
+  if (result.undisclosed.length) {
+    console.log(`
+Undisclosed commits (${result.undisclosed.length}):`);
+    for (const v of result.undisclosed.slice(0, 20)) {
+      console.log(`  \u2717 ${v.ref}  ${v.subject.slice(0, 60)}`);
+    }
+    if (result.undisclosed.length > 20) console.log(`  \u2026 and ${result.undisclosed.length - 20} more`);
+    console.log(
+      `
+To disclose: add a Co-Authored-By / Generated-by trailer, affirm your own authorship with 'madeby me', add a DCO Signed-off-by, sign the commit, or record your AI session with 'madeby ai'. (Disclosure, not a ban \u2014 what this project requires is set in .madeby/policy.json.)`
+    );
+  }
+  process.exit(result.pass ? 0 : 1);
+}
+
+// src/commands/ai.ts
+var ISSUE_URL = "https://github.com/MacDougherty/MadeBy/issues/new";
+function aiCommand(args) {
+  const root = repoRoot();
+  if (!root) {
+    console.error("madeby ai: not a git repository.");
+    process.exit(2);
+    return;
+  }
+  const makeSample = args.includes("--make-parser-sample");
+  const positional = args.filter((a) => !a.startsWith("--"));
+  if (makeSample) {
+    const s = writeParserSample(root, { transcriptPath: positional[0] });
+    if (s.error === "transcript-not-found") {
+      console.error("madeby ai: session log not found \u2014 pass it: madeby ai --make-parser-sample <log>");
+      process.exit(1);
+      return;
+    }
+    console.log(
+      `madeby ai: ${s.message}.
+  \u2192 It contains only the log's structure + model ids \u2014 all code, prompts, paths, and secrets
+    were redacted locally. Review it, then attach it to a new issue so we can add a parser:
+    ${ISSUE_URL}`
+    );
+    process.exit(0);
+    return;
+  }
+  const res = recordAiSpans(root, { transcriptPath: positional[0], ref: positional[1] });
+  if (res.error === "transcript-not-found") {
+    console.error("madeby ai: session log not found \u2014 pass it: madeby ai <transcript.jsonl> [ref]");
+    process.exit(1);
+    return;
+  }
+  if (res.error === "unrecognized-format") {
+    console.error(
+      "madeby ai: unrecognized log format \u2014 no registered tool parser matched (Claude Code, aider, and\n  SpecStory are supported today). Help add your tool WITHOUT sharing any code or prompts:\n    madeby ai --make-parser-sample <log>   # writes a content-free format sample to review + share"
+    );
+    process.exit(1);
+    return;
+  }
+  if (!res.written) {
+    console.log(`madeby ai: ${res.message}. Nothing recorded.`);
+    process.exit(0);
+    return;
+  }
+  console.log(
+    `madeby ai: wrote ${res.path} \u2014 [${res.tool}] ${res.matched} witnessed file(s) matched, ${res.discarded} discarded (not present in the checkout).`
+  );
+}
+
+// src/commands/me.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+function git3(root, args) {
+  return execFileSync5("git", ["-C", root, ...args], { encoding: "utf8" }).trim();
+}
+var HUMAN_ATTEST = /^[ \t]*(?:Authored-by-human|Human-authored(?:-by)?)[ \t]*:/im;
+function meCommand(_args) {
+  const root = repoRoot();
+  if (!root) {
+    console.error("madeby me: not a git repository.");
+    process.exit(2);
+    return;
+  }
+  let name = "";
+  let email = "";
+  try {
+    name = git3(root, ["config", "user.name"]);
+    email = git3(root, ["config", "user.email"]);
+  } catch {
+  }
+  if (!name || !email) {
+    console.error("madeby me: set your git identity first (git config user.name / user.email).");
+    process.exit(1);
+    return;
+  }
+  try {
+    execFileSync5("git", ["-C", root, "diff", "--cached", "--quiet"]);
+  } catch {
+    console.error("madeby me: you have staged changes. Commit them first \u2014 `me` affirms HEAD, not your index.");
+    process.exit(1);
+    return;
+  }
+  let subject = "";
+  let message = "";
+  try {
+    subject = git3(root, ["show", "-s", "--format=%s", "HEAD"]);
+    message = git3(root, ["show", "-s", "--format=%B", "HEAD"]);
+  } catch {
+    console.error("madeby me: no commit to affirm \u2014 make a commit first.");
+    process.exit(1);
+    return;
+  }
+  if (HUMAN_ATTEST.test(message)) {
+    console.log("madeby me: HEAD already affirms human authorship. Nothing to do.");
+    process.exit(0);
+    return;
+  }
+  execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", "--trailer", `Authored-by-human: ${name} <${email}>`]);
+  console.log(`madeby me: affirmed human authorship on HEAD \u2014 "${subject}" (Authored-by-human: ${name}).`);
+}
+
+// src/commands/who.ts
+function parseLines(arg) {
+  if (!arg) return {};
+  const m = /^--lines=(\d+)(?:-(\d+))?$/.exec(arg);
+  if (!m) return {};
+  const startLine = Number(m[1]);
+  const endLine = m[2] ? Number(m[2]) : startLine;
+  return { startLine, endLine };
+}
+function whoCommand(args) {
+  const json = args.includes("--json");
+  const path = args.find((a) => !a.startsWith("--"));
+  const { startLine, endLine } = parseLines(args.find((a) => a.startsWith("--lines=")));
+  const root = repoRoot();
+  if (!root) {
+    console.error("madeby who: not a git repository.");
+    process.exit(2);
+    return;
+  }
+  if (path) {
+    const res = provenanceOf(root, path, { startLine, endLine });
+    if (json) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(`made by whom? \u2014 ${res.path}${startLine ? ` (lines ${startLine}-${endLine})` : ""}`);
+    if (res.records.length === 0) {
+      console.log("  (no record \u2014 origin unknown)");
+      return;
+    }
+    for (const r of res.records) {
+      const span = r.startLine ? `${r.startLine}-${r.endLine ?? r.startLine}` : "\u2014";
+      console.log(`  [${r.confidence}] L${span}  ${r.evidence}`);
+    }
+    return;
+  }
+  const map = provenanceMap(root, {});
+  if (json) {
+    console.log(JSON.stringify(map, null, 2));
+    return;
+  }
+  console.log(map.summary);
+  for (const w of map.witnessed) {
+    console.log(`  \u270E ${w.path}  [${w.models.join(", ")}]`);
+  }
+}
+
+// src/init-repo.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var GH_WORKFLOW = `name: Disclosure
+on: pull_request
+jobs:
+  madeby:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: MacDougherty/MadeBy/packages/action@v0.1.0
+`;
+function writeIfAbsent(abs, rel, content, created, skipped) {
+  if (existsSync3(abs)) {
+    skipped.push(rel);
+    return;
+  }
+  mkdirSync2(dirname2(abs), { recursive: true });
+  writeFileSync2(abs, content);
+  created.push(rel);
+}
+function initRepo(root, opts = {}) {
+  const mode = opts.mode ?? "advisory";
+  const host = opts.host ?? "github";
+  const created = [];
+  const skipped = [];
+  writeIfAbsent(join4(root, ".madeby", "policy.json"), ".madeby/policy.json", JSON.stringify({ version: 0, mode }, null, 2) + "\n", created, skipped);
+  if (host === "github") {
+    writeIfAbsent(join4(root, ".github", "workflows", "disclosure.yml"), ".github/workflows/disclosure.yml", GH_WORKFLOW, created, skipped);
+  }
+  const nextSteps = ["Commit the created files."];
+  if (host === "azure-devops") {
+    nextSteps.push("Add the Azure Pipelines template (packages/action/azure-pipelines-disclosure.yml) and wire it as a PR build-validation branch policy.");
+  } else if (host !== "github") {
+    nextSteps.push(`Add a CI step that runs 'npx madeby check' on pull requests for ${host}.`);
+  }
+  if (mode !== "required") {
+    nextSteps.push(`When ready to enforce: set mode to "required", then make the check required on the protected branch \u2014 the host's control plane (GitHub: gh api branch protection; Azure: a build-validation policy). See the MCP resource madeby://guide/enforce for exact commands.`);
+  }
+  nextSteps.push("Contributors disclose origin with a Co-Authored-By / Generated-by trailer (AI), an Authored-by-human trailer ('madeby me'), a DCO Signed-off-by, a signed commit, or 'madeby ai' (record your own AI session's witnessed spans).");
+  nextSteps.push("Existing history is accounted for honestly, not fabricated: run 'madeby check' over full history to recognize what's already disclosed; pre-adoption commits stay unknown. See madeby://guide/backfill.");
+  return { created, skipped, policyMode: mode, host, nextSteps };
+}
+
+// src/commands/init.ts
+function initCommand(args) {
+  const root = repoRoot();
+  if (!root) {
+    console.error("madeby init: not a git repository.");
+    process.exit(2);
+    return;
+  }
+  const mode = args.includes("--required") ? "required" : "advisory";
+  const hostIdx = args.indexOf("--host");
+  const host = hostIdx >= 0 ? args[hostIdx + 1] : void 0;
+  const r = initRepo(root, { mode, host });
+  for (const f of r.created) console.log(`  + ${f}`);
+  for (const f of r.skipped) console.log(`  \xB7 ${f} (exists \u2014 left as-is)`);
+  console.log(`
+madeby init \u2014 policy: ${r.policyMode}, host: ${r.host}`);
+  console.log("Next:");
+  for (const s of r.nextSteps) console.log(`  - ${s}`);
+}
+
+// src/mcp.ts
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { createInterface } from "node:readline";
+var DEFAULT_PROTOCOL = "2024-11-05";
+var SERVER_INFO = { name: "madeby", version: "0.1.0" };
+function rootFor(path) {
+  const cwd = path && path.length ? path : process.cwd();
+  return execFileSync6("git", ["-C", cwd, "-c", "core.quotePath=false", "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+}
+var repoInput = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: "path to the repo (default: the server's working directory)" },
+    range: { type: "string", description: "git commit range, e.g. origin/main..HEAD (default: recent history)" }
+  }
+};
+var TOOLS = [
+  {
+    name: "init",
+    description: "Align a repository with MadeBy in one call: create .madeby/policy.json (advisory by default \u2014 reports, never fails) and the CI disclosure check for the host (github default; azure-devops guided). Idempotent \u2014 never clobbers an existing policy or workflow. Returns the files created/skipped and the recommended next steps. Read the resources: madeby://guide/align (full workflow), madeby://guide/enforce (make the check required \u2014 the host's control plane, exact commands), madeby://guide/backfill (account for existing history honestly \u2014 never fabricate).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "path to the repo (default: the server's working directory)" },
+        mode: { enum: ["advisory", "required"], description: "policy mode to seed (default: advisory)" },
+        host: { type: "string", description: "CI host to wire: github (default) or azure-devops" }
+      }
+    },
+    handler: (args) => initRepo(rootFor(args.path), { mode: args.mode, host: args.host })
+  },
+  {
+    name: "check",
+    description: "Evaluate a repo's commits against its .madeby/policy.json disclosure policy (the maintainer gate). Returns pass/fail, the policy mode, and the undisclosed commits. The policy file is optional \u2014 with no file (or an invalid one) it degrades to advisory (report-only, never a false gate).",
+    inputSchema: repoInput,
+    handler: (args) => evaluateRepoDisclosure(rootFor(args.path), { range: args.range })
+  },
+  {
+    name: "who",
+    description: "Made by whom? Read what's ON THE RECORD about who made this. With `path`: one file's origin \u2014 witnessed AI spans (model/tool, precise) where captured, last-touch commit disclosure from git blame elsewhere (approximate, labeled), unknown otherwise. With no `path`: a repo-wide map (the orientation to read BEFORE you work) \u2014 the witnessed AI surface plus commit-level disclosure coverage, cheap (no per-file blame). The universal contract is the line range: for a symbol, turn it into a line range with your own tooling (tree-sitter/LSP/ctags) and pass it \u2014 MadeBy never parses code. Disclosure, not detection: it reports what's disclosed and never asserts 'human'.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "repo-relative file to read one file's origin (omit for a repo-wide map)" },
+        repo: { type: "string", description: "path to the repo (default: the server's working directory)" },
+        startLine: { type: "number", description: "with `path`: optional 1-based start of a line range" },
+        endLine: { type: "number", description: "with `path`: optional 1-based end of a line range" },
+        prefix: { type: "string", description: "map only: limit to a path prefix, e.g. src/" },
+        commitLimit: { type: "number", description: "map only: recent commits to include in the coverage figure (default 500)" }
+      }
+    },
+    handler: (args) => args.path ? provenanceOf(rootFor(args.repo), args.path, {
+      startLine: args.startLine,
+      endLine: args.endLine
+    }) : provenanceMap(rootFor(args.repo), { prefix: args.prefix, commitLimit: args.commitLimit })
+  },
+  {
+    name: "ai",
+    description: "Made by AI (WRITE): record witnessed AI-authorship spans from YOUR OWN session log into the repo's .madeby/spans (asserted tier, self-reported) \u2014 how an agent DISCLOSES its own contribution. Honest by construction: it records only spans whose AI-authored content is STRUCTURALLY PRESENT in the checkout (survives reformatting); anything not present is discarded. Writes only derived attribution, locally \u2014 the log/content never leave the machine. It cannot claim a higher tier or attribute work to anyone else.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "path to the repo (default: the server's working directory)" },
+        log: { type: "string", description: "session transcript path (default: auto-discover the Claude Code transcript)" },
+        ref: { type: "string", description: "commit the spans anchor to (default: HEAD)" }
+      }
+    },
+    handler: (args) => recordAiSpans(rootFor(args.path), { transcriptPath: args.log, ref: args.ref })
+  }
+];
+var ALIGN_GUIDE = `# Aligning a repository with MadeBy
+
+MadeBy is **disclosure, not detection** \u2014 it records what a commit *states* about its origin, never
+guesses whether code is AI. To align a repo:
+
+1. **Assess** \u2014 call \`check\` (or \`who\` with no path for a repo-wide map) to see current coverage.
+2. **Set up** \u2014 call \`init\`: it writes \`.madeby/policy.json\` (advisory) and the CI disclosure check.
+   Idempotent; it never clobbers an existing policy or workflow. Then commit the created files.
+3. **Disclose going forward** \u2014 contributors disclose origin with a Co-Authored-By / Generated-by
+   trailer (AI), an \`Authored-by-human\` trailer (work they wrote themselves \u2014 the symmetric human
+   claim; \`madeby me\` adds it), a DCO Signed-off-by, a signed commit, or \`ai\` (record your own AI
+   session's witnessed spans, structurally verified and local). Human and AI disclosure ride the same ladder.
+4. **Account for existing history honestly** \u2014 do NOT fabricate disclosure for past commits. Read the
+   \`madeby://guide/backfill\` resource: recognize what's already disclosed, attach recoverable
+   evidence, and set an adoption boundary \u2014 pre-boundary history is labeled *unknown*, never invented.
+5. **Enforce when ready** \u2014 set the policy mode to \`required\`, then make the check required on the
+   protected branch. That last step is the host's control plane (your credentials), so MadeBy doesn't
+   do it for you \u2014 the exact commands are in the \`madeby://guide/enforce\` resource.
+6. **Verify** \u2014 call \`check\` again.
+
+Nothing is hosted; nothing leaves the CI. The maintainer owns the policy.
+`;
+var ENFORCE_GUIDE = `# Enforcing the MadeBy disclosure check
+
+MadeBy sets the policy (mode: required) but does NOT change your repository's protection settings \u2014
+that needs your credentials and is the host's control plane, so you (or an agent acting as you) make
+the check required. MadeBy deliberately keeps this an explicit, reviewable action.
+
+## GitHub (needs repo admin + the gh CLI, authenticated)
+
+1. Set the policy to required (or run: madeby init --required):
+   in .madeby/policy.json set "mode": "required".
+2. Find the check's name: open any pull request and read the Checks tab. For the generated workflow
+   the job name is "madeby".
+3. Add it as a required status check on the protected branch (e.g. main). If protection already
+   exists, add the context:
+
+       echo '["madeby"]' | gh api -X POST \\
+         repos/OWNER/REPO/branches/main/protection/required_status_checks/contexts --input -
+
+   If the branch has no protection yet, create it with a required_status_checks block that lists
+   "madeby" (PUT repos/OWNER/REPO/branches/main/protection --input protection.json).
+
+Confirm against the GitHub REST docs for "branch protection" and verify with the actual check name
+from a PR.
+
+## Azure DevOps (build validation branch policy)
+
+Project Settings -> Repositories -> (repo) -> Policies -> Branch (main) -> Build Validation -> Add:
+point it at the pipeline that includes azure-pipelines-disclosure.yml; set trigger automatic and
+required. CLI equivalent: az repos policy build create ... --branch main --blocking true.
+`;
+var BACKFILL_GUIDE = `# Honest backfill for an existing repo
+
+You cannot retroactively disclose past commits by inventing origin \u2014 that is fabrication, and MadeBy
+refuses it. But you CAN make an honest, verifiable statement about history. Backfill in layers, and
+never raise a commit's origin above its evidence \u2014 unknown stays unknown, just explicitly so.
+
+1. **Recognize what's already there** (free, pure evidence). Run \`check\` over FULL history:
+   existing Co-Authored-By AI trailers, DCO Signed-off-by, signed commits, and bot authorship are
+   recognized now even though they predate adoption. Much of your history may already be disclosed.
+
+2. **Attach recoverable evidence** (opt-in, evidence-grade):
+   - Old AI-tool session logs -> \`ai\` attaches structurally-verified spans to their commits (it
+     only matches content actually present, so it cannot over-claim). Pass the transcript + the ref.
+   - Committed AI-tool configs (.cursor/, CLAUDE.md, ...) are repo-level evidence the repo used AI.
+
+3. **Set the adoption boundary** (the watermark). The commit that introduced .madeby/policy.json is
+   your dated adoption boundary:
+
+       git log --diff-filter=A --format=%H -- .madeby/policy.json | tail -1
+
+   Report coverage RELATIVE to it: commits after the boundary are in-regime and measured; commits
+   before are UNKNOWN-origin (never "human", never "AI") unless independently disclosed by step 1/2.
+   This makes the gap explicit and dated instead of hidden.
+
+4. **Optionally self-attest** what you can stand behind (asserted tier). The author may assert
+   specific pre-boundary facts they honestly know ("I solo-authored the initial import"; "vendor/ is
+   third-party"). It is labeled self-reported (asserted) \u2014 never proof \u2014 and is contestable.
+
+The invariant: backfill adds only evidence you can point to, or an explicitly-labeled assertion; it
+never fabricates disclosure or upgrades origin beyond its evidence.
+`;
+var POLICY_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: ".madeby/policy.json",
+  type: "object",
+  required: ["version", "mode"],
+  properties: {
+    version: { const: 0 },
+    mode: { enum: ["advisory", "required"], description: "advisory: report only (the default, and the safe degrade); required: fail on any undisclosed commit" },
+    accept: { type: "array", items: { type: "string" }, description: "restrict what satisfies the policy (e.g. dco-signoff, ai-trailer, commit-signature); omit \u21D2 any recognized disclosure counts" }
+  }
+};
+var RESOURCES = [
+  { uri: "madeby://guide/align", name: "Aligning a repo with MadeBy", description: "The step-by-step workflow to align a repository (for humans and agents).", mimeType: "text/markdown", text: ALIGN_GUIDE },
+  { uri: "madeby://guide/enforce", name: "Enforcing the disclosure check", description: "How to make the check required on a protected branch (GitHub / Azure DevOps) \u2014 the host's control plane, exact commands.", mimeType: "text/markdown", text: ENFORCE_GUIDE },
+  { uri: "madeby://guide/backfill", name: "Honest backfill for existing repos", description: "How to account for pre-adoption history honestly \u2014 recognize, attach evidence, set a boundary; never fabricate.", mimeType: "text/markdown", text: BACKFILL_GUIDE },
+  { uri: "madeby://schema/policy", name: ".madeby/policy.json schema", description: "JSON Schema for the disclosure policy file.", mimeType: "application/json", text: JSON.stringify(POLICY_SCHEMA, null, 2) }
+];
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+function handle(msg) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case "initialize":
+      send({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: params?.protocolVersion ?? DEFAULT_PROTOCOL,
+          capabilities: { tools: {}, resources: {} },
+          serverInfo: SERVER_INFO
+        }
+      });
+      return;
+    case "notifications/initialized":
+    case "notifications/cancelled":
+      return;
+    // notifications get no response
+    case "ping":
+      send({ jsonrpc: "2.0", id, result: {} });
+      return;
+    case "tools/list":
+      send({ jsonrpc: "2.0", id, result: { tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })) } });
+      return;
+    case "resources/list":
+      send({ jsonrpc: "2.0", id, result: { resources: RESOURCES.map(({ uri, name, description, mimeType }) => ({ uri, name, description, mimeType })) } });
+      return;
+    case "resources/read": {
+      const found = RESOURCES.find((r) => r.uri === params?.uri);
+      if (!found) {
+        send({ jsonrpc: "2.0", id, error: { code: -32602, message: `unknown resource: ${String(params?.uri)}` } });
+        return;
+      }
+      send({ jsonrpc: "2.0", id, result: { contents: [{ uri: found.uri, mimeType: found.mimeType, text: found.text }] } });
+      return;
+    }
+    case "tools/call": {
+      const tool = TOOLS.find((t) => t.name === params?.name);
+      if (!tool) {
+        send({ jsonrpc: "2.0", id, error: { code: -32602, message: `unknown tool: ${String(params?.name)}` } });
+        return;
+      }
+      try {
+        const out = tool.handler(params?.arguments ?? {});
+        send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(out, null, 2) }] } });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        send({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: `error: ${message}` }], isError: true } });
+      }
+      return;
+    }
+    default:
+      if (id !== void 0) send({ jsonrpc: "2.0", id, error: { code: -32601, message: `method not found: ${String(method)}` } });
+  }
+}
+function startMcpServer() {
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    handle(msg);
+  });
+  process.stderr.write("madeby mcp: ready (stdio; tools: init, check, who, ai; resources: align/enforce/backfill guides, policy schema)\n");
+}
+
+// src/madeby.ts
+function help() {
+  console.log(`madeby \u2014 verifiable content provenance ("made by whom?")
+
+Usage:
+  madeby init                    Set MadeBy up: write .madeby/policy.json + the CI disclosure check.
+                                 --required to enforce now; --host azure-devops for Azure Pipelines.
+  madeby check [<range>]         The gate: do commits meet .madeby/policy.json? (a verdict \u2014 exit
+                                 code gates). <range> e.g. origin/main..HEAD; in CI it's auto-detected.
+                                 --json for a machine-readable result.
+  madeby who [<path>]            Made by whom? Read what's on the record about who made this \u2014 one
+   (alias: whom)                 file's origin, or the whole repo with no path. --lines=A-B to scope.
+  madeby ai [<log>] [<ref>]      Made by AI: record your AI session's witnessed spans into .madeby/spans.
+                                 <log> defaults to the auto-discovered Claude Code transcript.
+  madeby me                      Made by me: affirm you authored HEAD yourself (an Authored-by-human
+                                 trailer \u2014 the symmetric human claim to \`ai\`).
+  madeby mcp                     Run the MCP server (stdio) \u2014 the tools, agent-callable.
+  madeby help                    Show this help.
+
+Disclosure, never detection: madeby states what origin was disclosed; it never asserts whether
+code is AI. What a project requires is set in its .madeby/policy.json \u2014 the maintainer's call.`);
+}
+var [cmd, ...rest] = process.argv.slice(2);
+switch (cmd) {
+  case "init":
+    initCommand(rest);
+    break;
+  case "check":
+    checkCommand(rest);
+    break;
+  case "who":
+  case "whom":
+    whoCommand(rest);
+    break;
+  case "ai":
+    aiCommand(rest);
+    break;
+  case "me":
+    meCommand(rest);
+    break;
+  case "mcp":
+    startMcpServer();
+    break;
+  case void 0:
+  case "help":
+  case "--help":
+  case "-h":
+    help();
+    break;
+  default:
+    console.error(`madeby: unknown command '${cmd}'
+`);
+    help();
+    process.exit(2);
+}