contrib-tools: adopt Assisted-by commit message trailers for AI-assisted changes

[myitcv]

Is your feature request related to a problem? Please describe.

The cueckoo common guidance currently says, under "Commit Messages":

No AI authorship attribution in commit messages

That rule predates what has since become a de facto ecosystem norm: the
Assisted-by: trailer for disclosing AI involvement in a change. The
Linux kernel's AI-contribution policy reserves Signed-off-by: for
humans (it asserts the DCO, which only a person can do) and introduces
Assisted-by: as the disclosure trailer, and that convention is being
adopted more widely (e.g. Artsy's merged RFC choosing Assisted-by
over Co-authored-by precisely because it keeps responsibility with
the human contributor).

Given how much CUE project work is now AI-assisted, we should disclose
that assistance rather than forbid its mention — and ideally the
disclosure should be deterministic, not dependent on an agent
remembering an instruction.

Describe the solution you'd like

Two parts, in order:

1. Flip the guidance policy (contrib-tools,
   cmd/cueckoo/cmd/guidance.go). Replace the "No AI authorship
   attribution" rule with:

   • AI-assisted commits carry an Assisted-by: trailer identifying
     the tool and model, e.g.
     Assisted-by: Claude Code (claude-fable-5).
   • Signed-off-by: remains reserved for humans (DCO).
   • Co-authored-by: must not name an AI — it implies personhood and
     dilutes responsibility.
     Agents following the guidance then add the trailer themselves. Note
     cueckoo rewrite-commit-msg already preserves arbitrary trailers,
     so the existing tooling composes.

2. Deterministic backstop: a cueckoo-managed prepare-commit-msg git
   hook that appends the trailer when it detects an agent environment
   (e.g. CLAUDECODE=1 for Claude Code; an override variable for other
   tools, since there is no standard "an agent is driving" signal).
   Implementation sketch:

   • git interpret-trailers --if-exists doNothing so an
     agent-authored trailer is never duplicated;
   • installation must compose with existing hooks
     (git-codereview's commit-msg, and hand-rolled
     prepare-commit-msg hooks adding Signed-off-by).

Part 1 is being implemented now in contrib-tools. Part 2 can follow as
a separate change on this issue.

Describe alternatives you've considered

• Guidance-only (part 1 alone): works for agents that load and follow
  the guidance, which today is Claude Code via the CLAUDE.md @-import;
  silent for any other agent. The hook closes that gap.
• Per-tool configuration (e.g. Claude Code settings/hooks committed per
  repo): Claude-only, and multiplies per-tool maintenance.
• Adopting Co-authored-by: for AI: rejected — see above.

Additional context

• Linux kernel Assisted-by policy coverage:
  https://allthingsopen.org/articles/open-source-ai-contributions-assisted-by-git-trailer-standard
• Artsy RFC discussion of Assisted-by vs Co-authored-by:
  https://www.baristalabs.io/blog/ai-assisted-commits-need-provenance-trailer
• Related: the cross-agent guidance-distribution gap is tracked
  separately in contrib-tools: cueckoo guidance only reliably reaches Claude Code; cross-agent use needs AGENTS.md #4451 (cueckoo guidance currently only reliably reaches
  Claude Code), which bounds how far part 1 alone can reach.

[mvdan]

I personally think the correct solution here is indeed to configure each tool to self-report the model being used via the trailer. Only they know exactly what model is being used at each point, especially given that e.g. Fable can downgrade to Opus when it detects it's being used for "security" work.

Having the guidance ask the AI to self-report is best-effort and the AI might not get it right, so I would avoid that.

We already have to configure each AI we use (see all the dotfiles Marcel has been adding) so this bit of extra configuration seems fine to me. Unfortunately, it seems like these tools hard-code Co-authored-by as the supported trailer: anthropics/claude-code#36105

[myitcv]

Where this stands

Part 1 is done and merged. The guidance in cmd/cueckoo/cmd/guidance.go now
requires an Assisted-by: trailer naming the tool and, where known, the model;
reserves Signed-off-by: for humans; and forbids naming an AI in
Co-authored-by:. cueckoo rewrite-commit-msg preserves the trailer across
amends, rebases and full message rewrites, so the existing tooling composes as
expected.

Part 2, the deterministic backstop, has not been started: there is no
prepare-commit-msg support and no hooks command in cueckoo.

What has changed since the issue was filed

@mvdan's point above — only the tool knows which model is in use, so the tool
should self-report — is well founded, and the constraint is sharper than a
preference. Measured inside a Claude Code session (2.1.220, 2026-07-29), what a
git hook can actually see is:

CLAUDECODE=1                 # present: reliable "an agent is driving" signal
CLAUDE_CODE_MODEL            # unset
ANTHROPIC_MODEL              # unset
CLAUDE_MODEL                 # unset

The only other Claude variables exported to child processes are
CLAUDE_CODE_{CHILD_SESSION,ENTRYPOINT,EXECPATH,SESSION_ID}, CLAUDE_EFFORT
and CLAUDE_PID; none carries the model. So a prepare-commit-msg hook can
reliably detect that an agent is driving, but cannot name the model. That is a
hard limit on part 2 as sketched, not an implementation detail.

Meanwhile the upstream route that would make self-reporting authoritative does
not look imminent. anthropics/claude-code#36105 is still open, and the
discussion has moved away from adopting Assisted-by: one participant withdrew
their support on the grounds that shipping it would legitimize tool-injected
trailers, arguing the correct fix is no trailer by default with opt-in
attribution. There is now an attribution setting, but its default concerns the
"Generated with Claude Code" footer rather than the trailer, its effectiveness
is disputed in that thread, and it is a static string, so it cannot carry the
model either.

Worth recording on the reliability of self-reporting: it has already drifted in
practice. The example in the guidance says claude-fable-5, while commits made
in a later session say claude-opus-5. Both are self-reports, and neither is
verifiable after the fact.

Option space

1. Guidance only (status quo). Works for agents that load the guidance —
   today, Claude Code via the CLAUDE.md @-import. Yields tool and model when
   the agent complies. Silent for any other agent, and unverifiable. contrib-tools: cueckoo guidance only reliably reaches Claude Code; cross-agent use needs AGENTS.md #4451
   bounds how far this reaches.
2. Hook only, tool level. A cueckoo-managed prepare-commit-msg appends
   Assisted-by: Claude Code when CLAUDECODE=1. Deterministic, but coarser
   than the guidance asks for, because it cannot include the model.
3. Hybrid: agent self-reports, hook backstops. The agent writes tool and
   model per part 1; the hook adds a tool-level trailer only when no
   Assisted-by: is already present, via
   git interpret-trailers --if-exists doNothing as in the original sketch.
   Disclosure is then never zero, and the model appears whenever the agent does
   its job. Cost: two grades of trailer in the wild.
4. Wait for upstream. Keep part 1 and revisit if a tool grows a way to emit
   its own trailer including the model. Given the direction of
   [FEATURE] Use Assisted-by git commit trailer instead of Co-authored-by anthropics/claude-code#36105 this may be a long wait, and agents other than
   Claude Code stay silent in the meantime.

What remains open

• Which option to adopt. My reading is that (3) is the only one satisfying both
  "disclosure should be deterministic" and "the model must come from the tool",
  and that (2) collapses into (3) as soon as an agent-written trailer is
  present.
• If a hook is adopted: installation has to compose with git-codereview's
  commit-msg hook and with any hand-rolled prepare-commit-msg adding
  Signed-off-by, and it needs an override for agents other than Claude Code,
  since there is no standard "an agent is driving" signal.
• Whether tool-level-only disclosure is worth having at all, or whether a
  trailer without a model is worse than no trailer.