git

name

git

description

Git for agents — the cockpit that composes the commit DAG (scene) with the commitments (trail) into ONE graph joined by commit SHA, rendered as four lenses — Evolution (the commit DAG carrying the why, with counterfactual edges = the road not taken), Research (the commitment/hypothesis map), Commitments (what governs each scope), Live (agents now). One surface, lenses not modes; the commit is the truth, the rest decorates it. Run `gfa` (provisional command) → ~/.anu/git/<repo>/index.html. Use when the user wants to see a project evolving WITH its decisions and roads-not-taken, runs `gfa`, or asks for the git-for-agents view.

git: the agent's git — evolution carrying the why

Plain git remembers what changed. A status visualizer adds who / when. This adds why and the road not taken — on the commit DAG itself — so a future agent can continue the project without silently losing its reasons.

The one model

One substrate — project evolution through committed steps — under different lenses, not different trackers. A hypothesis is just a build-step that made a bet. The view takes the shape of the work (auto-detected from the trailer mix); it never forks the data model.

• Evolution (the building default): the commit DAG (scene) as the spine; each commit decorated from the trail — ⚐ branch-points, counterfactual edges (a dashed fork to a dead-end = an Alternatives: road not taken), and a click → work-step panel (intent · delta · introduced · honored · roads-not-taken).
• Research (the default when predictions dominate): the commitment/hypothesis map — claims, status, the tempo of what's resolved vs still open.
• Commitments: what governs each scope — ⊚ awaiting a verdict · ⚠ at-risk (stuck) · ● active constraints.
• Live: which agents are acting now (via viz; wired in Phase 3b).

How it's built — compose, don't fork

gfa runs trail (the commitments, no-LLM trailer parse) and scene (the DAG), pins the commitment-bearing commits so decision history isn't collapsed out of the frontier, and joins them by commit SHA into one git.json the page lays out client-side. scene/trail stay standalone.

The law (so it doesn't rot)

Observed-transition first: what changed → who → constraints active → alternatives rejected → story. The real commit + diff is the node; the why decorates it, never replaces it. Record Alternatives: only at genuine branch points (architecture/interface/tool choices, overrides, accepted tradeoffs) as a byproduct — not on every commit, or it becomes synthetic garbage.

Recording roads-not-taken (the capture loop)

The counterfactual edges only exist if agents record them. The discipline is cheap, a byproduct, and branch-points only:

When — a branch point, not every commit. You changed architecture or an interface · rejected an obvious approach · overrode or superseded a commitment · chose between tools/libraries/protocols · accepted a tradeoff with future cost · the human asked "why this way?". A typo fix or a rote edit is not a branch point — recording one is slop.

Capture at plan time, before editing. You already weigh the options and then throw them away (the "Decision Shadow"). Catch them then — name the path you took and the ones you didn't while they're fresh — and let it ride the commit that enacts the choice.

How — a Commitment: with Alternatives: on that commit:

Commitment: <slug>
Type: decision
Scope: <files it governs>
Claim: <the call, one line>
Caused: <the diff>
Alternatives: <road not taken> — <why not> | <another road> — <why not>

Alternatives: is pipe-separated; each entry becomes a counterfactual edge in the Evolution lens (the — splits off the why-not). Click the commit and the roads it didn't take light up off its node.

The honest floor: if you can't name a real alternative a competent agent would have weighed, it wasn't a branch point — don't invent one. An honest gap beats synthetic garbage.

Use

• gfa — build + render + open the cockpit at ~/.anu/git/<repo>/index.html.
• gfa open — re-open the last render without rebuilding.
• gfa watch — a live re-render as you commit.

The trailers that fill it are trail's (Commitment / Type / Scope / Caused / Alternatives / …). See the trail skill for the recording discipline. (gfa is a provisional command name; the plugin dir is git.)