madeby 0.3.11 → 0.3.13

package/README.md

@@ -67,22 +67,30 @@ sides of it, and `init`/`check` are the setup and the gate.
 ### `madeby check` — the disclosure gate
 
 Reads `.madeby/policy.json`, recognizes each commit's disclosure signals, and reports coverage.
-A commit **discloses its origin** if it carries any of:
+A commit **discloses who wrote it** if it carries any of:
 
 - an **AI-authorship trailer** — `Co-Authored-By:` / `Generated-by:` / `Assisted-by:` naming an AI
-  tool (Claude Code, Copilot, Cursor, aider, … already emit these);
+  tool (Claude Code, Copilot, Cursor, aider, … already emit these), or `Authored-by-ai:`;
 - an **affirmative human-authorship trailer** — `Authored-by-human: <you>` (see below);
-- a **DCO `Signed-off-by:`** line;
-- a **commit signature**;
 - a **`madeby ai`** attestation (your own AI session's witnessed spans).
 
-Exit codes: **0** = pass · **1** = a `required` policy failed on an undisclosed commit · **2** = not
-a git repository. Under `advisory` it only reports (always exit 0) — so it's safe to add to CI
+A **DCO `Signed-off-by:`** line or a **commit signature** is recognized too, but on its own it says
+who is accountable for the commit, not who wrote it, so it counts only if the policy's `accept`
+lists it. `check` reports commits that carry only one of those apart from those that carry nothing.
+
+Exit codes: **0** = pass · **1** = a `required` policy failed on an undisclosed commit, or couldn't
+read the history (below) · **2** = not a git repository. Under `advisory` it only reports (always exit 0) — so it's safe to add to CI
 before you decide to enforce anything.
 
 In CI, omit `<range>` — on a pull-request build `madeby check` **auto-scopes to the PR's own
-commits** from the CI environment (GitHub today; other hosts via their adapter). Pass an explicit
-`<range>` to override.
+commits** from the CI environment (GitHub, Azure DevOps and GitLab). Pass an explicit `<range>` to
+override.
+
+**The history has to be there.** On a shallow clone, when a range endpoint isn't in the clone (a
+target branch that was never fetched), or on a pull-request build whose range can't be read, `check`
+says so: under `required` it fails rather than score whatever happens to be present, and under
+`advisory` it prints a warning. Check out the full history (`fetch-depth: 0` on GitHub,
+`fetchDepth: 0` on Azure Pipelines); the files `madeby init` writes already do.
 
 ### `madeby coverage` — the authorship scoreboard
 
@@ -92,6 +100,7 @@ history's authorship is **on the record** — no policy, no config:
 ```sh
 madeby coverage                 # scores recent history
 madeby coverage origin/main..HEAD   # or a range
+madeby coverage --by author     # the same, one row per commit author
 ```
 
 ```
@@ -115,7 +124,8 @@ inferred as human — disclosure, not detection. The human/with_ai/ai mix is rep
 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
+sum past 100%. `--by author` shows one row per commit author (grouped by email): how many of their
+commits disclose, and the mix — who discloses and who never does. `--json` (which includes `byAuthor`) 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
@@ -151,8 +161,8 @@ Two modes, nothing more:
 
 - `advisory` — report coverage on each run; never fails. **The default** (and what you get with no file).
 - `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 `"accept": ["dco-signoff", "ai-trailer", …]` — set what satisfies the policy
+  (omit ⇒ any authorship disclosure counts; a DCO sign-off or signature alone counts only if listed).
 - 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
@@ -166,7 +176,8 @@ Two modes, nothing more:
 (There's no "off" — that's just not running the check. Advisory is the floor.)
 
 Fail-safe by design: a missing or malformed policy degrades to `advisory`. `madeby` never blocks a PR
-on its own error, and never invents a stricter gate than the maintainer wrote.
+on its own error, and never invents a stricter gate than the maintainer wrote. It never passes a
+`required` check it couldn't actually run, either: missing history fails it (see `check` above).
 
 ## Use it as a PR check
 

package/dist/madeby.mjs

@@ -16,6 +16,26 @@ var parseMeta = (rec) => {
     message: parts.slice(4).join(FIELD).trimEnd()
   };
 };
+function historyProblem(repoPath, range) {
+  const git4 = (...args) => {
+    try {
+      return execFileSync("git", ["-C", repoPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      return null;
+    }
+  };
+  if (git4("rev-parse", "--is-shallow-repository") === "true") {
+    return "this is a shallow clone, so the history may be cut short. Fetch the full history (Azure Pipelines: fetchDepth: 0 on the checkout step; GitHub Actions: fetch-depth: 0).";
+  }
+  if (range) {
+    for (const end of range.split(/\.{2,3}/).filter(Boolean)) {
+      if (git4("rev-parse", "--verify", "--quiet", `${end}^{commit}`) === null) {
+        return `the range ${range} can't be read: ${end} isn't in this clone. Fetch it (full history), or pass a range that exists.`;
+      }
+    }
+  }
+  return null;
+}
 function readGitLog(repoPath, limit, range) {
   try {
     const args = [
@@ -873,6 +893,27 @@ var conformance_v0_default = {
 var CONFORMANCE_VERSION = conformance_v0_default.version;
 
 // ../core/src/disclosure.ts
+var DISCLOSURE_KINDS = {
+  "ai-trailer": { label: "AI-authorship trailer", nativeness: "external", ceiling: "asserted", parser: "recognized", authorship: true },
+  // The AFFIRMATIVE human-authorship claim — the symmetric counterpart of the AI trailer, NOT a
+  // separate mechanism: same recognizer, same ladder. A bare trailer is `asserted` (identical to the
+  // AI trailer); sign it → verified, swear it → sworn — the signature authenticates WHO is claiming
+  // (invariant #10), equally for human or AI disclosure. The one genuine asymmetry is EVIDENCE vs.
+  // tier: AI authorship can leave a re-checkable ARTIFACT (a session log matched to the code,
+  // `prove`); human authorship is the author's firsthand TESTIMONY — real, but not independently
+  // re-checkable, so to a third party it lands as an attestation (asserted → signed → sworn testimony).
+  "human-attestation": { label: "human-authorship attestation", nativeness: "madeby", ceiling: "asserted", parser: "recognized", authorship: true },
+  "dco-signoff": { label: "DCO Signed-off-by", nativeness: "external", ceiling: "asserted", parser: "recognized", authorship: false },
+  "commit-signature": { label: "commit signature", nativeness: "external", ceiling: "verified", parser: "recognized", authorship: false },
+  "ai-tool-config": { label: "committed AI-tool config", nativeness: "external", ceiling: "asserted", parser: "recognized", authorship: false },
+  "spdx-license": { label: "SPDX license metadata", nativeness: "external", ceiling: "asserted", parser: "recognized", authorship: false },
+  "spdx-ai-disclosure": { label: "SPDX-AI-Disclosure tag", nativeness: "external", ceiling: "asserted", parser: "recognized", authorship: true },
+  reuse: { label: "REUSE licensing", nativeness: "external", ceiling: "asserted", parser: "planned", authorship: false },
+  "in-toto": { label: "in-toto attestation", nativeness: "external", ceiling: "verified", parser: "planned", authorship: false },
+  slsa: { label: "SLSA provenance", nativeness: "external", ceiling: "verified", parser: "planned", authorship: false },
+  "madeby-manifest": { label: "MadeBy witnessed manifest", nativeness: "madeby", ceiling: "asserted", parser: "recognized", authorship: true },
+  "madeby-declaration": { label: "MadeBy self-hosted declaration", nativeness: "madeby", ceiling: "sworn", parser: "recognized", authorship: true }
+};
 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) {
@@ -947,18 +988,22 @@ function parseDisclosurePolicy(input) {
     ...o.recordModel === true ? { recordModel: true } : {}
   };
 }
+function acceptsKind(policy, kind) {
+  return policy.accept ? policy.accept.includes(kind) : DISCLOSURE_KINDS[kind]?.authorship === true;
+}
 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 satisfiedBy = c.kinds.filter((k) => acceptsKind(policy, k));
+    const notAccepted = c.kinds.filter((k) => !acceptsKind(policy, k));
+    return { ref: c.ref, compliant: satisfiedBy.length > 0, satisfiedBy, notAccepted };
   });
   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.` : "");
+  const wanted = accept ? accept.join(", ") : "any authorship disclosure";
+  const otherOnly = nonCompliant.filter((v) => v.notAccepted.length > 0).length;
+  const summary = `${compliant}/${verdicts.length} commits disclose origin (${policy.mode}; accepts: ${wanted}).` + (nonCompliant.length ? ` ${nonCompliant.length} undisclosed` + (otherOnly ? ` (${otherOnly} carry only a sign-off or signature, which don't say who wrote the code).` : ".") : "");
   return { mode: policy.mode, pass, total: verdicts.length, compliant, nonCompliant, summary };
 }
 
@@ -977,6 +1022,10 @@ function detectCiRange(env = process.env) {
   }
   return null;
 }
+function detectCiPullRequest(env = process.env) {
+  for (const adapter of registry.values()) if (adapter.ciPullRequest?.(env)) return 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;
@@ -996,8 +1045,11 @@ var githubAdapter = {
   // 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.
+  // (the quickstart's `fetch-depth: 0`). Any absence/parse failure → null (`check` reports the
+  // unreadable PR build, see ciPullRequest); never throws.
+  ciPullRequest(env) {
+    return env.GITHUB_EVENT_NAME === "pull_request" || env.GITHUB_EVENT_NAME === "pull_request_target";
+  },
   ciRange(env) {
     const event = env.GITHUB_EVENT_NAME;
     if (event !== "pull_request" && event !== "pull_request_target") return null;
@@ -1266,11 +1318,18 @@ function repoCoverage(root, opts = {}) {
   const byTier = { asserted: 0, verified: 0 };
   let known = 0;
   const agents = /* @__PURE__ */ new Map();
+  const authors = /* @__PURE__ */ new Map();
   for (const c of commits) {
     const kinds = commitDisclosureKinds({ message: c.message, signed: c.signed });
     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;
+    const email = (c.authorEmail ?? "").toLowerCase();
+    const author = authors.get(email) ?? { name: c.authorName ?? email, email, commits: 0, known: 0, byCategory: { human: 0, with_ai: 0, ai: 0, bot: 0 } };
+    author.commits += 1;
+    authors.set(email, author);
     if (category === "unknown") continue;
+    author.known += 1;
+    author.byCategory[category] += 1;
     known += 1;
     byCategory[category] += 1;
     if (c.signed) byTier.verified += 1;
@@ -1298,7 +1357,8 @@ function repoCoverage(root, opts = {}) {
     unknown: commits.length - known,
     byCategory,
     byTier,
-    byAgent: [...agents.values()].sort((a, b) => b.commits - a.commits || a.name.localeCompare(b.name))
+    byAgent: [...agents.values()].sort((a, b) => b.commits - a.commits || a.name.localeCompare(b.name)),
+    byAuthor: [...authors.values()].sort((a, b) => b.commits - a.commits || a.email.localeCompare(b.email))
   };
 }
 
@@ -1745,7 +1805,11 @@ var azureAdapter = {
   // 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).
+  // fetchDepth: 0 so that ref + the PR history are present. Any absence → null; `check` then reports
+  // the PR build whose range it couldn't read (ciPullRequest) instead of passing on recent history.
+  ciPullRequest(env) {
+    return env.BUILD_REASON === "PullRequest";
+  },
   ciRange(env) {
     if (env.BUILD_REASON !== "PullRequest") return null;
     const targetRef = env.SYSTEM_PULLREQUEST_TARGETBRANCH;
@@ -1771,7 +1835,10 @@ var gitlabAdapter = {
   },
   // 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).
+  // (Needs the MR pipeline / a deep-enough fetch for those SHAs.) Any absence → null (reported by `check`).
+  ciPullRequest(env) {
+    return env.CI_PIPELINE_SOURCE === "merge_request_event";
+  },
   ciRange(env) {
     if (env.CI_PIPELINE_SOURCE !== "merge_request_event") return null;
     const base = env.CI_MERGE_REQUEST_DIFF_BASE_SHA;
@@ -1809,9 +1876,23 @@ function checkCommand(args) {
   }
   const { range, autoHost } = resolveRange(explicit);
   const result = evaluateRepoDisclosure(root, { range });
+  const prHost = explicit || autoHost ? null : detectCiPullRequest();
+  const problem = prHost ? `this is a ${prHost} pull-request build, but its commit range couldn't be read from the CI environment. Pass the range explicitly: madeby check <base>..<head>` : historyProblem(root, range);
+  const blocked = problem !== null && result.mode === "required";
+  const pass = result.pass && !blocked;
   if (json) {
-    console.log(JSON.stringify({ range: range ?? null, autoHost: autoHost ?? null, ...result }, null, 2));
-    process.exit(result.pass ? 0 : 1);
+    console.log(JSON.stringify({ range: range ?? null, autoHost: autoHost ?? null, ...result, pass, ...problem ? { historyProblem: problem } : {} }, null, 2));
+    process.exit(pass ? 0 : 1);
+    return;
+  }
+  if (problem) {
+    const banner = blocked ? "FAILED \u2014 can't check this history" : "WARNING \u2014 this result may be wrong";
+    console.error(`
+madeby check: ${banner}: ${problem}
+`);
+  }
+  if (blocked) {
+    process.exit(1);
     return;
   }
   if (result.warning) console.warn(`madeby check: ${result.warning}`);
@@ -1826,7 +1907,7 @@ Undisclosed commits (${result.undisclosed.length}):`);
     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.)`
+To disclose who wrote it: 'madeby ai <tool>' (an AI wrote it), 'madeby me --with-ai <tool>' (you, with AI), or 'madeby me' (you alone); a Co-Authored-By trailer naming an AI tool also counts. A DCO sign-off or a signature alone doesn't say who wrote the code. (Disclosure, not a ban \u2014 what this project requires is set in .madeby/policy.json.)`
     );
   }
   process.exit(result.pass ? 0 : 1);
@@ -2250,6 +2331,22 @@ function policyIsRequired(root) {
 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 renderByAuthor(r) {
+  console.log(`authorship coverage by author \u2014 ${r.scope}  (estimate \xB7 disclosure, not detection)`);
+  if (r.byAuthor.length === 0) {
+    console.log("  (no commits to score)");
+    return;
+  }
+  const label = (a) => a.name && a.name !== a.email ? `${a.name} <${a.email}>` : a.email;
+  const width = Math.max(...r.byAuthor.map((a) => label(a).length));
+  console.log(`  ${"author".padEnd(width)}  commits  disclosed   human  with_ai     ai`);
+  for (const a of r.byAuthor) {
+    const k = a.byCategory;
+    console.log(
+      `  ${label(a).padEnd(width)}  ${String(a.commits).padStart(7)}  ${`${a.known} \xB7 ${pct(a.known, a.commits)}%`.padStart(9)}  ${String(k.human).padStart(6)}  ${String(k.with_ai).padStart(7)}  ${String(k.ai + k.bot).padStart(5)}`
+    );
+  }
+}
 function render(r, required) {
   const knownPct = pct(r.known, r.total);
   const unknownPct = 100 - knownPct;
@@ -2288,7 +2385,14 @@ function render(r, required) {
 }
 function coverageCommand(args) {
   const json = args.includes("--json");
-  const range = args.find((a) => !a.startsWith("--"));
+  const byAt = args.findIndex((a) => a === "--by" || a.startsWith("--by="));
+  const by = byAt < 0 ? void 0 : args[byAt].includes("=") ? args[byAt].split("=")[1] : args[byAt + 1];
+  if (by !== void 0 && by !== "author") {
+    console.error("madeby coverage: --by takes 'author'.");
+    process.exit(2);
+    return;
+  }
+  const range = args.find((a, i) => !a.startsWith("--") && !(byAt >= 0 && i === byAt + 1 && !args[byAt].includes("=")));
   const root = repoRoot();
   if (!root) {
     console.error("madeby coverage: not a git repository.");
@@ -2300,12 +2404,18 @@ function coverageCommand(args) {
     console.log(JSON.stringify(r, null, 2));
     return;
   }
-  render(r, policyIsRequired(root));
+  if (by === "author") renderByAuthor(r);
+  else render(r, policyIsRequired(root));
 }
 
 // src/init-repo.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join8 } from "node:path";
+
+// src/version.ts
+var VERSION = "0.3.13";
+
+// src/init-repo.ts
 var ACO_VERSION = 2;
 var ACO_OPEN = `<!-- madeby:aco v${ACO_VERSION} -->`;
 var ACO_CLOSE = `<!-- /madeby:aco -->`;
@@ -2451,6 +2561,8 @@ function initRepo(root, opts = {}) {
   ensureAco(join8(root, "CLAUDE.md"), "CLAUDE.md", res, { createIfAbsent: false, ...aco });
   if (host === "github") {
     writeIfAbsent(join8(root, ".github", "workflows", "disclosure.yml"), ".github/workflows/disclosure.yml", GH_WORKFLOW, created, skipped);
+  } else if (host === "azure-devops") {
+    writeIfAbsent(join8(root, ".madeby", "azure-pipelines.yml"), ".madeby/azure-pipelines.yml", AZURE_PIPELINE, created, skipped);
   }
   const nextSteps = ["Commit the created files."];
   if (raised.length > 0) {
@@ -2475,19 +2587,21 @@ function initRepo(root, opts = {}) {
     nextSteps.push(`${outdated.join(" + ")} carries an OUTDATED ACO convention \u2014 run 'madeby init --update' to refresh it in place (only the ACO block changes).`);
   }
   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.");
+    nextSteps.push("In Azure DevOps, create a pipeline from .madeby/azure-pipelines.yml (a PR-only pipeline: no credentials kept, madeby pinned) and add it to the protected branch as a build-validation policy.");
   } else if (host !== "github") {
     nextSteps.push(`Add a CI step that runs 'npx madeby check' on pull requests for ${host}.`);
   }
   if (policy.mode !== "required") {
     nextSteps.push(`When ready to enforce: run 'madeby init --required' (or set "mode": "required" in .madeby/policy.json), 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'), 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("Contributors disclose origin with a Co-Authored-By / Generated-by trailer (AI), an Authored-by-human trailer ('madeby me'), or an Authored-by-ai trailer ('madeby ai' \u2014 AI authored, committer accountable). A DCO Signed-off-by or a signed commit alone doesn't say who wrote the code, so it counts only if the policy's 'accept' lists it. 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, modelOn, policyMode: policy.mode, recordModel: policy.recordModel, host, nextSteps };
 }
 var GH_WORKFLOW = `name: Disclosure
 on: pull_request
+permissions:
+  contents: read
 jobs:
   madeby:
     runs-on: ubuntu-latest
@@ -2495,7 +2609,27 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          persist-credentials: false
       - uses: MadeByFYI/MadeBy/packages/action@v0.2.0
+        with:
+          version: "${VERSION}"
+`;
+var AZURE_PIPELINE = `# MadeBy disclosure check. Run it as a build-validation policy on the protected branch: Azure
+# DevOps runs it for each pull request. It reads the git history only, so it keeps no credentials.
+trigger: none
+
+pool:
+  vmImage: ubuntu-latest
+
+steps:
+  - checkout: self
+    fetchDepth: 0 # the PR's commits and the target branch, so the range can be read
+    persistCredentials: false
+  - task: NodeTool@0
+    inputs:
+      versionSpec: "20.x"
+  - script: npx --yes madeby@${VERSION} check
+    displayName: MadeBy disclosure check
 `;
 
 // src/commands/init.ts
@@ -2529,7 +2663,7 @@ madeby init \u2014 policy: ${r.policyMode}${r.recordModel ? " + records model" :
 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.11" };
+var SERVER_INFO = { name: "madeby", version: VERSION };
 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();
@@ -2570,7 +2704,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), 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.",
+    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, 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), and byAuthor: the same picture per commit author (by email), to see who discloses and who doesn't. 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 })
   },
@@ -2640,14 +2774,20 @@ 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 (\`mode: "required"\` only ever raises an
-   advisory policy to required). 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.
+1. **Assess** \u2014 call \`coverage\` for the scoreboard (known vs unknown, the human / with_ai / ai mix, and
+   the agents and model versions named), \`check\` for the gate's verdict, or \`who\` with no path for a
+   repo-wide map.
+2. **Set up** \u2014 call \`init\`: it writes \`.madeby/policy.json\` (advisory), the AGENTS.md disclosure rule,
+   and the CI disclosure check (\`host: "azure-devops"\` for Azure Pipelines). Idempotent; it never
+   clobbers an existing policy or workflow (\`mode: "required"\` only ever raises an advisory policy to
+   required). Add \`record_model: true\` if the repo should also record which model version did the work
+   (opt-in; a project's choice). Then commit the created files.
+3. **Disclose going forward** \u2014 contributors disclose origin with an \`Authored-by-ai\` trailer (an AI
+   wrote it; \`madeby ai\` adds it), \`Authored-by-human\` plus \`Assisted-by\` (a human wrote it with AI;
+   \`madeby me --with-ai\`), \`Authored-by-human\` alone (\`madeby me\`), a Co-Authored-By / Generated-by AI
+   trailer, or witnessed spans from an AI session log (\`madeby ai --witness\`). Human and AI disclosure
+   ride the same ladder. A DCO Signed-off-by or a signed commit alone says who is accountable, not who
+   wrote the code, so it satisfies the policy only if the policy's \`accept\` lists it.
 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.
@@ -2685,8 +2825,8 @@ 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.
+point it at the pipeline created from .madeby/azure-pipelines.yml (written by init with host
+azure-devops); 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
 
@@ -2695,8 +2835,9 @@ refuses it. But you CAN make an honest, verifiable statement about history. Back
 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.
+   existing Co-Authored-By AI trailers and bot authorship are recognized now even though they predate
+   adoption. Much of your history may already be disclosed. (DCO sign-offs and signatures are
+   recognized too, but say who is accountable, not who wrote the code.)
 
 2. **Attach recoverable evidence** (opt-in, evidence-grade):
    - Old AI-tool session logs -> \`ai\` attaches structurally-verified spans to their commits (it
@@ -2727,7 +2868,8 @@ var POLICY_SCHEMA = {
   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" }
+    accept: { type: "array", items: { type: "string" }, description: "restrict what satisfies the policy (e.g. dco-signoff, ai-trailer, commit-signature); omit \u21D2 any authorship disclosure counts (a DCO sign-off or signature alone counts only if listed)" },
+    recordModel: { type: "boolean", description: "ask AI disclosures to name the model version too (tool:model, e.g. Assisted-by: Cursor:gpt-5.3-codex); madeby reads it from the tool's own session record where it can. Set by init --record-model. A request, not a gate" }
   }
 };
 var ACO_GUIDE = `# ACO \u2014 the Authorship Certificate of Origin
@@ -2743,12 +2885,22 @@ https://github.com/MadeByFYI/MadeBy/blob/main/ACO.md
 - **ai** \u2014 an AI agent authored it (a human remains accountable).
 
 ## How an agent discloses its OWN work (asserted tier, no keys)
-- Collaborative / human-directed work you just did -> call **disclose** (with_ai: true, tool: "<your name>").
-  It affirms human authorship + discloses AI assistance on HEAD, classifying the commit with_ai.
+- After you commit, call **disclose** with the honest \`category\` and your \`tool\` name (e.g. "Claude Code"):
+  - \`ai\`: you wrote it; the committer stays accountable. Adds \`Authored-by-ai: <tool>\`.
+  - \`with_ai\`: a human wrote it with your help. Adds \`Authored-by-human\` + \`Assisted-by: <tool>\`.
+  - \`human\`: a human wrote it alone. Adds \`Authored-by-human\`.
+  If you wrote the code and a human is only committing it, that is \`ai\`, not \`with_ai\`.
+- **The model version.** If the repo's \`.madeby/policy.json\` has \`"recordModel": true\`, madeby reads your
+  model from the tool's own record of the session (Cursor, Copilot CLI, Claude Code) and writes
+  \`<tool>:<model>\`. Elsewhere pass \`model\` only if you know your exact model version. Never guess.
+- **If your platform makes or rebuilds the commit** (a cloud coding agent that pushes through its own
+  tool), a trailer amended in afterwards can be lost. Call disclose with \`print: true\` to get the trailer
+  lines instead, and put them in the commit message's last paragraph.
 - Fully AI-authored spans recoverable from your session log -> call **ai** (records structurally-verified
   spans, local-only).
-- Read what's already disclosed -> **who**. Align a whole repo -> **init** (also scaffolds an AGENTS.md
-  ACO convention so any agent working there discloses).
+- Read what's already disclosed -> **who**; measure a repo -> **coverage** (also lists the agents and
+  models named). Align a whole repo -> **init** (also scaffolds an AGENTS.md ACO convention so any agent
+  working there discloses).
 
 Disclose per commit, honestly. Undisclosed content stays *unknown*, never guessed.
 `;
@@ -2849,7 +3001,7 @@ Usage:
    (alias: whom)                 file's origin, or the whole repo with no path. --lines=A-B to scope.
   madeby coverage [<range>]      The scoreboard: how much of your repo's authorship is disclosed (known)
                                  vs unknown, the human/with_ai/ai mix, and the asserted/verified split.
-                                 --json for a machine-readable result.
+                                 --by author for one row per commit author. --json for a machine-readable result.
   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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "madeby",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "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",