madeby 0.3.7 → 0.3.9

package/README.md

@@ -42,6 +42,7 @@ npm i -g madeby
 
 ```
 madeby init                    Set MadeBy up: write .madeby/policy.json + the CI disclosure check.
+                               --record-model (opt-in) also asks agents to name the model version.
 madeby check  [<range>]        The gate: do commits meet .madeby/policy.json? (a verdict — exit code
                                gates). <range> e.g. origin/main..HEAD — a PR's own commits. --json too.
 madeby coverage [<range>]      The scoreboard: how much of the repo's authorship is disclosed (known)
@@ -49,9 +50,10 @@ madeby coverage [<range>]      The scoreboard: how much of the repo's authorship
 madeby who    [<path>]         Made by whom? What's on the record about who made this — one file's
   (alias: whom)                origin, or the whole repo with no path. --lines=A-B to scope. --json too.
 madeby ai     [tool]           Made by AI: attest AI authorship of HEAD (an Authored-by-ai trailer).
+                               --model <version> names the model too (Authored-by-ai: <tool>:<version>).
                                `--witness [log]` instead records witnessed spans from a session log.
 madeby me     [--with-ai [t]]  Made by me: affirm you authored HEAD (Authored-by-human); --with-ai adds
-                               Assisted-by → with_ai.
+                               Assisted-by → with_ai. --model <version> names the model too.
 madeby mcp                     Run the MCP server (stdio) — the tools, agent-callable.
 madeby help
 ```
@@ -97,13 +99,23 @@ authorship coverage — last 500 commits  (estimate · disclosure, not detection
   of the 310 known:  human 41% · with_ai 38% · ai 21%
   trust:  asserted 88% · verified 12%  — self-reported; sign commits to verify
 
+  agents & models named in the 183 AI commits:
+    Claude Code        121   66%
+    Claude Opus 5.5     98   54%
+    Cursor              62   34%
+
   → 38% unknown. Require disclosure going forward:  madeby init --required
 ```
 
 It is a **labeled estimate**, honest by construction: an undisclosed commit is **unknown**, never
 inferred as human — disclosure, not detection. The human/with_ai/ai mix is reported *of the known*,
-never of the whole repo, and the asserted-vs-verified split shows how much is signed. `--json` emits
-counts only (percentages are derived at the edge, never stored). Use it to see your gap, then
+never of the whole repo, and the asserted-vs-verified split shows how much is signed. The agents and
+model versions are listed exactly as the AI commits name them — a commit naming a tool and its model
+(`Assisted-by: Claude Code` + `Co-Authored-By: Claude Opus 5.5`) counts under both, so those rows can
+sum past 100%. `--json` emits
+counts only (percentages are derived at the edge, never stored). A plain merge authors nothing and
+isn't scored; a merge that changes content of its own (a conflict resolution) is, like any other
+commit — chosen by what it changes, never by whether it discloses. Use it to see your gap, then
 `madeby init --required` to close it going forward.
 
 ### `madeby me` — affirm human authorship
@@ -138,6 +150,15 @@ Two modes, nothing more:
 - `required` — fail on any commit that discloses nothing your policy accepts.
 - optional `"accept": ["dco-signoff", "ai-trailer", …]` — restrict what satisfies the policy
   (omit ⇒ any recognized disclosure counts).
+- optional `"recordModel": true` — written by `madeby init --record-model`: the repo asks AI
+  disclosures to name the model version as well as the tool. It adds one line to the AGENTS.md rule,
+  and `me --with-ai` / `ai` then read the model from the **tool's own record of the session** — Cursor's
+  `CURSOR_MODEL`, the Copilot CLI and Claude Code session logs (locally; only the model id is read) —
+  which wins over an agent's `--model`, since an agent routed by "Auto" may not know which model served
+  it. Elsewhere `--model <version>` is used, never guessed. So `coverage` can list each **agent · model** pairing
+  (`Cursor · gpt-5.3-codex` vs `Claude Code · claude-sonnet-5`). A request, not a gate — an AI
+  disclosure without a model still satisfies the policy. Opt-in because naming models is a project's
+  call: the Linux kernel, for one, asks only that an LLM was used, not which.
 
 (There's no "off" — that's just not running the check. Advisory is the floor.)
 

package/dist/madeby.mjs

@@ -4,6 +4,18 @@
 import { execFileSync } from "node:child_process";
 var FIELD = "";
 var RECORD = "";
+var GROUP = "";
+var parseMeta = (rec) => {
+  const parts = rec.split(FIELD);
+  const sig = parts[3] ?? "N";
+  return {
+    sha: parts[0] ?? "",
+    authorName: parts[1] ?? "",
+    authorEmail: parts[2] ?? "",
+    signed: sig !== "N" && sig !== "",
+    message: parts.slice(4).join(FIELD).trimEnd()
+  };
+};
 function readGitLog(repoPath, limit, range) {
   try {
     const args = [
@@ -11,7 +23,7 @@ function readGitLog(repoPath, limit, range) {
       repoPath,
       "log",
       "--no-merges",
-      // merge commits aren't authored content — exclude them from attribution
+      // a merge is not authored content by default; readAuthoredMerges finds those that are
       ...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
@@ -22,19 +34,38 @@ function readGitLog(repoPath, limit, range) {
       ...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 };
-    });
+    return out.split(RECORD).map((r) => r.replace(/^\s+/, "")).filter((r) => r.length > 0).map(parseMeta);
   } catch {
     return [];
   }
 }
+function readAuthoredMerges(repoPath, opts = {}) {
+  try {
+    const args = [
+      "-C",
+      repoPath,
+      "log",
+      "--merges",
+      "--cc",
+      "--name-only",
+      `--format=${RECORD}%H${FIELD}%an${FIELD}%ae${FIELD}%G?${FIELD}%B${GROUP}`,
+      ...opts.since !== void 0 && !opts.range ? [`--since=@${opts.since}`] : [],
+      ...opts.range ? [opts.range] : []
+    ];
+    const out = execFileSync("git", args, { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+    return out.split(RECORD).filter((r) => r.includes(GROUP)).filter((r) => r.slice(r.lastIndexOf(GROUP) + 1).trim().length > 0).map((r) => parseMeta(r.slice(0, r.lastIndexOf(GROUP))));
+  } catch {
+    return [];
+  }
+}
+function commitTime(repoPath, sha) {
+  try {
+    const t = Number(execFileSync("git", ["-C", repoPath, "log", "-1", "--format=%ct", sha], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
+    return Number.isFinite(t) && t > 0 ? t : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // ../classify/src/classify.ts
 var AI_PATTERNS = [
@@ -55,6 +86,20 @@ function matchAi(text) {
   }
   return null;
 }
+var TOOL_MODEL = /^([^:\s<>][^:<>]*?)[ \t]*:[ \t]*([^\s:<>/][^:<>]*?)$/;
+function splitToolModel(value) {
+  const v = value.replace(/<[^>]*>/g, "").trim();
+  const m = TOOL_MODEL.exec(v);
+  return m ? { tool: m[1].trim(), model: m[2].trim() } : null;
+}
+function matchAiTrailer(who) {
+  const tm = splitToolModel(who);
+  if (tm) {
+    const p = matchAi(tm.tool) ?? matchAi(tm.model) ?? genericAiDisclosure(tm.tool);
+    if (p) return { ...p, raw: who.trim(), tool: tm.tool, modelVersion: tm.model };
+  }
+  return matchAi(who) ?? genericAiDisclosure(who);
+}
 var GENERIC_AI_TRAILER = /^(?:AI|an? AI|AI (?:assistant|tool|pair)|artificial intelligence)$/i;
 function genericAiDisclosure(who) {
   const w = who.trim();
@@ -94,13 +139,13 @@ function classifyCommit(commit) {
   const aiAuthored = [...commit.message.matchAll(AI_AUTHOR_TRAILER)].map((m) => m[1].trim());
   if (aiAuthored.length > 0 && !HUMAN_ATTEST.test(commit.message)) {
     const who = aiAuthored[0];
-    const c = matchAi(who) ?? { provider: "unspecified", raw: who };
+    const c = matchAiTrailer(who) ?? { provider: "unspecified", raw: who };
     return { class: "ai", confidence: CONF_AI, signals: [`authored-by-ai:${c.provider}`], aiContributors: [c] };
   }
   const trailers = [...commit.message.matchAll(TRAILER_RE)].map((m) => m[1].trim());
   let humanCoAuthors = 0;
   for (const who of trailers) {
-    const ai = matchAi(who) ?? genericAiDisclosure(who);
+    const ai = matchAiTrailer(who);
     if (ai) {
       aiContributors.push(ai);
       signals.push(`co-authored-by:${ai.provider}`);
@@ -109,7 +154,7 @@ function classifyCommit(commit) {
     }
   }
   for (const who of aiAuthored) {
-    const ai = matchAi(who) ?? { provider: "unspecified", raw: who };
+    const ai = matchAiTrailer(who) ?? { provider: "unspecified", raw: who };
     aiContributors.push(ai);
     signals.push(`authored-by-ai:${ai.provider}`);
   }
@@ -894,7 +939,12 @@ function parseDisclosurePolicy(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 };
+  return {
+    version,
+    mode,
+    ...accept && accept.length > 0 ? { accept } : {},
+    ...o.recordModel === true ? { recordModel: true } : {}
+  };
 }
 function evaluateDisclosurePolicy(policy, commits) {
   const accept = policy.accept;
@@ -1200,30 +1250,54 @@ function provenanceMap(root, opts = {}) {
 }
 
 // ../analyzer/src/coverage.ts
+function agentName(raw) {
+  const name = raw.replace(/<[^>]*>/g, " ").split(/\s+/).filter((w) => !w.includes("@")).join(" ").replace(/(\s*\([^)]*\))+\s*$/, "").trim();
+  return name || raw.trim();
+}
 function repoCoverage(root, opts = {}) {
-  const commits = readGitLog(root, opts.range ? void 0 : opts.limit ?? 500, opts.range);
+  const limit = opts.range ? void 0 : opts.limit ?? 500;
+  const authored = readGitLog(root, limit, opts.range);
+  const oldest = authored.at(-1)?.sha;
+  const since = limit && oldest && authored.length >= limit ? commitTime(root, oldest) : void 0;
+  const merges = authored.length > 0 && (!limit || authored.length < limit || since !== void 0) ? readAuthoredMerges(root, { range: opts.range, since }) : [];
+  const commits = [...authored, ...merges];
   const byCategory = { human: 0, with_ai: 0, ai: 0, bot: 0 };
   const byTier = { asserted: 0, verified: 0 };
   let known = 0;
+  const agents = /* @__PURE__ */ new Map();
   for (const c of commits) {
     const kinds = commitDisclosureKinds({ message: c.message, signed: c.signed });
-    const cls = classifyCommit({ message: c.message, authorName: c.authorName, authorEmail: c.authorEmail, signed: c.signed, sha: c.sha }).class;
+    const { class: cls, aiContributors } = classifyCommit({ message: c.message, authorName: c.authorName, authorEmail: c.authorEmail, signed: c.signed, sha: c.sha });
     const category = cls === "human" && !kinds.includes("human-attestation") ? "unknown" : cls;
     if (category === "unknown") continue;
     known += 1;
     byCategory[category] += 1;
     if (c.signed) byTier.verified += 1;
     else byTier.asserted += 1;
+    if (category === "with_ai" || category === "ai") {
+      const named = /* @__PURE__ */ new Set();
+      for (const a of aiContributors) {
+        const paired = a.tool && a.modelVersion ? { tool: a.tool, model: a.modelVersion } : void 0;
+        const name = paired ? `${paired.tool} \xB7 ${paired.model}` : agentName(a.raw);
+        const key = name.toLowerCase();
+        if (named.has(key)) continue;
+        named.add(key);
+        const e = agents.get(key) ?? { name, provider: a.provider, ...paired, commits: 0 };
+        e.commits += 1;
+        agents.set(key, e);
+      }
+    }
   }
   return {
     isEstimate: true,
-    methodology: "commit-level authorship disclosure (estimate); undisclosed = unknown, never inferred",
-    scope: opts.range ? `range ${opts.range}` : `last ${commits.length} commits`,
+    methodology: "commit-level authorship disclosure (estimate); undisclosed = unknown, never inferred; merges scored only when they change content of their own",
+    scope: (opts.range ? `range ${opts.range}` : `last ${authored.length} commits`) + (merges.length ? ` + ${merges.length} merges with changes of their own` : ""),
     total: commits.length,
     known,
     unknown: commits.length - known,
     byCategory,
-    byTier
+    byTier,
+    byAgent: [...agents.values()].sort((a, b) => b.commits - a.commits || a.name.localeCompare(b.name))
   };
 }
 
@@ -1759,6 +1833,94 @@ To disclose: add a Co-Authored-By / Generated-by trailer, affirm your own author
 
 // src/commands/me.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join6 } from "node:path";
+
+// src/model-source.ts
+import { closeSync, existsSync as existsSync4, openSync, readdirSync as readdirSync3, readSync, statSync as statSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join5 } from "node:path";
+var SESSION_ID = /^[0-9a-f-]{8,64}$/i;
+var TAIL_BYTES = 2 * 1024 * 1024;
+function lastModelIn(path) {
+  let fd;
+  try {
+    const size = statSync2(path).size;
+    const len = Math.min(size, TAIL_BYTES);
+    const buf = Buffer.alloc(len);
+    fd = openSync(path, "r");
+    readSync(fd, buf, 0, len, size - len);
+    const models = [...buf.toString("utf8").matchAll(/"(?:model|newModel)"\s*:\s*"([^"<][^"]{0,80})"/g)].map((m) => m[1]);
+    return models.at(-1) ?? null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+var MODEL_SOURCES = [
+  {
+    tool: "Cursor",
+    matches: /\bcursor/i,
+    detect: (env) => env.CURSOR_AGENT === "1" && env.CURSOR_MODEL?.trim() ? { model: env.CURSOR_MODEL.trim(), source: "Cursor's CURSOR_MODEL" } : null
+  },
+  {
+    tool: "GitHub Copilot CLI",
+    matches: /copilot/i,
+    detect: (env, home) => {
+      const id = env.COPILOT_AGENT_SESSION_ID;
+      if (env.COPILOT_CLI !== "1" || !id || !SESSION_ID.test(id)) return null;
+      const model = lastModelIn(join5(home, ".copilot", "session-state", id, "events.jsonl"));
+      return model ? { model, source: "Copilot CLI's session log" } : null;
+    }
+  },
+  {
+    tool: "Claude Code",
+    matches: /claude/i,
+    detect: (env, home) => {
+      const id = env.CLAUDE_CODE_SESSION_ID;
+      if (env.CLAUDECODE !== "1" || !id || !SESSION_ID.test(id)) return null;
+      const projects = join5(home, ".claude", "projects");
+      if (!existsSync4(projects)) return null;
+      try {
+        for (const dir of readdirSync3(projects)) {
+          const p = join5(projects, dir, `${id}.jsonl`);
+          if (existsSync4(p)) {
+            const model = lastModelIn(p);
+            return model ? { model, source: "Claude Code's session transcript" } : null;
+          }
+        }
+      } catch {
+      }
+      return null;
+    }
+  }
+];
+function detectAgentModel(tool, env = process.env, home = homedir2()) {
+  const generic = /^(?:AI|an? AI)$/i.test(tool.trim());
+  for (const s of MODEL_SOURCES) {
+    if (!generic && !s.matches.test(tool)) continue;
+    const hit = s.detect(env, home);
+    if (hit) return { tool: generic ? s.tool : tool, ...hit };
+  }
+  return null;
+}
+
+// src/commands/me.ts
+function parseModel(args) {
+  const i = args.findIndex((a2) => a2 === "--model" || a2.startsWith("--model="));
+  if (i === -1) return void 0;
+  const a = args[i];
+  const v = a.startsWith("--model=") ? a.slice("--model=".length) : args[i + 1];
+  return v && !v.startsWith("-") ? v : void 0;
+}
+function aiValue(tool, model) {
+  const line = (s) => s.replace(/\s+/g, " ").trim();
+  const t = line(tool.replace(/:/g, " ")) || "AI";
+  const m = model ? line(model) : "";
+  return m ? `${t}:${m}` : t;
+}
 function parseWithAi(args) {
   const i = args.findIndex((a2) => a2 === "--with-ai" || a2.startsWith("--with-ai="));
   if (i === -1) return { withAi: false, tool: "AI" };
@@ -1772,10 +1934,27 @@ function git3(root, args) {
 }
 var HUMAN_ATTEST2 = /^[ \t]*(?:Authored-by-human|Human-authored(?:-by)?)[ \t]*:/im;
 var ASSIST = /^[ \t]*Assisted-by[ \t]*:/im;
+function recordsModel(root) {
+  const p = join6(root, ".madeby", "policy.json");
+  if (!existsSync5(p)) return false;
+  try {
+    return parseDisclosurePolicy(JSON.parse(readFileSync6(p, "utf8"))).recordModel === true;
+  } catch {
+    return false;
+  }
+}
+function resolveAi(root, o) {
+  const tool = o.tool && o.tool.trim() || "AI";
+  const detected = recordsModel(root) ? detectAgentModel(tool, o.env ?? process.env, o.home ?? homedir3()) : null;
+  if (detected) return { value: aiValue(detected.tool, detected.model), tool: detected.tool, model: detected.model, modelSource: detected.source };
+  const model = o.model?.trim() || void 0;
+  return { value: aiValue(tool, model), tool, ...model ? { model, modelSource: "as given (--model)" } : {} };
+}
 var AI_AUTHOR = /^[ \t]*Authored-by-ai[ \t]*:/im;
 function attestAiAuthorship(root, opts = {}) {
-  const tool = opts.tool && opts.tool.trim() || "AI";
-  const base = { ok: false, changed: false, withAi: false, tool, added: [], category: "ai" };
+  const ai = resolveAi(root, opts);
+  const tool = ai.value;
+  const base = { ok: false, changed: false, withAi: false, tool, model: ai.model, modelSource: ai.modelSource, added: [], category: "ai" };
   try {
     execFileSync5("git", ["-C", root, "diff", "--cached", "--quiet"]);
   } catch {
@@ -1796,14 +1975,15 @@ function attestAiAuthorship(root, opts = {}) {
     added.push("Authored-by-ai");
   }
   if (trailers.length > 0) {
-    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", ...trailers]);
+    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
   }
-  return { ok: true, changed: trailers.length > 0, withAi: false, tool, subject, added, category: "ai" };
+  return { ...base, ok: true, changed: trailers.length > 0, subject, added };
 }
 function affirmAuthorship(root, opts = {}) {
   const withAi = opts.withAi ?? false;
-  const tool = opts.tool && opts.tool.trim() || "AI";
-  const base = { ok: false, changed: false, withAi, tool, added: [], category: withAi ? "with_ai" : "human" };
+  const ai = withAi ? resolveAi(root, opts) : void 0;
+  const tool = ai?.value ?? "AI";
+  const base = { ok: false, changed: false, withAi, tool, model: ai?.model, modelSource: ai?.modelSource, added: [], category: withAi ? "with_ai" : "human" };
   let name = "";
   let email = "";
   try {
@@ -1838,20 +2018,26 @@ function affirmAuthorship(root, opts = {}) {
     added.push("Assisted-by");
   }
   if (trailers.length > 0) {
-    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", ...trailers]);
+    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
   }
   const category = hasAssist || added.includes("Assisted-by") ? "with_ai" : "human";
-  return { ok: true, changed: trailers.length > 0, withAi, tool, name, email, subject, added, category };
+  return { ...base, ok: true, changed: trailers.length > 0, name, email, subject, added, category };
 }
 function meCommand(args) {
   const { withAi, tool } = parseWithAi(args);
+  const model = parseModel(args);
+  if (model && !withAi) {
+    console.error("madeby me: --model names the AI's model, so it goes with --with-ai (e.g. madeby me --with-ai Cursor --model claude-sonnet-5).");
+    process.exit(1);
+    return;
+  }
   const root = repoRoot();
   if (!root) {
     console.error("madeby me: not a git repository.");
     process.exit(2);
     return;
   }
-  const r = affirmAuthorship(root, { withAi, tool });
+  const r = affirmAuthorship(root, { withAi, tool, model });
   if (!r.ok) {
     if (r.reason === "no-identity") console.error("madeby me: set your git identity first (git config user.name / user.email).");
     else if (r.reason === "staged-changes") console.error("madeby me: you have staged changes. Commit them first \u2014 `me` affirms HEAD, not your index.");
@@ -1866,7 +2052,8 @@ function meCommand(args) {
     return;
   }
   console.log(
-    withAi ? `madeby me: made by me, with AI \u2014 affirmed human authorship + disclosed AI assistance on HEAD \u2014 "${r.subject}" (Authored-by-human: ${r.name}; Assisted-by: ${r.tool}).` : `madeby me: affirmed human authorship on HEAD \u2014 "${r.subject}" (Authored-by-human: ${r.name}).`
+    withAi ? `madeby me: made by me, with AI \u2014 affirmed human authorship + disclosed AI assistance on HEAD \u2014 "${r.subject}" (Authored-by-human: ${r.name}; Assisted-by: ${r.tool}).${r.modelSource && r.modelSource !== "as given (--model)" ? `
+  model from ${r.modelSource}.` : ""}` : `madeby me: affirmed human authorship on HEAD \u2014 "${r.subject}" (Authored-by-human: ${r.name}).`
   );
 }
 
@@ -1881,7 +2068,8 @@ function aiCommand(args) {
   }
   const makeSample = args.includes("--make-parser-sample");
   const witness = args.includes("--witness");
-  const positional = args.filter((a) => !a.startsWith("--"));
+  const model = parseModel(args);
+  const positional = args.filter((a, i) => !a.startsWith("--") && !(args[i - 1] === "--model"));
   if (makeSample) {
     const s = writeParserSample(root, { transcriptPath: positional[0] });
     if (s.error === "transcript-not-found") {
@@ -1923,7 +2111,7 @@ function aiCommand(args) {
     return;
   }
   const tool = positional[0] || "AI";
-  const r = attestAiAuthorship(root, { tool });
+  const r = attestAiAuthorship(root, { tool, model });
   if (!r.ok) {
     if (r.reason === "staged-changes") {
       console.error("madeby ai: you have staged changes. Commit them first \u2014 `ai` attests HEAD, not your index.");
@@ -1940,7 +2128,8 @@ function aiCommand(args) {
   }
   console.log(
     `madeby ai: attested AI authorship on HEAD \u2014 "${r.subject}" (Authored-by-ai: ${r.tool}).
-  \u2192 asserted tier. For evidence-backed spans from your session log: madeby ai --witness [log].`
+` + (r.modelSource && r.modelSource !== "as given (--model)" ? `  model from ${r.modelSource}.
+` : "") + "  \u2192 asserted tier. For evidence-backed spans from your session log: madeby ai --witness [log]."
   );
 }
 
@@ -1992,17 +2181,18 @@ function whoCommand(args) {
 }
 
 // src/commands/coverage.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
+import { join as join7 } from "node:path";
 function policyIsRequired(root) {
-  const p = join5(root, ".madeby", "policy.json");
-  if (!existsSync4(p)) return false;
+  const p = join7(root, ".madeby", "policy.json");
+  if (!existsSync6(p)) return false;
   try {
-    return parseDisclosurePolicy(JSON.parse(readFileSync6(p, "utf8"))).mode === "required";
+    return parseDisclosurePolicy(JSON.parse(readFileSync7(p, "utf8"))).mode === "required";
   } catch {
     return false;
   }
 }
+var AGENT_ROWS = 8;
 var pct = (n, d) => d > 0 ? Math.round(n / d * 100) : 0;
 var bar = (p) => "\u2588".repeat(Math.round(p / 5)) + "\u2591".repeat(20 - Math.round(p / 5));
 function render(r, required) {
@@ -2023,6 +2213,16 @@ function render(r, required) {
   of the ${r.known} known:  ${parts.join(" \xB7 ")}`);
     console.log(`  trust:  asserted ${pct(r.byTier.asserted, r.known)}% \xB7 verified ${pct(r.byTier.verified, r.known)}%  \u2014 self-reported; sign commits to verify`);
   }
+  const withAi = r.byCategory.with_ai + r.byCategory.ai;
+  if (r.byAgent.length > 0) {
+    console.log(`
+  agents & models named in the ${withAi} AI commits:`);
+    const width = Math.max(...r.byAgent.slice(0, AGENT_ROWS).map((a) => a.name.length));
+    for (const a of r.byAgent.slice(0, AGENT_ROWS)) {
+      console.log(`    ${a.name.padEnd(width)}  ${String(a.commits).padStart(4)}  ${String(pct(a.commits, withAi)).padStart(3)}%`);
+    }
+    if (r.byAgent.length > AGENT_ROWS) console.log(`    \u2026 and ${r.byAgent.length - AGENT_ROWS} more (--json for all)`);
+  }
   if (r.unknown > 0) {
     console.log(
       required ? `
@@ -2049,8 +2249,8 @@ function coverageCommand(args) {
 }
 
 // src/init-repo.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join8 } from "node:path";
 var ACO_VERSION = 1;
 var ACO_OPEN = `<!-- madeby:aco v${ACO_VERSION} -->`;
 var ACO_CLOSE = `<!-- /madeby:aco -->`;
@@ -2067,14 +2267,16 @@ After you commit, run the command for the honest category (no install, no setup)
 
 Disclose per commit, honestly. Undisclosed content stays *unknown*, never guessed.
 `;
-var ACO_BLOCK = `${ACO_OPEN}
-${ACO_BODY}${ACO_CLOSE}
+var MODEL_LINE = `
+**This repo also records the model.** Name your tool as usual \u2014 madeby reads the model from the
+tool's own record of the session where it can (Cursor, Copilot CLI, Claude Code), e.g.
+\`npx madeby@latest me --with-ai Cursor\` writes \`Assisted-by: Cursor:<model>\`. Elsewhere add
+\`--model <version>\` with the exact model you are running as. If you don't know it, leave it off \u2014
+never guess.
+`;
+var acoBlock = (recordModel) => `${ACO_OPEN}
+${ACO_BODY}${recordModel ? MODEL_LINE : ""}${ACO_CLOSE}
 `;
-var AGENTS_CONVENTION = `# AGENTS.md
-
-${ACO_BLOCK}`;
-var ACO_SECTION = `
-${ACO_BLOCK}`;
 function findAcoBlock(content) {
   const m = ACO_OPEN_RE.exec(content);
   if (!m) return null;
@@ -2097,11 +2299,11 @@ function acoStatus(content) {
   if (loc.version > ACO_VERSION) return "newer";
   return "current";
 }
-function replaceAcoBlock(content, loc) {
-  return content.slice(0, loc.start) + ACO_BLOCK + content.slice(loc.end);
+function replaceAcoBlock(content, loc, block) {
+  return content.slice(0, loc.start) + block + content.slice(loc.end);
 }
 function writeIfAbsent(abs, rel, content, created, skipped) {
-  if (existsSync5(abs)) {
+  if (existsSync7(abs)) {
     skipped.push(rel);
     return;
   }
@@ -2109,47 +2311,60 @@ function writeIfAbsent(abs, rel, content, created, skipped) {
   writeFileSync2(abs, content);
   created.push(rel);
 }
-function ensurePolicy(abs, rel, mode, res) {
-  if (!existsSync5(abs)) {
+function ensurePolicy(abs, rel, want, res) {
+  if (!existsSync7(abs)) {
     mkdirSync2(dirname2(abs), { recursive: true });
-    writeFileSync2(abs, JSON.stringify({ version: 0, mode }, null, 2) + "\n");
+    const fresh = { version: 0, mode: want.mode, ...want.recordModel ? { recordModel: true } : {} };
+    writeFileSync2(abs, JSON.stringify(fresh, null, 2) + "\n");
     res.created.push(rel);
-    return { mode, malformed: false };
+    return { mode: want.mode, recordModel: want.recordModel, malformed: false };
   }
   let raw;
   try {
-    raw = JSON.parse(readFileSync7(abs, "utf8"));
+    raw = JSON.parse(readFileSync8(abs, "utf8"));
   } catch {
     res.skipped.push(rel);
-    return { mode: "advisory", malformed: true };
+    return { mode: "advisory", recordModel: false, malformed: true };
   }
   const isObject = !!raw && typeof raw === "object" && !Array.isArray(raw);
-  const current = parseDisclosurePolicy(raw).mode;
-  if (mode === "required" && current !== "required" && isObject) {
-    writeFileSync2(abs, JSON.stringify({ ...raw, mode: "required" }, null, 2) + "\n");
-    res.raised.push(rel);
-    return { mode: "required", malformed: false };
+  const current = parseDisclosurePolicy(raw);
+  const raise = want.mode === "required" && current.mode !== "required" && isObject;
+  const modelOn = want.recordModel && !current.recordModel && isObject;
+  if (raise || modelOn) {
+    const next = { ...raw, ...raise ? { mode: "required" } : {}, ...modelOn ? { recordModel: true } : {} };
+    writeFileSync2(abs, JSON.stringify(next, null, 2) + "\n");
+    if (raise) res.raised.push(rel);
+    if (modelOn) res.modelOn.push(rel);
+  } else {
+    res.skipped.push(rel);
   }
-  res.skipped.push(rel);
-  return { mode: current, malformed: !isObject };
+  return { mode: raise ? "required" : current.mode, recordModel: modelOn || current.recordModel === true, malformed: !isObject };
 }
 function ensureAco(abs, rel, res, opts) {
-  if (!existsSync5(abs)) {
+  const block = acoBlock(opts.recordModel);
+  if (!existsSync7(abs)) {
     if (!opts.createIfAbsent) return;
     mkdirSync2(dirname2(abs), { recursive: true });
-    writeFileSync2(abs, AGENTS_CONVENTION);
+    writeFileSync2(abs, `# AGENTS.md
+
+${block}`);
     res.created.push(rel);
     return;
   }
-  const content = readFileSync7(abs, "utf8");
+  const content = readFileSync8(abs, "utf8");
   const status = acoStatus(content);
+  const loc = findAcoBlock(content);
   if (status === "absent") {
     const sep = content.endsWith("\n") ? "" : "\n";
-    writeFileSync2(abs, content + sep + ACO_SECTION);
+    writeFileSync2(abs, content + sep + `
+${block}`);
     res.merged.push(rel);
+  } else if (status === "current" && opts.modelRequested && loc && content.slice(loc.start, loc.end) !== block) {
+    writeFileSync2(abs, replaceAcoBlock(content, loc, block));
+    res.updated.push(rel);
   } else if (status === "outdated") {
     if (opts.update) {
-      writeFileSync2(abs, replaceAcoBlock(content, findAcoBlock(content)));
+      writeFileSync2(abs, replaceAcoBlock(content, loc, block));
       res.updated.push(rel);
     } else {
       res.outdated.push(rel);
@@ -2168,17 +2383,23 @@ function initRepo(root, opts = {}) {
   const updated = [];
   const outdated = [];
   const raised = [];
-  const res = { created, skipped, merged, updated, outdated, raised };
-  const policy = ensurePolicy(join6(root, ".madeby", "policy.json"), ".madeby/policy.json", mode, res);
-  ensureAco(join6(root, "AGENTS.md"), "AGENTS.md", res, { createIfAbsent: true, update });
-  ensureAco(join6(root, "CLAUDE.md"), "CLAUDE.md", res, { createIfAbsent: false, update });
+  const modelOn = [];
+  const res = { created, skipped, merged, updated, outdated, raised, modelOn };
+  const modelRequested = opts.recordModel ?? false;
+  const policy = ensurePolicy(join8(root, ".madeby", "policy.json"), ".madeby/policy.json", { mode, recordModel: modelRequested }, res);
+  const aco = { update, recordModel: policy.recordModel, modelRequested };
+  ensureAco(join8(root, "AGENTS.md"), "AGENTS.md", res, { createIfAbsent: true, ...aco });
+  ensureAco(join8(root, "CLAUDE.md"), "CLAUDE.md", res, { createIfAbsent: false, ...aco });
   if (host === "github") {
-    writeIfAbsent(join6(root, ".github", "workflows", "disclosure.yml"), ".github/workflows/disclosure.yml", GH_WORKFLOW, created, skipped);
+    writeIfAbsent(join8(root, ".github", "workflows", "disclosure.yml"), ".github/workflows/disclosure.yml", GH_WORKFLOW, created, skipped);
   }
   const nextSteps = ["Commit the created files."];
   if (raised.length > 0) {
     nextSteps.push('Raised .madeby/policy.json to "required" \u2014 undisclosed commits now fail the check. To make it block merges, also mark the check required on the protected branch (see madeby://guide/enforce).');
   }
+  if (modelOn.length > 0 || modelRequested && created.includes(".madeby/policy.json")) {
+    nextSteps.push("This repo now asks AI disclosures to name the model version (recordModel in .madeby/policy.json; the AGENTS.md rule says how: --model <version>). `madeby coverage` lists each agent \xB7 model pairing. It never changes the gate.");
+  }
   if (policy.malformed) {
     nextSteps.push('.madeby/policy.json is not a valid policy, so the check treats it as advisory. It was left untouched \u2014 fix it (e.g. { "version": 0, "mode": "required" }) to enforce.');
   }
@@ -2204,7 +2425,7 @@ function initRepo(root, opts = {}) {
   }
   nextSteps.push("Contributors disclose origin with a Co-Authored-By / Generated-by trailer (AI), an Authored-by-human trailer ('madeby me'), an Authored-by-ai trailer ('madeby ai' \u2014 AI authored, committer accountable), a DCO Signed-off-by, or a signed commit. Evidence upgrade: 'madeby ai --witness' records 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, merged, updated, outdated, raised, policyMode: policy.mode, host, nextSteps };
+  return { created, skipped, merged, updated, outdated, raised, modelOn, policyMode: policy.mode, recordModel: policy.recordModel, host, nextSteps };
 }
 var GH_WORKFLOW = `name: Disclosure
 on: pull_request
@@ -2228,17 +2449,19 @@ function initCommand(args) {
   }
   const mode = args.includes("--required") ? "required" : "advisory";
   const update = args.includes("--update");
+  const recordModel = args.includes("--record-model");
   const hostIdx = args.indexOf("--host");
   const host = hostIdx >= 0 ? args[hostIdx + 1] : void 0;
-  const r = initRepo(root, { mode, host, update });
+  const r = initRepo(root, { mode, host, update, recordModel });
   for (const f of r.created) console.log(`  + ${f}`);
   for (const f of r.merged) console.log(`  ~ ${f} (merged in the ACO rule)`);
   for (const f of r.updated) console.log(`  \u2191 ${f} (ACO convention refreshed to the current version)`);
   for (const f of r.raised) console.log(`  \u2191 ${f} (mode raised to required)`);
+  for (const f of r.modelOn) console.log(`  \u2191 ${f} (now records the model version)`);
   for (const f of r.outdated) console.log(`  ! ${f} (ACO convention OUTDATED \u2014 run 'madeby init --update')`);
   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}`);
+madeby init \u2014 policy: ${r.policyMode}${r.recordModel ? " + records model" : ""}, host: ${r.host}`);
   console.log("Next:");
   for (const s of r.nextSteps) console.log(`  - ${s}`);
 }
@@ -2247,7 +2470,7 @@ madeby init \u2014 policy: ${r.policyMode}, host: ${r.host}`);
 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.3.7" };
+var SERVER_INFO = { name: "madeby", version: "0.3.9" };
 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();
@@ -2269,10 +2492,16 @@ var TOOLS = [
         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" },
-        update: { type: "boolean", description: "refresh an outdated ACO convention block in place (drift update); default false (report only)" }
+        update: { type: "boolean", description: "refresh an outdated ACO convention block in place (drift update); default false (report only)" },
+        record_model: { type: "boolean", description: "opt in: ask AI disclosures to also name the model version (tool:model) \u2014 policy recordModel + an AGENTS.md line. Never turned off by init; default false." }
       }
     },
-    handler: (args) => initRepo(rootFor(args.path), { mode: args.mode, host: args.host, update: args.update })
+    handler: (args) => initRepo(rootFor(args.path), {
+      mode: args.mode,
+      host: args.host,
+      update: args.update,
+      recordModel: args.record_model
+    })
   },
   {
     name: "check",
@@ -2282,7 +2511,7 @@ var TOOLS = [
   },
   {
     name: "coverage",
-    description: "Authorship coverage scoreboard for a repo \u2014 the honest estimate of how much of the code's authorship is ON THE RECORD (known) vs undisclosed (unknown \u2014 origin unknown, NEVER guessed), the human/with_ai/ai mix OF THE KNOWN (never of the whole repo), and the asserted-vs-verified trust split. Disclosure, not detection; the report is a labeled estimate (counts only \u2014 derive percents at the edge). Use it to show a maintainer their provenance picture and motivate requiring disclosure.",
+    description: "Authorship coverage scoreboard for a repo \u2014 the honest estimate of how much of the code's authorship is ON THE RECORD (known) vs undisclosed (unknown \u2014 origin unknown, NEVER guessed), the human/with_ai/ai mix OF THE KNOWN (never of the whole repo), the asserted-vs-verified trust split, and byAgent: the agents and model versions named in the AI commits, exactly as disclosed (a commit naming a tool and its model counts under both). Disclosure, not detection; the report is a labeled estimate (counts only \u2014 derive percents at the edge). Use it to show a maintainer their provenance picture and motivate requiring disclosure.",
     inputSchema: repoInput,
     handler: (args) => repoCoverage(rootFor(args.path), { range: args.range })
   },
@@ -2314,15 +2543,18 @@ var TOOLS = [
         path: { type: "string", description: "path to the repo (default: the server's working directory)" },
         category: { enum: ["human", "with_ai", "ai"], description: "the honest authorship category (see the description). Defaults from with_ai if omitted." },
         with_ai: { type: "boolean", description: "legacy shorthand: true \u21D2 category with_ai, false \u21D2 human. Prefer `category`." },
-        tool: { type: "string", description: "the AI tool to name (Assisted-by for with_ai, Authored-by-ai for ai). Default: AI." }
+        tool: { type: "string", description: "the AI tool to name (Assisted-by for with_ai, Authored-by-ai for ai). Default: AI." },
+        model: { type: "string", description: "the model version you are running as, e.g. claude-sonnet-5 \u2014 written as tool:model. Give it when the repo's AGENTS.md asks; omit it rather than guess." }
       }
     },
     handler: (args) => {
       const root = rootFor(args.path);
       const tool = args.tool;
+      const model = args.model;
       const category = args.category;
-      if (category === "ai") return attestAiAuthorship(root, { tool });
-      return affirmAuthorship(root, { withAi: category === "with_ai" || args.with_ai === true, tool });
+      if (category === "ai") return attestAiAuthorship(root, { tool, model });
+      const withAi = category === "with_ai" || args.with_ai === true;
+      return affirmAuthorship(root, { withAi, tool, model: withAi ? model : void 0 });
     }
   },
   {
@@ -2544,7 +2776,8 @@ function help() {
 Usage:
   madeby init                    Set MadeBy up: write .madeby/policy.json + the ACO AGENTS.md convention
                                  + the CI disclosure check. --update refreshes an outdated ACO block in
-                                 place; --required to enforce now; --host azure-devops for Azure Pipelines.
+                                 place; --required to enforce now; --host azure-devops for Azure Pipelines;
+                                 --record-model to also ask agents for the model version (opt-in).
   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.
@@ -2559,6 +2792,7 @@ Usage:
                                  trailer \u2014 the symmetric human claim to \`ai\`).
   madeby me --with-ai [tool]     Made by me, with AI: also disclose AI assistance (Assisted-by:
                                  <tool>, default "AI") \u2014 the assisted middle state, classified with_ai.
+                                 --model <version> names the model too (Assisted-by: <tool>:<version>).
   madeby mcp                     Run the MCP server (stdio) \u2014 the tools, agent-callable.
   madeby help                    Show this help.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madeby",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "mcpName": "io.github.MadeByFYI/madeby",
   "description": "Disclose AI authorship of code. `npx madeby ai` adds an Authored-by-ai git trailer; AI coding agents disclose per the ACO standard (human/with_ai/ai) from an AGENTS.md convention. Disclosure, not detection. Gate PRs with `madeby check`.",
   "license": "MIT",