DAWM Phase 3: selective persistence, contradiction handling, and learned abstain

Overview

This phase began as a narrow extension of the prior phase — could the reasoning cursor still operate when its input graph was produced by a learned word extractor instead of an oracle? — and ended as a self-contained architectural research program about persistent belief runtimes. Across eight milestones it produced four binding findings, three Pareto walls, and one closing architectural proposition.

The closing proposition (the phase's terminal finding):

A softmax over supported edges can arbitrate which destination to follow, but it cannot represent irreducible conflict as a separate categorical state. The arbitration question ("which destination?") and the calibration question ("is the destination set even decidable?") are two different computations and need two different output channels.

The final arc — three independent failed bridges (post-hoc closed-form, post-hoc learned head, and full cursor retrain) — is the empirical proof that those two computations cannot share one softmax. This proposition is the entire justification for the successor dual-channel design.

The pipeline at phase close

extract -> commit -> persist -> forget -> arbitrate -> calibrate -> abstain -> answer

• extract: a small learned word extractor, per-token (depth, relation, hedge) — done
• commit: a learned write policy = a small hedge head plus a deterministic local-window filter — done
• persist: multi-turn accumulated graph state — done
• forget: recency-weighted salience read as an additive log-weight bias — done (the headline positive)
• arbitrate: step-conditioned router softmax over supported edges — done
• calibrate: architecturally blocked — needs a dual output channel (all three bridge attempts failed)
• abstain: partial — the existing entropy gate handles the diffuse regime only; the peaked-but-split regime is blind to it
• answer: unified-action softmax with an ABSTAIN slot — done

The two unresolved arrows (calibrate, and abstain-for-peaked-but-split) are structurally bound together: the cursor's single unified-action softmax cannot carry both an arbitration signal and a calibration signal on the same scale.

Extraction is not commitment

• Replacing the oracle with the learned extractor preserved joint accuracy on the kinship microworld, with all prior gates within seed noise. The cursor runtime was untouched.
• Random false facts did NOT poison persistence — the cursor is structurally robust to random noise.
• Targeted ON-PATH noise DID poison persistence, bimodally across seeds: one seed collapsed to near-zero accuracy on the deepest query class while others held near baseline. Structural robustness has a real adversarial ceiling.
• A small hedge head on the extractor plus a deterministic local-window filter at edge-build time fully recovered the catastrophic tail: a large tail repair, no clean-preservation regression, and zero false commits across the trial budget. This is the first proof that extraction is a separate competence from commitment.

Selective forgetting improves reasoning (headline positive)

The persistent graph had been treated as a binary union — every committed edge equally salient forever. This milestone replaced the cursor's binary adjacency mask with an additive log-weight bias: current-turn edges carry full weight, prior-turn edges carry a global scalar weight in [0,1]. The cursor runtime change is a single line in the step function; with a binary adjacency it is bit-identical to the prior baseline, so the change is fully backward compatible and applied at inference time only (the cursor was never retrained for it).

Sweeping the prior-turn weight produced a genuine interior optimum with a clean memory-vs-reasoning trade-off curve:

• Full prior-turn weight (the prior baseline): the everything-persists reference point.
• A LOW-BUT-NONZERO prior-turn weight (the optimum): a strict Pareto win, gaining on clean reasoning quality and on adversarial (poisoned + filtered) safety simultaneously relative to the prior adversarial baseline.
• Zero prior-turn weight (drop prior edges entirely): clean accuracy on shallow queries surges, but accuracy on the deepest query class COLLAPSES to zero across all seeds, because that class genuinely requires a fact established earlier in the episode and never repeated.

Both extremes are wrong; the optimum sits in the interior. Per-seed, the clean and adversarial deepest-class curves are monotone in the weight down to the breaking point, and the shallowest query class (which never depends on prior-turn edges) is invariant across the entire sweep — exactly as the design predicts. This is the first time the project measured a hard memory <-> reasoning trade-off curve with a real interior optimum, and the first proof that the persistent graph is fundamentally a weighted memory rather than a binary union.

Two clean nulls — salience is relational, not intrinsic

Could per-edge features beat a single global scalar? Two clean nulls said no in the kinship world:

• A heuristic combining confidence, an inverse-hedge term, and an age decay: fails — confidence is saturated, hedge probability is noisy on clean tokens, and recency is WRONG-SIGNED (recency does not predict relevance in this microworld).
• A pure age-decay policy: also fails at its best decay setting; recency is still wrong-signed.

These two nulls prove the feature ceiling lives in the world, not in the architecture. Codified as the binding rule salience is relational: per-edge salience is recoverable only when competing evidence exists on the same (source, relation) slot. Without within-slot competition, any learned head over those features collapses to a global constant. The nulls are retained as cited prerequisites — any future "add freshness / add confidence" proposal must first refute them or demonstrate within-slot competition in its world.

A contradiction world unlocks the first positive per-edge salience

Rather than tune the model, the next milestone pivoted the WORLD: multi-source / conflicting assertions on the same (source, relation) slot, producing genuine per-edge variance (support count, refute count, is-contradicted, latest-support-turn). On a diagnostic two-supports-vs-one-support subtype, a support-count policy substantially beat the prior global-scalar baseline on the deepest query class, with tiny cross-seed variance — the win is structural, not noise. A second independent closed-form policy (a decay-free support ratio) confirmed it at essentially the same level.

This discharges the two preconditions the earlier nulls had set: edge-level variance exists (contradiction structure produces it), and the variance correlates with usefulness (support count predicts truth-ness here).

Honest boundary: support count is a "trust the majority" heuristic, not a truth detector — on a mirror subtype where the false answer happened to have more supports, it would confidently choose wrong with the same margin. The milestone tests whether salience can incorporate edge-level information, not whether it finds truth.

It also surfaced the failure that drives the rest of the phase: on the one-versus-one tied subtypes no symmetric closed-form policy can beat a coin flip, and the cursor's existing entropy abstain does NOT fire on tied contradictions — the mass is peaked-but-split, not diffuse. That is a calibration problem, not a salience one.

Three Pareto walls on abstain calibration

Three independent attempts to make the system abstain on irreducibly-tied contradictions, all landing on the SAME Pareto frontier set by the cursor's own internal mass variance:

Closed-form post-hoc trigger (three iterations).

• An additive logit boost: detection is near-perfect (clean separation in expectation between tied and resolved subtypes) but the additive nudge on the abstain logit cannot override the cursor's strongly peaked node logits — the abstain-when-unresolved rate is zero uniformly across the whole config and seed grid. Action must be categorical, not additive.
• A hard override on the SUM of the top-two cursor masses: detection and safety gates pass, but false-abstain on clean data inflates catastrophically — clean kinship slots where a child genuinely has two true parents trip the trigger even when the cursor is decisively on one.
• A hard override on the MIN of the top-two (requiring the cursor to be BALANCED): false-abstain improves sharply, but a Pareto wall appears — NO operating point satisfies all four gates at once. Cursor mass on tied contradictions is itself noisy, and its left tail overlaps the right tail of clean multi-true slots.

A small learned head over a handful of closed-form (adjacency, distribution) features. No regularization-and-seed combination passes all four gates. The head DID learn correct ordering at the population level and produced a SMOOTHER curve than the hard override (better clean preservation) but was strictly LESS aggressive on triggering. It moved along the same frontier; it did not break it. Notable positive: the head left the resolved subtype completely alone — the first demonstration in the project of CORRECT NON-INTERVENTION, learning "tied vs already-supported" as a real distinction rather than "any contradiction -> abstain."

Retraining the cursor itself with tied -> ABSTAIN gold labels. Two iterations. The first hit a hidden oracle dedup bug that destroyed the multiplicity signal (resolved and tied subtypes had identical training-time adjacency); this was diagnosed and fixed. The second (with the bug fixed and a support-arbitration collation making the subtypes genuinely distinct at training time) STILL fails — cursor retrain ends up the WORST of the three approaches: lowest abstain-on-tied, highest confident-wrong, AND it BREAKS resolved-subtype arbitration. This is the empirical proof of the closing finding: even given (i) the correct training-time adjacency signal and (ii) gold ABSTAIN supervision, the softmax-over-actions primitive conflates "two highly-weighted competing destinations" with "two correctly-supported multi-true destinations" because both produce structurally similar internal mass distributions. There is no place to put the "this is unresolvable" signal that doesn't also degrade arbitration.

Binding findings (catalog)

• Salience is relational, not intrinsic (the two nulls plus the contradiction-world positive): per-edge salience is recoverable only under within-slot competing evidence.
• Three regimes of uncertainty: diffuse (abstain), peaked-but-split (abstain), confident-single (answer). The existing entropy gate handles only the diffuse regime; peaked-but-split requires comparing cursor mass to the persistent adjacency structure, not just inspecting the distribution alone.
• Abstaining in a decisive arbitrator is categorically different from uncertain routing; an additive logit nudge cannot bridge it.
• Closed-form post-hoc detection has a noise floor equal to the cursor's own internal variance on the targeted regime.
• A learned head over post-hoc features can re-shape the decision boundary but cannot synthesize discrimination the input features do not carry.
• Arbitration is not calibration (the closing finding): softmax routing can adjudicate which edge to follow but cannot express whether the evidence itself is adjudicable. The single softmax output is structurally incapable of carrying both signals on the same scale.

Negative results as accumulated assets

The phase leaves four documented nulls and three Pareto walls, each retained as a cited precondition that gates future proposals (add-freshness, add-confidence, learned-scalar-head, post-hoc-abstain-trigger, retrain-cursor-for-abstain). This is the architecture-search pruning the chapter bought; the nulls are part of the specification, not historical residue.

Why the successor exists

The cumulative evidence localizes the bottleneck to the cursor's representational structure — not its training, its calibration, or its feature inputs. Detection is sufficient; post-hoc heads can re-shape but not bridge; cursor retrain cannot sharpen the internal mass and additionally breaks arbitration. The justified next move is a surgical extension of the OUTPUT structure: a parallel sigmoid abstain channel evaluated after the walk completes, fed by the same closed-form features, detached from the arbitration weights, and composing via a max with the existing abstain gate — leaving the locked step equations and the unified-action arbitration softmax untouched. Three independent milestones of attribution earn this relaxation under the project's surgical-relaxation discipline.

Reproducibility

Every milestone's sweeps are committed with fixed seeds; the same seed reproduces bit-exact closure. The salience-mode menu defaults to the global mode and reproduces the prior baselines bit-identically, so each mechanism is independently disable-flagged.