feat(git): line-level AI provenance and per-commit model id from agent-trace (#866)

Extend the agent-trace channel from commit attribution to line granularity.

AgentTraceIndex now builds a path-keyed line-share aggregate from each
record's ranges[]: the count of distinct lines an AI/mixed contributor wrote
(interval-union deduped across every record, so overlapping re-edits count
once and a bogus end_line can't blow memory) plus a {model_id: line_count}
breakdown. It is revision-independent and merged into git_metadata at the
indexer's existing path-keyed merge point, so it also covers the
rename-tracking walk. New columns: agent_line_count, agent_line_model_json.

resolve() now also returns the winning record's dominant model_id (models.dev
provider/model form), stored as git_commits.agent_model_id and set only when
the agent_trace channel actually wins (a git-ai note or service identity can
outrank it, and only the trace carries a model).

The git indexer stores only the AI numerator; the "% AI-written" denominator
is the file's current LOC, applied downstream, keeping ingestion LOC-decoupled.
Migration 0038 adds the columns; a _WALK_FIELD_EMPTIES guard keeps a transient
trace-read failure on an incremental update from zeroing a prior share.

Author: RaghavChamadiya

packages/core/alembic/versions/0038_agent_trace_line_provenance.py

@@ -0,0 +1,50 @@
+"""Line-level agent-trace provenance: model id + per-file AI line share.
+
+Line-level extension of the agent-trace channel. Per-commit: the ``model_id``
+(models.dev ``provider/model`` form) resolved from the agent-trace record that
+attributed the commit — populated only for the ``agent_trace`` channel, NULL otherwise.
+Per-file: the count of distinct file lines an AI/mixed contributor wrote
+(interval-union deduped across all trace records for the path) plus a
+``{model_id: line_count}`` breakdown, so "N% of this file is AI-written" and an
+opus-vs-sonnet split can be derived downstream against the file's current LOC.
+
+All columns are nullable / defaulted and back-populated on the next index. Data
+comes from ``.agent-trace/traces.jsonl`` only — repos without the standard pay
+nothing and keep NULL/zero throughout.
+
+Revision ID: 0038
+Revises: 0037
+Create Date: 2026-07-16
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers
+revision: str = "0038"
+down_revision: str | None = "0037"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column("git_commits", sa.Column("agent_model_id", sa.String(64), nullable=True))
+
+    op.add_column(
+        "git_metadata",
+        sa.Column("agent_line_count", sa.Integer, nullable=False, server_default="0"),
+    )
+    op.add_column(
+        "git_metadata",
+        sa.Column("agent_line_model_json", sa.Text, nullable=False, server_default="{}"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("git_metadata", "agent_line_model_json")
+    op.drop_column("git_metadata", "agent_line_count")
+    op.drop_column("git_commits", "agent_model_id")

packages/core/src/repowise/core/ingestion/git_commit_index.py

@@ -83,6 +83,7 @@ def load_commit_index(
     commit_sink: list[dict] | None = None,
     since_ts: int | None = None,
     provenance_classifier: object | None = None,
+    trace_index: object | None = None,
 ) -> dict[str, list[_CommitRec]]:
     """Bucket every commit in the recent history by the files it touched.
 
@@ -154,7 +155,10 @@ def load_commit_index(
     # git-ai authorship notes for this window (``{}`` unless the repo uses them).
     note_agents = load_git_ai_note_agents(repo, commit_limit)
     # Agent-trace records (empty after one stat call unless the repo has them).
-    trace_index = AgentTraceIndex.load(repo)
+    # The orchestrator may pass a shared instance so the trace file is read once
+    # per index rather than once per walk.
+    if trace_index is None:
+        trace_index = AgentTraceIndex.load(repo)
 
     bucket: dict[str, list[_CommitRec]] = {}
     commits_parsed = 0
@@ -262,6 +266,12 @@ def load_commit_index(
                     "agent_autonomy_tier": prov.autonomy_tier,
                     "agent_channel": prov.channel,
                     "agent_confidence": prov.confidence,
+                    # Model id only when the trace channel actually won: a note
+                    # or service-identity match can outrank the trace above, and
+                    # only the trace record carries a model.
+                    "agent_model_id": (
+                        trace_hit[2] if (trace_hit and prov.channel == "agent_trace") else None
+                    ),
                 }
             )
 
@@ -282,6 +292,7 @@ def load_deep_commit_index(
     skip: int,
     deep_limit: int,
     provenance_classifier: object | None = None,
+    trace_index: object | None = None,
 ) -> dict[str, list[_CommitRec]]:
     """Bucket commits OLDER than the recent window for *wanted_files* only.
 
@@ -343,7 +354,9 @@ def load_deep_commit_index(
     # git-ai notes across the deep region (``{}`` unless the repo uses them).
     note_agents = load_git_ai_note_agents(repo, skip + deep_limit)
     # Agent-trace records (empty after one stat call unless the repo has them).
-    trace_index = AgentTraceIndex.load(repo)
+    # Reuse the orchestrator's shared instance when supplied (single file read).
+    if trace_index is None:
+        trace_index = AgentTraceIndex.load(repo)
 
     bucket: dict[str, list[_CommitRec]] = {}
     commits_parsed = 0

packages/core/src/repowise/core/ingestion/git_indexer/README.md

@@ -114,7 +114,19 @@ Agent-trace records name a `vcs.revision` captured at edit or commit time, so
 `AgentTraceIndex` attributes a record to a commit when the revision matches
 the commit itself (confidence `high`) or one of its parents (the traced change
 landed in the child; confidence `medium`), and only when the record's file
-set overlaps the commit's changed paths.
+set overlaps the commit's changed paths. The winning record's dominant
+`model_id` (models.dev `provider/model` form) rides through to the commit for
+an opus-vs-sonnet split.
+
+`AgentTraceIndex` also produces a **per-file line share** from each record's
+`ranges[]`: the count of distinct lines an AI/mixed contributor wrote
+(interval-union deduped across every record for the path) plus a
+`{model_id: line_count}` breakdown. This is revision-independent (a record
+without `vcs.revision` still counts lines) and path-keyed, so the orchestrator
+merges it into `git_metadata` alongside the co-change / prior-defect signals
+and it works on the rename-tracking walk too. The `"N% AI-written"` denominator
+is the file's current LOC, applied downstream — the indexer stores only the AI
+numerator so it stays LOC-decoupled.
 
 Design rules:
 
@@ -134,11 +146,12 @@ Design rules:
   (`service_emails`, `footer_patterns`, `coauthor_patterns`) — additive on top
   of the built-ins, malformed entries skipped with a warning.
 
-Persisted as four nullable columns on `git_commits`
-(`agent_name`/`agent_autonomy_tier`/`agent_channel`/`agent_confidence`) and a
-per-file rollup on `git_metadata` (`agent_commit_count`, `agent_authored_pct`,
-`agent_tier_counts_json`), surfaced in the `/git-metadata` file view and the
-MCP `get_context` ownership block.
+Persisted as five nullable columns on `git_commits`
+(`agent_name`/`agent_autonomy_tier`/`agent_channel`/`agent_confidence`/`agent_model_id`)
+and a per-file rollup on `git_metadata` (`agent_commit_count`,
+`agent_authored_pct`, `agent_tier_counts_json` at the commit level;
+`agent_line_count`, `agent_line_model_json` at the line level), surfaced in the
+`/git-metadata` file view and the MCP `get_context` ownership block.
 
 ## Internal layout