madeby 0.3.13 → 0.3.15

package/README.md

@@ -43,6 +43,7 @@ npm i -g madeby
 ```
 madeby init                    Set MadeBy up: write .madeby/policy.json + the CI disclosure check.
                                --record-model (opt-in) also asks agents to name the model version.
+                               In a repo that uses Claude Code, also turns its commit trailer on.
 madeby check  [<range>]        The gate: do commits meet .madeby/policy.json? (a verdict — exit code
                                gates). <range> e.g. origin/main..HEAD — a PR's own commits. --json too.
 madeby coverage [<range>]      The scoreboard: how much of the repo's authorship is disclosed (known)
@@ -148,6 +149,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:
@@ -179,6 +199,24 @@ Fail-safe by design: a missing or malformed policy degrades to `advisory`. `made
 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).
 
+### Claude Code's own trailer
+
+Claude Code adds a `Co-Authored-By` trailer to its commits unless a developer turns it off in their
+personal settings — and then the `AGENTS.md` rule alone may not bring it back. So in a repo that uses
+Claude Code (it has a `CLAUDE.md` or a `.claude/` folder; `--claude-code` to force), `madeby init`
+sets the trailer in the shared `.claude/settings.json`:
+
+```json
+{ "attribution": { "commit": "Co-Authored-By: Claude Code <noreply@anthropic.com>" } }
+```
+
+The shared project file overrides a developer's personal settings, so everyone in the repo gets the
+trailer back. It's fixed text — Claude Code's setting has no placeholder for the model — so to record
+the model use `--record-model`. It merges into an existing file and never changes a value the team
+already set, including turning attribution off on purpose. A developer's own
+`.claude/settings.local.json` or instructions can still turn it off; the `required` check is what
+holds the line.
+
 ## Use it as a PR check
 
 A ready-made GitHub Action, an Azure DevOps Pipelines template, and a GitLab CI job wrap

package/dist/madeby.mjs

@@ -17,19 +17,19 @@ var parseMeta = (rec) => {
   };
 };
 function historyProblem(repoPath, range) {
-  const git4 = (...args) => {
+  const git5 = (...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") {
+  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 (git4("rev-parse", "--verify", "--quiet", `${end}^{commit}`) === null) {
+      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.`;
       }
     }
@@ -971,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" };
@@ -1070,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;
@@ -1089,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 ?? "";
@@ -1099,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";
 
@@ -1141,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() };
@@ -1217,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;
@@ -1273,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 });
@@ -1313,10 +1401,11 @@ 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) {
@@ -1331,6 +1420,7 @@ function repoCoverage(root, opts = {}) {
     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;
@@ -1350,11 +1440,12 @@ 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)),
@@ -1363,7 +1454,7 @@ function repoCoverage(root, opts = {}) {
 }
 
 // ../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";
@@ -1696,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, "-");
@@ -1713,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) {
@@ -1731,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) {
@@ -1850,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;
   }
@@ -1905,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 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.)`
+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";
@@ -2033,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;
@@ -2060,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" };
   }
@@ -2079,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 };
 }
@@ -2091,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: [] };
@@ -2109,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" };
   }
@@ -2140,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);
@@ -2159,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) {
@@ -2201,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") {
@@ -2243,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;
@@ -2413,7 +2591,7 @@ import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as rea
 import { dirname as dirname2, join as join8 } from "node:path";
 
 // src/version.ts
-var VERSION = "0.3.13";
+var VERSION = "0.3.15";
 
 // src/init-repo.ts
 var ACO_VERSION = 2;
@@ -2509,6 +2687,31 @@ function ensurePolicy(abs, rel, want, res) {
   }
   return { mode: raise ? "required" : current.mode, recordModel: modelOn || current.recordModel === true, malformed: !isObject };
 }
+var CLAUDE_TRAILER = "Co-Authored-By: Claude Code <noreply@anthropic.com>";
+function ensureClaudeSettings(root, force) {
+  const abs = join8(root, ".claude", "settings.json");
+  const usesClaude = force || existsSync7(join8(root, "CLAUDE.md")) || existsSync7(join8(root, ".claude"));
+  if (!usesClaude) return "not-used";
+  if (!existsSync7(abs)) {
+    mkdirSync2(dirname2(abs), { recursive: true });
+    writeFileSync2(abs, JSON.stringify({ attribution: { commit: CLAUDE_TRAILER } }, null, 2) + "\n");
+    return "created";
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync9(abs, "utf8"));
+  } catch {
+    return "malformed";
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "malformed";
+  const settings = raw;
+  const attribution = settings.attribution;
+  if (attribution === false || attribution && typeof attribution === "object" && "commit" in attribution) return "kept";
+  if (attribution === void 0 && settings.includeCoAuthoredBy === false) return "kept";
+  const next = { ...settings, attribution: { ...attribution && typeof attribution === "object" ? attribution : {}, commit: CLAUDE_TRAILER } };
+  writeFileSync2(abs, JSON.stringify(next, null, 2) + "\n");
+  return "merged";
+}
 function ensureAco(abs, rel, res, opts) {
   const block = acoBlock(opts.recordModel);
   if (!existsSync7(abs)) {
@@ -2559,6 +2762,8 @@ function initRepo(root, opts = {}) {
   const aco = { update, recordModel: policy.recordModel, modelRequested };
   ensureAco(join8(root, "AGENTS.md"), "AGENTS.md", res, { createIfAbsent: true, ...aco });
   ensureAco(join8(root, "CLAUDE.md"), "CLAUDE.md", res, { createIfAbsent: false, ...aco });
+  const claudeSettings = ensureClaudeSettings(root, opts.claudeCode ?? false);
+  if (claudeSettings === "created") created.push(".claude/settings.json");
   if (host === "github") {
     writeIfAbsent(join8(root, ".github", "workflows", "disclosure.yml"), ".github/workflows/disclosure.yml", GH_WORKFLOW, created, skipped);
   } else if (host === "azure-devops") {
@@ -2595,8 +2800,15 @@ function initRepo(root, opts = {}) {
     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'), 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.");
+  if (claudeSettings === "created" || claudeSettings === "merged") {
+    nextSteps.push(`Claude Code now adds '${CLAUDE_TRAILER}' to its commits in this repo (.claude/settings.json), for everyone \u2014 including developers who turned the trailer off in their personal settings. Their .claude/settings.local.json, or an instruction of their own, can still turn it off; the check is what holds the line.`);
+  } else if (claudeSettings === "kept") {
+    nextSteps.push("This repo's .claude/settings.json already sets Claude Code's commit attribution, so it was left as the team set it. Clear that setting for the default trailer, or set attribution.commit to name the AI.");
+  } else if (claudeSettings === "malformed") {
+    nextSteps.push(".claude/settings.json isn't valid JSON, so Claude Code's commit trailer wasn't set. Fix the file and run 'madeby init' again.");
+  }
   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 };
+  return { created, skipped, merged, updated, outdated, raised, modelOn, policyMode: policy.mode, recordModel: policy.recordModel, claudeSettings, host, nextSteps };
 }
 var GH_WORKFLOW = `name: Disclosure
 on: pull_request
@@ -2645,9 +2857,11 @@ function initCommand(args) {
   const recordModel = args.includes("--record-model");
   const hostIdx = args.indexOf("--host");
   const host = hostIdx >= 0 ? args[hostIdx + 1] : void 0;
-  const r = initRepo(root, { mode, host, update, recordModel });
+  const claudeCode = args.includes("--claude-code");
+  const r = initRepo(root, { mode, host, update, recordModel, claudeCode });
   for (const f of r.created) console.log(`  + ${f}`);
   for (const f of r.merged) console.log(`  ~ ${f} (merged in the ACO rule)`);
+  if (r.claudeSettings === "merged") console.log("  ~ .claude/settings.json (merged in Claude Code's commit trailer)");
   for (const f of r.updated) console.log(`  \u2191 ${f} (ACO convention refreshed to the current version)`);
   for (const f of r.raised) console.log(`  \u2191 ${f} (mode raised to required)`);
   for (const f of r.modelOn) console.log(`  \u2191 ${f} (now records the model version)`);
@@ -2660,13 +2874,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: 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",
@@ -2686,14 +2900,16 @@ var TOOLS = [
         mode: { enum: ["advisory", "required"], description: "policy mode to seed (default: advisory)" },
         host: { type: "string", description: "CI host to wire: github (default) or azure-devops" },
         update: { type: "boolean", description: "refresh an outdated ACO convention block in place (drift update); default false (report only)" },
-        record_model: { type: "boolean", description: "opt in: ask AI disclosures to also name the model version (tool:model) \u2014 policy recordModel + an AGENTS.md line. Never turned off by init; default false." }
+        record_model: { type: "boolean", description: "opt in: ask AI disclosures to also name the model version (tool:model) \u2014 policy recordModel + an AGENTS.md line. Never turned off by init; default false." },
+        claude_code: { type: "boolean", description: "set Claude Code's commit trailer in .claude/settings.json even if the repo shows no sign of Claude Code (it is set automatically when there is a CLAUDE.md or .claude/). A value the team already set is never changed." }
       }
     },
     handler: (args) => initRepo(rootFor(args.path), {
       mode: args.mode,
       host: args.host,
       update: args.update,
-      recordModel: args.record_model
+      recordModel: args.record_model,
+      claudeCode: args.claude_code
     })
   },
   {
@@ -2729,7 +2945,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: {
@@ -2738,7 +2954,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) => {
@@ -2746,6 +2963,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 });
@@ -2994,6 +3215,8 @@ Usage:
                                  + the CI disclosure check. --update refreshes an outdated ACO block in
                                  place; --required to enforce now; --host azure-devops for Azure Pipelines;
                                  --record-model to also ask agents for the model version (opt-in).
+                                 In a repo that uses Claude Code (CLAUDE.md or .claude/; --claude-code to
+                                 force) it also turns Claude Code's commit trailer on in .claude/settings.json.
   madeby check [<range>]         The gate: do commits meet .madeby/policy.json? (a verdict \u2014 exit
                                  code gates). <range> e.g. origin/main..HEAD; in CI it's auto-detected.
                                  --json for a machine-readable result.
@@ -3011,6 +3234,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.13",
+  "version": "0.3.15",
   "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",