madeby 0.3.12 → 0.3.14

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
@@ -138,6 +148,25 @@ of AI disclosure); a sworn declaration is *sworn*. The one asymmetry is evidence
 leave a re-checkable artifact (a session log, `madeby ai`); human authorship is your firsthand
 testimony. If you used AI, disclose the AI — don't claim human.
 
+### Disclosing earlier commits — `--for`
+
+`me` and `ai` amend HEAD. When that isn't possible — the commits are already pushed, or the repo
+forbids amending and rebasing — disclose them with **one new commit** instead:
+
+```sh
+madeby me --with-ai "Claude Code" --for origin/dev..HEAD   # your commits on this branch
+madeby ai "Claude Code" --for 4f1c2a9e                     # one commit
+```
+
+It makes an empty **disclosure commit** whose `Discloses: <hash>` lines name the commits and whose
+trailers say who wrote them. Nothing is rewritten. Push it as usual: on a pull request the check
+re-runs, and it travels with the branch into every target it's merged into. Only your own commits
+(author email = `git config user.email`) that don't disclose yet are included; the rest are listed
+as skipped. The model is named only if you pass `--model`, since the session you're in now didn't
+write those commits. `check`, `coverage` and `who` read disclosure commits by the rules in
+[ACO §5](https://github.com/MadeByFYI/MadeBy/blob/main/ACO.md#5-carriers-bindings--subsume-dont-compete), and `coverage` counts how many
+disclosures arrived late.
+
 **The policy file is optional.** With no `.madeby/policy.json`, `check` defaults to **advisory** —
 it reports coverage and never blocks, so you can run it (or add the CI check) with zero config. Add
 the file only when you want to enforce:
@@ -151,8 +180,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 +195,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 git5 = (...args) => {
+    try {
+      return execFileSync("git", ["-C", repoPath, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      return null;
+    }
+  };
+  if (git5("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 (git5("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) {
@@ -930,6 +971,16 @@ function commitDisclosureKinds(commit) {
   if (commit.signed === true) kinds.push("commit-signature");
   return kinds;
 }
+function hasAuthorshipDisclosure(message) {
+  return commitDisclosureKinds({ message }).some((k) => DISCLOSURE_KINDS[k].authorship);
+}
+var DISCLOSES_RE = /^[ \t]*Discloses[ \t]*:[ \t]*([0-9a-f]{64}|[0-9a-f]{40})[ \t]*$/gim;
+function disclosedTargets(message) {
+  return [...new Set([...message.matchAll(DISCLOSES_RE)].map((m) => m[1].toLowerCase()))];
+}
+function disclosureCommitTrailers(message) {
+  return message.split("\n").slice(1).filter((l) => !/^[ \t]*Discloses[ \t]*:/i.test(l)).join("\n").trim();
+}
 
 // ../core/src/policy.ts
 var DEFAULT_POLICY = { version: 0, mode: "advisory" };
@@ -947,18 +998,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 +1032,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 +1055,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;
@@ -1018,13 +1080,85 @@ registerHostAdapter(githubAdapter);
 // ../analyzer/src/read-disclosures.ts
 import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import { join } from "node:path";
+
+// ../analyzer/src/late-disclosure.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var FIELD2 = "";
+var RECORD2 = "";
+var git = (root, args) => {
+  try {
+    return execFileSync2("git", ["-C", root, ...args], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return null;
+  }
+};
+function rangeHead(range) {
+  if (!range) return "HEAD";
+  const parts = range.split(/\.{2,3}/);
+  return parts[parts.length - 1] || "HEAD";
+}
+function readDisclosureCommits(root, head = "HEAD") {
+  const out = { applied: /* @__PURE__ */ new Map(), disclosureCommits: /* @__PURE__ */ new Set(), rejected: [] };
+  const log = git(root, ["log", "--no-merges", "-E", "--grep=^[ 	]*Discloses[ 	]*:[ 	]*[0-9a-f]{40}", `--format=%H${FIELD2}%ae${FIELD2}%B${RECORD2}`, head]);
+  if (!log) return out;
+  const candidates = log.split(RECORD2).map((r) => r.replace(/^\s+/, "")).filter(Boolean).map((r) => {
+    const [sha = "", email = "", ...msg] = r.split(FIELD2);
+    return { sha, email: email.toLowerCase(), message: msg.join(FIELD2) };
+  });
+  for (const d of candidates) {
+    const targets = disclosedTargets(d.message);
+    if (targets.length === 0) continue;
+    const changed = git(root, ["diff-tree", "--root", "--no-commit-id", "--name-only", "-r", d.sha]);
+    if (changed === null || changed.trim() !== "") continue;
+    out.disclosureCommits.add(d.sha);
+    const trailers = disclosureCommitTrailers(d.message);
+    const emails = /* @__PURE__ */ new Map();
+    const shown = git(root, ["show", "-s", "--format=%H %ae", ...targets]) ?? targets.map((t) => git(root, ["show", "-s", "--format=%H %ae", t]) ?? "").join("\n");
+    for (const line of shown.split("\n")) {
+      const [sha, email] = line.trim().split(" ");
+      if (sha && email !== void 0) emails.set(sha, email.toLowerCase());
+    }
+    for (const t of targets) {
+      if (out.applied.has(t)) continue;
+      const email = emails.get(t);
+      if (email === void 0) out.rejected.push({ sha: t, via: d.sha, reason: "unknown-commit" });
+      else if (email !== d.email) out.rejected.push({ sha: t, via: d.sha, reason: "other-author" });
+      else if (git(root, ["merge-base", "--is-ancestor", t, d.sha]) === null) out.rejected.push({ sha: t, via: d.sha, reason: "not-an-ancestor" });
+      else out.applied.set(t, { via: d.sha, trailers });
+    }
+  }
+  return out;
+}
+function applyLateDisclosures(commits, d) {
+  const out = [];
+  for (const c of commits) {
+    const sha = (c.sha ?? "").toLowerCase();
+    if (d.disclosureCommits.has(sha)) continue;
+    const late = d.applied.get(sha);
+    if (late && !hasAuthorshipDisclosure(c.message)) out.push({ ...c, message: `${c.message}
+
+${late.trailers}`, late: late.via });
+    else out.push(c);
+  }
+  return out;
+}
+
+// ../analyzer/src/read-disclosures.ts
 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 })
-  }));
+  return readDisclosuresWithRejects(root, opts).commits;
+}
+function readDisclosuresWithRejects(root, opts) {
+  const late = readDisclosureCommits(root, rangeHead(opts.range));
+  const commits = applyLateDisclosures(readGitLog(root, opts.range ? void 0 : opts.limit ?? 200, opts.range), late);
+  return {
+    commits: commits.map((c) => ({
+      sha: c.sha ?? "",
+      subject: c.message.split("\n")[0] ?? "",
+      disclosures: commitDisclosureKinds({ message: c.message, signed: c.signed }),
+      ...c.late ? { late: c.late } : {}
+    })),
+    rejected: late.rejected
+  };
 }
 function evaluateRepoDisclosure(root, opts = {}) {
   let policy = DEFAULT_POLICY;
@@ -1037,7 +1171,7 @@ function evaluateRepoDisclosure(root, opts = {}) {
       warning = ".madeby/policy.json is not valid JSON \u2014 degrading to advisory (report-only, never blocks).";
     }
   }
-  const commits = readDisclosures(root, opts);
+  const { commits, rejected } = readDisclosuresWithRejects(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 ?? "";
@@ -1047,12 +1181,13 @@ function evaluateRepoDisclosure(root, opts = {}) {
     summary: result.summary,
     total: disclosures.length,
     undisclosed: result.nonCompliant.map((v) => ({ ref: v.ref, subject: subjectFor(v.ref) })),
+    lateRejected: rejected.filter((r) => commits.some((c) => c.sha === r.sha)),
     ...warning ? { warning } : {}
   };
 }
 
 // ../analyzer/src/path-provenance.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync4, existsSync as existsSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 
@@ -1089,13 +1224,13 @@ function readSpanManifestsFromDir(repoDir) {
 
 // ../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"] });
+function git2(root, args) {
+  return execFileSync3("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 out = git2(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() };
@@ -1165,12 +1300,17 @@ function provenanceOf(root, path, opts = {}) {
   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 porcelain = git2(root, ["blame", "--porcelain", ...range, "--", path]);
       const metaCache = /* @__PURE__ */ new Map();
+      const late = readDisclosureCommits(root);
       for (const g of blameGroups(porcelain)) {
         let meta = metaCache.get(g.sha);
         if (meta === void 0) {
           meta = commitMeta(root, g.sha);
+          const filled = meta && late.applied.get(g.sha.toLowerCase());
+          if (meta && filled && !hasAuthorshipDisclosure(meta.message)) meta = { ...meta, message: `${meta.message}
+
+${filled.trailers}` };
           metaCache.set(g.sha, meta);
         }
         if (!meta) continue;
@@ -1221,7 +1361,7 @@ function provenanceMap(root, opts = {}) {
   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;
+    trackedFiles = git2(root, ["ls-files", ...prefix ? ["--", prefix] : []]).split("\n").filter(Boolean).length;
   } catch {
   }
   const commits = readDisclosures(root, { limit: opts.commitLimit ?? 500 });
@@ -1261,17 +1401,26 @@ function repoCoverage(root, opts = {}) {
   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 commits = applyLateDisclosures([...authored, ...merges], readDisclosureCommits(root, rangeHead(opts.range)));
   const byCategory = { human: 0, with_ai: 0, ai: 0, bot: 0 };
   const byTier = { asserted: 0, verified: 0 };
   let known = 0;
+  let late = 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;
+    if (c.late) late += 1;
     byCategory[category] += 1;
     if (c.signed) byTier.verified += 1;
     else byTier.asserted += 1;
@@ -1291,19 +1440,21 @@ function repoCoverage(root, opts = {}) {
   }
   return {
     isEstimate: true,
-    methodology: "commit-level authorship disclosure (estimate); undisclosed = unknown, never inferred; merges scored only when they change content of their own",
+    methodology: "commit-level authorship disclosure (estimate); undisclosed = unknown, never inferred; merges scored only when they change content of their own; a disclosure commit (Discloses:) fills in commits disclosed afterwards and isn't scored itself",
     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,
+    late,
     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))
   };
 }
 
 // ../analyzer/src/record-spans.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join as join4 } from "node:path";
@@ -1636,8 +1787,8 @@ ${body}
 }
 
 // ../analyzer/src/record-spans.ts
-function git2(root, ...a) {
-  return execFileSync3("git", ["-C", root, "-c", "core.quotePath=false", ...a], { encoding: "utf8" }).trim();
+function git3(root, ...a) {
+  return execFileSync4("git", ["-C", root, "-c", "core.quotePath=false", ...a], { encoding: "utf8" }).trim();
 }
 function autodiscover(root) {
   const enc3 = root.replace(/[/_]/g, "-");
@@ -1653,7 +1804,7 @@ function recordAiSpans(root, opts = {}) {
   if (!transcriptPath || !existsSync3(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 commit = git3(root, "rev-parse", opts.ref ?? "HEAD");
   const transcriptText = readFileSync5(transcriptPath, "utf8");
   const parser = detectParser(transcriptText);
   if (!parser) {
@@ -1671,7 +1822,7 @@ function recordAiSpans(root, opts = {}) {
       }
     },
     commit,
-    operatorId: git2(root, "show", "-s", "--format=%ae", commit),
+    operatorId: git3(root, "show", "-s", "--format=%ae", commit),
     now: opts.now ?? (/* @__PURE__ */ new Date()).toISOString()
   });
   if (result.manifest.attestations.length === 0) {
@@ -1745,7 +1896,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 +1926,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;
@@ -1783,10 +1941,10 @@ var gitlabAdapter = {
 registerHostAdapter(gitlabAdapter);
 
 // src/scope.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 function repoRoot() {
   try {
-    return execFileSync4("git", ["-c", "core.quotePath=false", "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+    return execFileSync5("git", ["-c", "core.quotePath=false", "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
   } catch {
     return null;
   }
@@ -1809,9 +1967,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}`);
@@ -1824,16 +1996,20 @@ Undisclosed commits (${result.undisclosed.length}):`);
       console.log(`  \u2717 ${v.ref}  ${v.subject.slice(0, 60)}`);
     }
     if (result.undisclosed.length > 20) console.log(`  \u2026 and ${result.undisclosed.length - 20} more`);
+    const why = { "other-author": "it names another author's commit", "not-an-ancestor": "it names a commit that isn't before it", "unknown-commit": "it names a commit that isn't here" };
+    for (const r of result.lateRejected.slice(0, 20)) {
+      console.log(`  ! ${r.sha.slice(0, 8)} is named by disclosure commit ${r.via.slice(0, 8)}, which can't disclose it: ${why[r.reason]}.`);
+    }
     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. Already pushed, or no amending allowed? Add --for <range> (e.g. madeby me --with-ai <tool> --for origin/main..HEAD): one new commit discloses the earlier ones, nothing rewritten. (Disclosure, not a ban \u2014 what this project requires is set in .madeby/policy.json.)`
     );
   }
   process.exit(result.pass ? 0 : 1);
 }
 
 // src/commands/me.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync6 } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join6 } from "node:path";
@@ -1952,8 +2128,8 @@ function parseWithAi(args) {
   const next = args[i + 1];
   return { withAi: true, tool: next && !next.startsWith("-") ? next : "AI" };
 }
-function git3(root, args) {
-  return execFileSync5("git", ["-C", root, ...args], { encoding: "utf8" }).trim();
+function git4(root, args) {
+  return execFileSync6("git", ["-C", root, ...args], { encoding: "utf8" }).trim();
 }
 var HUMAN_ATTEST2 = /^[ \t]*(?:Authored-by-human|Human-authored(?:-by)?)[ \t]*:/im;
 var ASSIST = /^[ \t]*Assisted-by[ \t]*:/im;
@@ -1979,15 +2155,15 @@ function attestAiAuthorship(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"]);
+    execFileSync6("git", ["-C", root, "diff", "--cached", "--quiet"]);
   } catch {
     return { ...base, reason: "staged-changes" };
   }
   let subject = "";
   let message = "";
   try {
-    subject = git3(root, ["show", "-s", "--format=%s", "HEAD"]);
-    message = git3(root, ["show", "-s", "--format=%B", "HEAD"]);
+    subject = git4(root, ["show", "-s", "--format=%s", "HEAD"]);
+    message = git4(root, ["show", "-s", "--format=%B", "HEAD"]);
   } catch {
     return { ...base, reason: "no-commit" };
   }
@@ -1998,7 +2174,7 @@ function attestAiAuthorship(root, opts = {}) {
     added.push("Authored-by-ai");
   }
   if (trailers.length > 0) {
-    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
+    execFileSync6("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
   }
   return { ...base, ok: true, changed: trailers.length > 0, subject, added };
 }
@@ -2010,8 +2186,8 @@ function disclosureTrailers(root, opts) {
   let name = "";
   let email = "";
   try {
-    name = git3(root, ["config", "user.name"]);
-    email = git3(root, ["config", "user.email"]);
+    name = git4(root, ["config", "user.name"]);
+    email = git4(root, ["config", "user.email"]);
   } catch {
   }
   if (!name || !email) return { ok: false, reason: "no-identity", lines: [] };
@@ -2028,21 +2204,21 @@ function affirmAuthorship(root, opts = {}) {
   let name = "";
   let email = "";
   try {
-    name = git3(root, ["config", "user.name"]);
-    email = git3(root, ["config", "user.email"]);
+    name = git4(root, ["config", "user.name"]);
+    email = git4(root, ["config", "user.email"]);
   } catch {
   }
   if (!name || !email) return { ...base, reason: "no-identity" };
   try {
-    execFileSync5("git", ["-C", root, "diff", "--cached", "--quiet"]);
+    execFileSync6("git", ["-C", root, "diff", "--cached", "--quiet"]);
   } catch {
     return { ...base, reason: "staged-changes", name, email };
   }
   let subject = "";
   let message = "";
   try {
-    subject = git3(root, ["show", "-s", "--format=%s", "HEAD"]);
-    message = git3(root, ["show", "-s", "--format=%B", "HEAD"]);
+    subject = git4(root, ["show", "-s", "--format=%s", "HEAD"]);
+    message = git4(root, ["show", "-s", "--format=%B", "HEAD"]);
   } catch {
     return { ...base, reason: "no-commit" };
   }
@@ -2059,11 +2235,84 @@ function affirmAuthorship(root, opts = {}) {
     added.push("Assisted-by");
   }
   if (trailers.length > 0) {
-    execFileSync5("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
+    execFileSync6("git", ["-C", root, "commit", "--amend", "--no-edit", "--allow-empty", ...trailers]);
   }
   const category = hasAssist || added.includes("Assisted-by") ? "with_ai" : "human";
   return { ...base, ok: true, changed: trailers.length > 0, name, email, subject, added, category };
 }
+function parseFor(args) {
+  const i = args.findIndex((a2) => a2 === "--for" || a2.startsWith("--for="));
+  if (i === -1) return void 0;
+  const a = args[i];
+  const v = a.startsWith("--for=") ? a.slice("--for=".length) : args[i + 1];
+  return v && !v.startsWith("-") ? v : void 0;
+}
+function discloseFor(root, target, opts) {
+  const none = { disclosed: [], skipped: [], lines: [] };
+  let email = "";
+  try {
+    email = git4(root, ["config", "user.email"]).toLowerCase();
+  } catch {
+  }
+  if (!email) return { ok: false, reason: "no-identity", ...none };
+  try {
+    execFileSync6("git", ["-C", root, "diff", "--cached", "--quiet"]);
+  } catch {
+    return { ok: false, reason: "staged-changes", ...none };
+  }
+  let commits;
+  if (target.includes("..")) {
+    commits = [...readGitLog(root, void 0, target), ...readAuthoredMerges(root, { range: target })];
+  } else {
+    try {
+      const sha = git4(root, ["rev-parse", "--verify", "--quiet", `${target}^{commit}`]);
+      commits = readGitLog(root, 1, sha);
+      if (commits[0]?.sha !== sha) commits = readAuthoredMerges(root, { range: `${sha}^!` });
+    } catch {
+      return { ok: false, reason: "bad-target", ...none };
+    }
+  }
+  if (commits.length === 0) return { ok: false, reason: "bad-target", ...none };
+  const later = readDisclosureCommits(root);
+  const disclosed = [];
+  const skipped = [];
+  for (const c of commits) {
+    const sha = (c.sha ?? "").toLowerCase();
+    const subject2 = c.message.split("\n")[0] ?? "";
+    if (later.disclosureCommits.has(sha)) continue;
+    if ((c.authorEmail ?? "").toLowerCase() !== email) skipped.push({ sha, subject: subject2, reason: "not-yours" });
+    else if (hasAuthorshipDisclosure(c.message)) skipped.push({ sha, subject: subject2, reason: "already-discloses" });
+    else if (later.applied.has(sha)) skipped.push({ sha, subject: subject2, reason: "already-disclosed-later" });
+    else disclosed.push({ sha, subject: subject2 });
+  }
+  const t = disclosureTrailers(root, { category: opts.category, tool: opts.tool, model: opts.model, env: {}, home: "/nonexistent" });
+  if (!t.ok) return { ok: false, reason: "no-identity", ...none };
+  if (disclosed.length === 0) return { ok: true, disclosed, skipped, lines: t.lines };
+  const n = disclosed.length;
+  const subject = `Disclose authorship of ${n} earlier commit${n === 1 ? "" : "s"}`;
+  const body = [...disclosed.map((d) => `Discloses: ${d.sha}`), ...t.lines].join("\n");
+  execFileSync6("git", ["-C", root, "commit", "--allow-empty", "-m", subject, "-m", body], { stdio: ["ignore", "ignore", "pipe"] });
+  return { ok: true, commit: git4(root, ["rev-parse", "HEAD"]), disclosed, skipped, lines: t.lines };
+}
+function renderDiscloseFor(cmd2, target, r) {
+  if (!r.ok) {
+    if (r.reason === "no-identity") console.error(`madeby ${cmd2}: set your git identity first (git config user.name / user.email).`);
+    else if (r.reason === "staged-changes") console.error(`madeby ${cmd2}: you have staged changes. A disclosure commit carries no content \u2014 commit or unstage them first.`);
+    else console.error(`madeby ${cmd2}: no commits found for ${target}. Give a commit or a range, e.g. --for origin/dev..HEAD`);
+    process.exit(1);
+    return;
+  }
+  const why = { "not-yours": "another author's \u2014 they disclose their own", "already-discloses": "its message already discloses", "already-disclosed-later": "a disclosure commit already covers it" };
+  for (const s of r.skipped) console.log(`  skipped ${s.sha.slice(0, 8)}  ${s.subject.slice(0, 50)}  (${why[s.reason]})`);
+  if (!r.commit) {
+    console.log(`madeby ${cmd2}: nothing to disclose in ${target}.`);
+    return;
+  }
+  console.log(
+    `madeby ${cmd2}: made disclosure commit ${r.commit.slice(0, 8)} for ${r.disclosed.length} earlier commit${r.disclosed.length === 1 ? "" : "s"} (${r.lines.join("; ")}).
+  Nothing was rewritten. Push it as usual; on a pull request the check re-runs.`
+  );
+}
 function meCommand(args) {
   const { withAi, tool } = parseWithAi(args);
   const model = parseModel(args);
@@ -2078,6 +2327,11 @@ function meCommand(args) {
     process.exit(2);
     return;
   }
+  const forTarget = parseFor(args);
+  if (forTarget) {
+    renderDiscloseFor("me", forTarget, discloseFor(root, forTarget, { category: withAi ? "with_ai" : "human", tool, model }));
+    return;
+  }
   if (args.includes("--print")) {
     const t = disclosureTrailers(root, { category: withAi ? "with_ai" : "human", tool, model });
     if (!t.ok) {
@@ -2120,7 +2374,7 @@ function aiCommand(args) {
   const makeSample = args.includes("--make-parser-sample");
   const witness = args.includes("--witness");
   const model = parseModel(args);
-  const positional = args.filter((a, i) => !a.startsWith("--") && !(args[i - 1] === "--model"));
+  const positional = args.filter((a, i) => !a.startsWith("--") && args[i - 1] !== "--model" && args[i - 1] !== "--for");
   if (makeSample) {
     const s = writeParserSample(root, { transcriptPath: positional[0] });
     if (s.error === "transcript-not-found") {
@@ -2162,6 +2416,11 @@ function aiCommand(args) {
     return;
   }
   const tool = positional[0] || "AI";
+  const forTarget = parseFor(args);
+  if (forTarget) {
+    renderDiscloseFor("ai", forTarget, discloseFor(root, forTarget, { category: "ai", tool, model }));
+    return;
+  }
   if (args.includes("--print")) {
     console.log(disclosureTrailers(root, { category: "ai", tool, model }).lines.join("\n"));
     return;
@@ -2250,6 +2509,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 +2563,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 +2582,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.14";
+
+// src/init-repo.ts
 var ACO_VERSION = 2;
 var ACO_OPEN = `<!-- madeby:aco v${ACO_VERSION} -->`;
 var ACO_CLOSE = `<!-- /madeby:aco -->`;
@@ -2451,6 +2739,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 +2765,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 +2787,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
@@ -2526,13 +2838,13 @@ madeby init \u2014 policy: ${r.policyMode}${r.recordModel ? " + records model" :
 }
 
 // src/mcp.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 import { createInterface } from "node:readline";
 var DEFAULT_PROTOCOL = "2024-11-05";
-var SERVER_INFO = { name: "madeby", version: "0.3.12" };
+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();
+  return execFileSync7("git", ["-C", cwd, "-c", "core.quotePath=false", "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
 }
 var repoInput = {
   type: "object",
@@ -2570,7 +2882,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 })
   },
@@ -2595,7 +2907,7 @@ var TOOLS = [
   },
   {
     name: "disclose",
-    description: "Disclose authorship on HEAD per ACO \u2014 the agent-native disclosure of work you just did. Pick the honest category: 'ai' (an AI authored it; you, the committer, are accountable) adds Authored-by-ai; 'with_ai' (a human authored it WITH AI assistance) adds Authored-by-human + Assisted-by; 'human' adds Authored-by-human. IMPORTANT: if the AI wrote the code and a human is merely committing it, that is 'ai' \u2014 do NOT claim 'with_ai'/human authorship the human didn't do. Amends HEAD's MESSAGE only (a testimony, never a content change) and refuses if there are staged changes. Evidence upgrade for the ai category (witnessed spans from a session log) is the CLI `madeby ai --witness`. Read the standard: madeby://guide/aco.",
+    description: "Disclose authorship on HEAD per ACO \u2014 the agent-native disclosure of work you just did. Pick the honest category: 'ai' (an AI authored it; you, the committer, are accountable) adds Authored-by-ai; 'with_ai' (a human authored it WITH AI assistance) adds Authored-by-human + Assisted-by; 'human' adds Authored-by-human. IMPORTANT: if the AI wrote the code and a human is merely committing it, that is 'ai' \u2014 do NOT claim 'with_ai'/human authorship the human didn't do. Amends HEAD's MESSAGE only (a testimony, never a content change) and refuses if there are staged changes. Evidence upgrade for the ai category (witnessed spans from a session log) is the CLI `madeby ai --witness`. To disclose EARLIER commits without rewriting them (a repo that forbids amend/rebase), pass `for` (a commit or range): it makes one empty disclosure commit naming them (Discloses: <hash>), only for the git user's own undisclosed commits; push it and the PR check re-runs. Read the standard: madeby://guide/aco.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2604,7 +2916,8 @@ var TOOLS = [
         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." },
         print: { type: "boolean", description: "return the disclosure trailer lines instead of amending HEAD \u2014 for platforms that make the commit themselves; put them in the commit message's last paragraph" },
-        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." }
+        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." },
+        for: { type: "string", description: "disclose earlier commits instead of HEAD: a commit or a range (e.g. origin/dev..HEAD). Makes an empty disclosure commit; nothing is rewritten. The model is named only if you pass `model` for those commits." }
       }
     },
     handler: (args) => {
@@ -2612,6 +2925,10 @@ var TOOLS = [
       const tool = args.tool;
       const model = args.model;
       const category = args.category;
+      if (typeof args.for === "string" && args.for) {
+        const c = category === "ai" ? "ai" : category === "with_ai" || args.with_ai === true ? "with_ai" : "human";
+        return discloseFor(root, args.for, { category: c, tool, model: c === "human" ? void 0 : model });
+      }
       if (args.print === true) {
         const c = category === "ai" ? "ai" : category === "with_ai" || args.with_ai === true ? "with_ai" : "human";
         return disclosureTrailers(root, { category: c, tool, model });
@@ -2651,8 +2968,9 @@ guesses whether code is AI. To align a repo:
 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, a DCO Signed-off-by, a signed commit, or witnessed spans from an AI session log
-   (\`madeby ai --witness\`). Human and AI disclosure ride the same ladder.
+   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.
@@ -2690,8 +3008,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
 
@@ -2700,8 +3018,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
@@ -2732,7 +3051,7 @@ 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" }
   }
 };
@@ -2865,7 +3184,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
@@ -2875,6 +3194,8 @@ Usage:
                                  --model <version> names the model too (Assisted-by: <tool>:<version>).
                                  --print (me / ai) prints the trailer lines instead of amending HEAD,
                                  for the commit message itself: git commit -m <msg> -m "$(madeby ai <tool> --print)".
+                                 --for <commit|range> (me / ai) discloses EARLIER commits instead, with one
+                                 new empty commit naming them (Discloses: <hash>) \u2014 nothing rewritten.
   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.12",
+  "version": "0.3.14",
   "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",