Date: 2026-09-26 Status: branching reader and exact runtime qualified; frozen Foundation generative bridge needs improvement

Objective

Replace the structurally trivial V2 multi-hop curriculum with a task that requires query-conditioned choice among several complete paths, preserve C1-C4 and G as separate sources, connect the resulting evidence to the frozen Foundation, and classify or repair every failed boundary without repeating an unchanged experiment.

The implementation uses mechanisms, not copied project code, from these reference lines:

• CEPE and Fusion-in-Decoder: independently encoded external evidence;
• OpenFlamingo: trainable external access around a frozen backbone;
• NBFNet/DrKIT: learned multi-hop relational scoring;
• Set Transformer/Deep Sets: source-set aggregation without a local lane-order assumption;
• CopyNet and pointer-generator networks: separate source copying from ordinary generation.

The broader source/edit map is recorded in docs/research/2026-09-26-modular-research-and-edit-map-v1.md.

The shortcut V4 removes

The previous three-hop reader reached 100%, but its audit found exactly one structurally valid A→B→CLASS path for each query. A deterministic join therefore also reached 100%. That result established learned plumbing, not ambiguous query-conditioned selection.

Every V4 group contains the same local C1-C4 bytes and three complete valid paths. Only G changes:

G.POLICY = SPEED  -> path A
G.POLICY = SAFETY -> path B
G.POLICY = VALUE  -> path C

Each terminal edge has three attributes. Their arrangement guarantees that a different branch wins each policy. Train, development and sealed identities are disjoint.

Implemented modules

BranchingPathReaderV4

[private artifact]

• shared order-aware entity encoder;
• learned START→A, A→B and B→CLASS join scorers;
• learned policy and terminal-attribute interaction;
• joint score over the complete A×B×CLASS path cube;
• structural-validity auxiliary loss that treats all complete paths as valid;
• policy auxiliary loss;
• exact payload pointer with source and coordinate provenance;
• independent contribution telemetry for C1-C4/G;
• abstention when G policy/start or a required relation family is absent.

Initialization reuses the qualified V2 structural scorer weights. The V4 policy mechanism and its interaction with the branching task are new.

BranchingContextFusionV4

[private artifact]

• uses the frozen qualified reader to identify evidence;
• retains the three selected records and G as separate lanes;
• encodes lanes with shared encoder weights and separate activations;
• performs five parallel Foundation→lane access calls;
• applies independent sigmoid contribution gates, not a source softmax;
• mixes sources through a DeepSets-style sum+max projection;
• trains only the external fusion/access module while Foundation stays frozen.

Agent runtime adapter

ContextBranchingPathReaderV4Adapter connects the reader to ContextPacket V1 and the existing RETURN_EXACT output mode. All five sources are presented to the reader in one operation. The packet retains all three evidence coordinates, source versions, policy, confidence and checkpoint identity.

Locked data

Reader curriculum:

The Foundation/runtime bridge received a separate 128-group, 384-row sealed set, locked before bridge training:

[checksum retained in the private evidence record]

Runs and results

Run 1 — initial reader execution

The first implementation scored every graph separately. It performed hundreds of tiny GPU launches per step and did not reach a metric checkpoint in a useful time. The process was stopped. No result was inferred from it.

Repair: batch graphs with equal A/B/CLASS candidate shapes. A five-step sample dropped to about 2.3 seconds and showed immediate loss reduction.

Run 2 — branching reader

Candidate:

• parameters: 100,805;
• SHA-256: [checksum retained in the private evidence record];
• runtime artifact: [retained internal evidence].

Qualified claim: within the tested typed family, a learned module selects the correct payload among three structurally valid cross-Drone paths using a query-conditioned policy from G, and generalizes to untouched identities.

Run 3 — first Foundation bridge trajectory

The reader-grounded fusion learned rapidly on a 48-row development sample:

Implementation code and detailed machine records are retained separately. This public edition presents the study methods, aggregate results, and qualification boundaries.

During required-source ablation, the batched reader encountered a graph with no CLASS candidates and attempted a zero-width projection. This was an evaluation robustness bug, not a learned-result failure. Sealed bridge data was not opened.

Repair: missing required relation families now return reader abstention. A regression test covers the batched path.

Run 4 — repaired Foundation bridge

The repaired run exposed initialization/generalization sensitivity. It reached 58.33% on the 48-row sample at step 400 and 236/384 = 61.46% on full development. Complete groups were 28/128 = 21.88%.

The qualified reader remained 384/384 on the same rows. Most Foundation misses were one-character corruptions, for example:

pw2kd1v -> ps2kdiv
p7z1sf1 -> p7zimf1
pesld66 -> pemmd66

Causal controls behaved correctly:

• G ablation: 0%;
• required local-lane ablations: 14.47% to 23.29%;
• protected Foundation state: unchanged;
• bridge sealed set: unopened.

Classification: FOUNDATION GENERATIVE COPY / BRIDGE GENERALIZATION FAILURE.

The neural bridge exists and can learn some examples, but it is not qualified. The lucky first trajectory is not treated as evidence of a stable candidate.

Run 5 — modular exact-output repair

For RETURN_EXACT, the agent now uses the already implemented deterministic ExactRenderer on the verified ContextPacket. This follows the copy-mechanism research boundary: source-specific bytes are copied rather than regenerated.

Fresh V4-B sealed runtime result:

The runtime was launched in a fresh Python process, reloaded candidate hash 7d4a2d...c19403, and reproduced the qualification result.

Findings

1. C1-C4 and G are simultaneously available to one learned reader operation.
2. The answer requires three local evidence records plus a policy in G.
3. Several structurally valid paths exist, so structural uniqueness cannot solve the task.
4. Changing only G changes the selected path on the same local Context bytes.
5. The learned reader generalizes perfectly to the locked sealed identity set.
6. Provenance survives through ContextPacket and fresh-process restore.
7. Exact output works end to end through the correct modular copy path.

Qualification limits

• The frozen Foundation does not reliably regenerate arbitrary selected bytes; its measured V4 development accuracy is 61.46%.
• V4 does not yet prove open-domain unstructured multi-Drone reasoning.
• The policy vocabulary and graph grammar are bounded and typed.
• The reader selects a path before Foundation access; it does not prove that Foundation itself discovered the multi-hop path.
• Learned semantic GENERATE/TRANSFORM use of several lanes remains a future qualification target.
• The neural fusion candidate is retained as negative/diagnostic evidence and must not be promoted.

Proposed follow-up

1. Add semantic reasoning targets whose answers are not arbitrary byte copies, so Foundation integration can be measured without conflating reasoning and rendering.
2. Compare a small pointer/copy Decoder MicroModel against deterministic copy only when neural selection inside the output layer is actually required.
3. Train the explicit fusion bridge under multiple fixed seeds and use a predeclared development selection rule; do not reuse V4-B sealed rows.
4. Expand branching policies and relation types, then test incomplete paths, conflicting authority/freshness, duplicated evidence and more than three branches.
5. Preserve the qualified reader as one polymorphic reader behind the stable ContextPacket contract; it does not replace unstructured, AST or graph specialist readers.