# Follow helper values before inference

Observed on 2026-10-08, compiler source
`246fdf5b0d40a1d1e148560f8389cdfb364da998`, Go 1.27.1, macOS arm64.
The source is [PR #1373](https://github.com/kimjooyoon/meta-ontology-go/pull/1373).
`compiler.json` records a clean VCS build; `compiler-binary.sha256` records the
temporary executable, which is not retained here. This is a development build,
separate from the published 0.6.8 binary.

## Source-only observation

```sh
gooo body-context --value-flow --activity Classify \
  --feature-version triple_record_field_flow_v2_shared_v1 \
  examples/text-operations/source.gooo.fixture
```

`context.json` is the exported graph: RESOLVED, four helper identities, 115 nodes
and five scalar call-result nodes, including the nested HasSuffix invocation.
The origin context is ENCODED. Predictions and candidate tests are both zero.
The earlier source declined this same analysis at the HasSuffix function name.

The independent test evaluator reads graph edges and original source spans. It
matches a separate Go policy on twelve filenames, three fields and both choices
(72 field values). Five more inputs exercise a helper's three return paths, and
three inputs exercise nested transport through an internal record. These are
separate finite test fixtures. Source relationships, native runtime cases and
model predictions are different observations.

## Compare the unchanged input contracts

From the pinned compiler checkout (which pins SDK v0.2.25-experimental):

```sh
go run /path/to/feature-order.go --compiler /path/to/gooo \
  --source examples/text-operations/source.gooo.fixture --out /new/output/path
```

The script exports all eight arrangements with both existing feature contracts,
checks RESOLVED/ENCODED and zero inference/outcome evaluation, and groups complete
float32 arrays by every bit. `order-features/` retains all source variants,
sixteen raw exports and the summary.

| Input contract | Source families | Arrangements | Different arrays | Maximum compatible rows |
| --- | ---: | ---: | ---: | ---: |
| v1 expression context | 1 | 8 | 2 | 2/8 |
| v2 origin context after helper expansion | 1 | 8 | 4 | 4/8 |

The bound uses the accepted masks `7 XOR order` from the earlier filename-order
study. They are supplied label assumptions, not newly established by this
source-only script. Each equal-array group needs a single deterministic answer;
its largest accepted-label count contributes to the row-weighted bound.

Origin counts now distinguish the original name from the helper-computed stem.
The v2 groups still pair orders 0/1, 2/3, 4/5 and 6/7: changing && to || remains
invisible in the existing projection. This is an input-information observation,
not a measured model accuracy improvement. No v2 weights were trained or used.
The next version needs operator distinctions as well as source value relations.

## Existing-model construction and native replay

`model-bound.json` uses the unchanged v1 shared QAT model. Construction made one
prediction and evaluated one candidate in the original order, satisfying 5/5
construction cases and 15/15 fields. Native execution passed twelve distinct
filenames. `replay.json` repeats the saved composition with twelve passing cases
and zero new model calls. The actual and expected JSON values were recounted and
agreed in both reports. The earlier eight-order v1 result remains 1/8 first
choices and 36 total candidate evaluations; this run does not supersede it.

The origin graph experiment and the v1 model run are separate paths. The v1
model does not consume the new helper graph. Weights were unchanged; whole-host
CPU utilization and training-set overlap were not measured.

`SHA256SUMS` covers all retained files except itself. Verify it from this directory
with `shasum -a 256 -c SHA256SUMS`.