Add --assume-untagged AGENT_NAME for projects with stripped/missing trailers

Real-world git histories have systematic trailer gaps:

- GitHub squash-merges strip Co-Authored-By trailers from individual
  branch commits and replace them with a synthesized merge message.
- Some Claude Code workflows commit via shell after the AI helps draft,
  without invoking the trailer-adding commit flow.
- Projects often started before the trailer convention existed; older
  commits look manual by inspection but were AI-paired by intent.

Without a flag, the analyzer can only report what it can prove from
trailers — so a project the developer "knows was end-to-end AI-assisted"
might show 21% AI commits because the other 79% were squash-merged or
pre-trailer. The 21% is technically correct but isn't the question the
user wanted answered.

The new flag closes that gap. `--assume-untagged "Claude Opus"`
re-attributes every untagged non-merge commit to that agent (which must
exist in the registry; merge commits are excluded because they almost
never represent direct authorship). Also configurable in YAML at
`agents.assume_untagged`.

Implementation:
- agent_detector.attribute_untagged() does the post-pass over the
  commits DataFrame, looking up the named agent in the registry and
  appending it to `agents`/`primary_agent`/`agent_vendors`.
- git_extractor now records each commit's parent SHAs and an
  `is_merge` boolean so the post-pass can skip merges.
- Config gains `agents.assume_untagged: str | None`.
- CLI gains `--assume-untagged AGENT_NAME` with help text pointing
  users at `list-agents` for valid names.
- Tests cover the happy path and the unknown-agent error.

Verified: on a 3-commit fixture with one Claude trailer, baseline
detection finds 1 AI commit; with `--assume-untagged "Claude Opus"`,
all 3 are attributed to Claude Opus.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: denn-gubsky

src/ai_dev_effectiveness/__init__.py

@@ -128,6 +128,11 @@ def analyze(
         )
     commits = agent_detector.detect_agents(commits, registry)
 
+    if cfg.agents.assume_untagged:
+        commits = agent_detector.attribute_untagged(
+            commits, cfg.agents.assume_untagged, registry,
+        )
+
     # 3. classify domains
     patterns = cfg.domain_patterns()
     if not patterns:

src/ai_dev_effectiveness/agent_detector.py

@@ -142,6 +142,66 @@ def vendor_color_map(registry: list[AgentSignature]) -> dict[str, str]:
     return out
 
 
+def attribute_untagged(
+    commits: pd.DataFrame,
+    agent_name: str,
+    registry: list[AgentSignature],
+) -> pd.DataFrame:
+    """Re-attribute commits with no detected agent to a known agent.
+
+    Use this when you KNOW the project was AI-assisted but commits don't
+    carry the trailer (squash-merges strip them; some workflows commit via
+    `git commit -m` without invoking the AI tool's commit flow; etc.).
+
+    The named agent must already exist in `registry`. Lookup is by exact
+    `name` match; if no match, raises ValueError with the available names.
+
+    Merge commits are NOT re-attributed by default — they almost never
+    represent direct authorship and would inflate the AI commit count.
+    """
+    if commits.empty or "primary_agent" not in commits.columns:
+        return commits
+
+    sig = next((s for s in registry if s.name == agent_name), None)
+    if sig is None:
+        names = sorted({s.name for s in registry})
+        raise ValueError(
+            f"Unknown agent {agent_name!r} in --assume-untagged. "
+            f"Pick one of: {', '.join(names)}"
+        )
+
+    out = commits.copy()
+    untagged_mask = out["primary_agent"].isna()
+    if "is_merge" in out.columns:
+        untagged_mask &= ~out["is_merge"]
+
+    if not untagged_mask.any():
+        return out
+
+    # Append the assumed agent to existing agent lists (rather than overwriting)
+    # so a future merge-inheritance pass can still distinguish detected vs
+    # inherited attributions. For untagged rows, agents starts empty.
+    new_agents_col = out["agents"].copy()
+    new_vendors_col = out["agent_vendors"].copy() if "agent_vendors" in out.columns else None
+
+    for idx in out.index[untagged_mask]:
+        existing = list(new_agents_col.loc[idx] or [])
+        if sig.name not in existing:
+            existing.append(sig.name)
+        new_agents_col.loc[idx] = existing
+        if new_vendors_col is not None:
+            existing_v = list(new_vendors_col.loc[idx] or [])
+            if sig.vendor not in existing_v:
+                existing_v.append(sig.vendor)
+            new_vendors_col.loc[idx] = sorted(existing_v)
+
+    out["agents"] = new_agents_col
+    if new_vendors_col is not None:
+        out["agent_vendors"] = new_vendors_col
+    out.loc[untagged_mask, "primary_agent"] = sig.name
+    return out
+
+
 def write_user_settings_template(target: Path) -> None:
     """Stub for future use; not called yet."""
     target.write_text("# User-defined agent signatures go here.\nagents:\n  extend: []\n")

src/ai_dev_effectiveness/cli.py

@@ -41,10 +41,18 @@ def main() -> None:
 @click.option("--judge-model", default=None, help="Override the judge model name.")
 @click.option("--no-ast-index", is_flag=True,
               help="Skip the `ast-index rebuild` step before the judge runs.")
+@click.option("--assume-untagged", "assume_untagged", default=None,
+              metavar="AGENT_NAME",
+              help="Attribute every untagged non-merge commit to AGENT_NAME "
+                   "(e.g. 'Claude Opus'). Use when you know the work was AI-"
+                   "assisted but the trailer is missing (squash-merges strip "
+                   "trailers; pre-trailer-convention commits look manual). "
+                   "Run `list-agents` to see valid names.")
 def analyze_cmd(target: str, config_path: str | None, out_dir: str | None,
                 workspace: str | None, fmt: str,
                 judge_provider: str | None, judge_all: bool, judge_dry_run: bool,
-                judge_model: str | None, no_ast_index: bool) -> None:
+                judge_model: str | None, no_ast_index: bool,
+                assume_untagged: str | None) -> None:
     """Analyze the git repo at TARGET (defaults to current directory).
 
     The analyzer is read-only with respect to TARGET — no files are created
@@ -61,6 +69,8 @@ def analyze_cmd(target: str, config_path: str | None, out_dir: str | None,
         cfg.judge.judge_all = True
     if judge_model is not None:
         cfg.judge.model = judge_model
+    if assume_untagged is not None:
+        cfg.agents.assume_untagged = assume_untagged
 
     if judge_dry_run:
         _run_judge_dry_run(target, cfg, workspace, out_dir)

src/ai_dev_effectiveness/config.py

@@ -71,6 +71,11 @@ class AgentExtension(BaseModel):
 class AgentsConfig(BaseModel):
     extend: list[AgentExtension] = Field(default_factory=list)
     override: list[AgentExtension] | None = None  # if set, replaces the built-in registry
+    # When the user knows the project was AI-assisted but commits don't carry
+    # the trailer (squash-merges, pre-trailer-convention work, manual-commit
+    # workflows), set this to a registry agent name (e.g. "Claude Opus") to
+    # attribute every untagged non-merge commit to that agent.
+    assume_untagged: str | None = None
 
 
 class JudgeConfig(BaseModel):

src/ai_dev_effectiveness/git_extractor.py

@@ -16,7 +16,8 @@
 # Sentinel that's effectively impossible to appear in a real commit body.
 _DELIM = "<<<COMMIT::AIDE>>>"
 _BODY_END = "<<<BODY_END::AIDE>>>"
-_LOG_FORMAT = f"{_DELIM}%n%H%n%ai%n%an%n%ae%n%s%n%b%n{_BODY_END}"
+# %P = parent SHAs (space-separated, multiple parents → merge commit).
+_LOG_FORMAT = f"{_DELIM}%n%H%n%P%n%ai%n%an%n%ae%n%s%n%b%n{_BODY_END}"
 
 # Trailer regex: matches "Token: value" lines at the end of a commit body
 # (RFC 5322-ish). git's own trailer parser is more permissive but this
@@ -93,23 +94,24 @@ def extract_commits(repo_dir: Path, branch: str | None = None) -> pd.DataFrame:
             continue
 
         sha = lines[0].strip()
-        date_str = lines[1].strip()
-        author_name = lines[2].strip()
-        author_email = lines[3].strip()
-        subject = lines[4].strip()
+        parents = [p for p in lines[1].strip().split() if p]
+        date_str = lines[2].strip()
+        author_name = lines[3].strip()
+        author_email = lines[4].strip()
+        subject = lines[5].strip()
 
         # Find the body terminator and the numstat tail.
         body_end_idx = None
-        for i, line in enumerate(lines[5:], start=5):
+        for i, line in enumerate(lines[6:], start=6):
             if line.strip() == _BODY_END:
                 body_end_idx = i
                 break
 
         if body_end_idx is None:
-            body = "\n".join(lines[5:]).strip()
+            body = "\n".join(lines[6:]).strip()
             numstat_lines: list[str] = []
         else:
-            body = "\n".join(lines[5:body_end_idx]).strip()
+            body = "\n".join(lines[6:body_end_idx]).strip()
             numstat_lines = lines[body_end_idx + 1:]
 
         insertions = 0
@@ -130,6 +132,8 @@ def extract_commits(repo_dir: Path, branch: str | None = None) -> pd.DataFrame:
 
         rows.append({
             "sha": sha,
+            "parents": parents,
+            "is_merge": len(parents) > 1,
             "date": pd.to_datetime(date_str, utc=True).tz_localize(None),
             "author_name": author_name,
             "author_email": author_email,

tests/test_smoke.py

@@ -158,3 +158,39 @@ def test_target_equals_workspace_keeps_legacy_layout(git_fixture, tmp_path):
     ], repo_dir=tmp_path / "single-repo")
     result = analyze(repo=repo, workspace=repo)
     assert result.out_dir == repo
+
+
+def test_assume_untagged_attributes_to_named_agent(git_fixture):
+    """`assume_untagged` re-attributes non-merge commits without a trailer."""
+    repo = git_fixture(commits=[
+        FakeCommit(files={"a.py": "1\n"}, subject="manual work"),  # no trailer
+        FakeCommit(files={"a.py": "2\n"}, subject="claude-paired",
+                   extra_trailers={"Co-Authored-By": "Claude Opus 4.7 <noreply@anthropic.com>"}),
+        FakeCommit(files={"a.py": "3\n"}, subject="another manual"),  # no trailer
+    ])
+
+    # Without the flag: 1/3 detected as AI-assisted.
+    baseline = analyze(repo=repo)
+    assert baseline.metrics.headline["n_ai_assisted"] == 1
+
+    # With assume_untagged="Claude Opus": all 3 attributed to Claude Opus.
+    cfg = Config()
+    cfg.agents.assume_untagged = "Claude Opus"
+    result = analyze(repo=repo, config=cfg)
+    assert result.metrics.headline["n_ai_assisted"] == 3
+    by_agent = result.metrics.by_agent.set_index("agent")["commits"].to_dict()
+    assert by_agent.get("Claude Opus", 0) == 3
+
+
+def test_assume_untagged_unknown_agent_raises(git_fixture):
+    """An unknown agent name raises with the list of valid names."""
+    repo = git_fixture(commits=[FakeCommit(files={"a.py": "1\n"}, subject="x")])
+    cfg = Config()
+    cfg.agents.assume_untagged = "ImaginaryBot"
+    try:
+        analyze(repo=repo, config=cfg)
+    except ValueError as e:
+        assert "ImaginaryBot" in str(e)
+        assert "Claude Opus" in str(e)  # listed as a valid option
+    else:
+        raise AssertionError("expected ValueError")