Verification

Structural verification

Every time the graph is updated, Causalist runs:

1. Cycle detection on causal edges. caused, prevented, and causes-to-fail must form a DAG. We use Tarjan's SCC algorithm in $O(V + E)$; any non-singleton SCC is a contradiction.
2. Pairwise contradiction detection. Edges $(X, Y, \text{cause})$ and $(X, Y, \text{prevent})$ with overlapping timestamps are incompatible; we surface both and ask the user (or the agent's introspection loop) to resolve.
3. Confidence floor. Edges below $c = 0.2$ are dimmed in the viewer; edges below $c = 0.05$ are dropped from reasoning context entirely.

From structural to interventional

Today's edges are observational or LLM-inferred. The research program for Causalist v2 is to promote them to interventional where possible.

Mutation testing

Given a function $f$, a test suite $T$, and an existing calls edge $(f, g)$:

1. Apply a semantic mutation to $g$ (e.g. flip a comparison, return a constant).
2. Re-run $T$. Let $T_{\text{fail}}(g')$ be the set of newly-failing tests.
3. For each $t \in T_{\text{fail}}(g')$, promote or create the edge $(g, t, \texttt{causes-to-fail})$ with confidence

estimated from test-history flake rate. This yields genuinely causal edges in Pearl's sense: we intervened, we observed, the counterfactual is the unmutated world.

Git commits as natural experiments

Every commit $c$ touches a set of files $F_c$ and either leaves the build green or turns a test $t$ red. Across many commits we have samples that let us estimate

Files with a large positive gap are load-bearing for that test. This isn't a true intervention (commits correlate with each other), but it's a principled way to rank candidate causal edges for mutation testing without having to mutate everything.

Counterfactual replay

Given a regression introduced by commit $c$, the counterfactual is "what would have happened if $c$ had reverted file $f$ to its state at $c-1$?" We use Claude + the test suite to hypothesize, then run the test to verify. Edges surviving this are labeled counterfactually-required.

The introspection loop

Every few agent iterations, a dedicated pass reads the graph and reports:

• Repeated actions — if the agent has called Edit on the same file 4+ times without an intervening successful test, it's stuck. Surface it.
• Contradictions — any new violations of DAG or pairwise checks.
• Low-confidence territory — clusters of nodes where average edge confidence < 0.3 deserve human review.

This snapshot gets injected back into the next turn's context, so the agent can course-correct on its own memory. It echoes Reflexion (NeurIPS 2023) — agents that read their own trajectory outperform agents that don't.