migration: 12 integer-brain kernels from idaptik sense-heavy sweep (cluster C14) (#590)

## Summary

Completes the exhaustive idaptik corpus sweep (C13 + C14). This cluster
covers the **sense-heavy** directory groups — `screens` (+
`training`/`locations`), `vm/lib/ocaml`, `engine` + `shared/src`,
`verisimdb` + `proven`, and the long-tail grab-bag — **148 `.res`
files** — extracting **12 new `Int->Int` brains**. Brain count **79 →
91**.

## New brains (12) — verified G1/G2/G4 green

`VictoryScreen` (2430) · `PlayTimeSplit` (2040) · `VeriSimError` (859) ·
`MissionBriefing` (285) · `IntroScreen` (254) · `InstructionCoprocessor`
(175) · `SkillTreeScreen` (114) · `VeriSimModality` (80) ·
`BalanceAnalyser` (68) · `LocationData` (61) · `AmbushObjective` (31) ·
`HighwayHits` (28)

(`N` = parity cases, all passing.) **~6,425 cases**, every brain
assail-clean. Independently re-verified, not just agent-reported.

## Disposition (148 files)

| | count |
|---|---|
| New brains | 12 |
| Already migrated | 45 |
| `NO_NEW_BRAINS` | 91 |

The 23 individual `vm/lib` instruction files are confirmed covered by
the migrated `Vm*` category brains; `shared/src` is a duplicate tree of
`src/shared` (already migrated). Several new brains are **residual
sub-brains earlier clusters scoped out** (screen score/grade kernels,
the opcode taxonomy, the VeriSim classifications). Full per-file ledger
in `EVIDENCE-C14-sense-sweep.adoc`.

## Corpus status

With **C13 (17) + C14 (12) = 29 new brains across 307 files**, the
idaptik logic corpus is exhaustively classified. A handful of straggler
leaves (`screens/main`, `screens/hub`, `vm/wasm`, two `devices/` subdirs
— ~8 files) are swept in a follow-up.

## Notes

- Brains stay `Int->Int` (the parity harness passes integer args only);
floats are carried as ×1000 milli-units / permille where integer-exact,
else host-side.
- Recurring authoring landmines re-confirmed: `total` is a reserved
word; the flat early-`return N;` idiom is the reliable many-branch style
that stays assail-clean.

https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s

---
_Generated by [Claude
Code](https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s)_

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

proposals/idaptik/migrated/AmbushObjective/AmbushObjective.affine

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
+//
+// AmbushObjective -- the assassin-survival objective co-processor, the pure
+// integer core extracted from idaptik src/app/screens/training/AssassinTraining.res
+// (the onUpdate ambush-counter logic, res:144-161). Per the DESIGN-VISION
+// ("AffineScript is the brain, JS/Pixi the senses; only primitives cross the wasm
+// boundary"), the host keeps the guard array, the pulsing warning Text, the HUD
+// string formatting and the victory-delay float timer; AffineScript owns only the
+// integer objective accounting over the assassin's failed-ambush count.
+//
+//## Why this split, not a port of AssassinTraining.res
+// AssassinTraining.res entangles (a) the Text pulse `0.5 +. 0.5 *. sin(t*3)` and
+// every container/position float (res:140-141), (b) the victory-delay countdown
+// `victoryDelay -. dt` (res:164-169), (c) the HUD string interpolation
+// "Ambushes survived: N / 3" (res:150,160), and (d) the integer objective decision:
+// sum the per-guard `getAssassinKillAttempts` into `attempts`, declare victory once
+// `attempts >= 3` (res:152). Only (d) is an integer decision; (a)-(c) are float
+// physics, async timing and string rendering that stay host-side. This file is the
+// verified core of that one decision, plus the two display read-outs the HUD needs
+// (clamped progress, remaining-to-go) so the host never re-derives the 0..3 band.
+//
+//## Objective encoding (the header contract for the JS host)
+// The assassin demo is won by forcing THREE failed ambushes. `attempts` is the host's
+// summed `getAssassinKillAttempts` over the guard array (a non-negative i32 in normal
+// play). The target is the literal 3 from res:152 (`attempts >= 3`). Boundary is
+// GREATER-OR-EQUAL, faithful to the .res `>=`, so attempts == 3 already wins and
+// attempts == 2 does not. All read-outs are total over every i32 input: a negative
+// host count (malformed) reads as zero progress / full remaining / not-met, never an
+// out-of-band code, so a stray encoding cannot spuriously complete the objective.
+
+// The number of failed ambushes that complete the objective (AssassinTraining
+// res:152 -- the literal 3 in `attempts >= 3`). The single source of truth for the
+// band width; every read-out below is stated against it.
+pub fn ambush_target() -> Int { 3 }
+
+//## is_objective_met -- whether the survive-the-assassin objective is complete.
+// The integer core of AssassinTraining res:152 (`attempts >= 3`). Boundary is
+// GREATER-OR-EQUAL, faithful to the .res `>=`. Returns 1 = met (fire the victory
+// transition), 0 = not yet. Total over every i32: a negative count is below 3 -> 0.
+pub fn is_objective_met(attempts: Int) -> Int {
+  if attempts >= 3 { 1 } else { 0 }
+}
+
+//## ambushes_survived -- the clamped 0..3 progress for the HUD read-out.
+// The display value behind "Ambushes survived: N / 3" (res:150,160). The raw host
+// count is clamped onto the closed 0..3 band so the HUD never shows a negative or an
+// over-count: a malformed negative reads 0, anything at or past the target reads 3
+// (the objective is complete, no further progress is meaningful). The clamp is to an
+// IN-BAND value (0 or 3), never an out-of-band sentinel, so assail stays clean and
+// no in-band code is shadowed.
+pub fn ambushes_survived(attempts: Int) -> Int {
+  if attempts < 0 { return 0; }
+  if attempts > 3 { return 3; }
+  attempts
+}
+
+//## ambushes_remaining -- failed ambushes still needed to win.
+// The complement of progress: how many more failed ambushes the assassin must be
+// forced into. Defined as 3 minus the clamped progress, so it is total and never
+// negative: at or past the target it is 0 (objective met), at a malformed negative
+// count it is the full 3. Mirrors the HUD's "/ 3" denominator semantics exactly.
+pub fn ambushes_remaining(attempts: Int) -> Int {
+  if attempts < 0 { return 3; }
+  if attempts >= 3 { return 0; }
+  3 - attempts
+}

proposals/idaptik/migrated/AmbushObjective/ambushobjective.config.mjs

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MPL-2.0
+// hypatia: allow cicd_rules/javascript_detected -- Deno trial component for nextgen-evangelist; production target is Rust/AffineScript (see proposals/nextgen-evangelist/README.adoc)
+//
+// affine-parity config for AmbushObjective.affine (idaptik AssassinTraining
+// survival-objective kernel; scalar i32 ABI). Each oracle re-derives the rule
+// straight from AssassinTraining.res INDEPENDENTLY of the .affine, so a codegen
+// regression surfaces as a differential mismatch.
+//
+// Oracle re-derivation (rule <- source site), independent of the .affine:
+//   ambush_target()         = 3                                   (res:152, the literal 3)
+//   is_objective_met(a)     = a >= 3 ? 1 : 0                      (res:152, `attempts >= 3`)
+//   ambushes_survived(a)    = clamp a onto 0..3                   (HUD "N / 3", res:150,160)
+//   ambushes_remaining(a)   = a<0 ? 3 : a>=3 ? 0 : 3-a            (complement of progress)
+
+// GREATER-OR-EQUAL boundary, faithful to the .res `>=` at res:152.
+const isObjectiveMet = (a) => (a >= 3 ? 1 : 0);
+// Clamp the host count onto the closed 0..3 band (negatives -> 0, over -> 3).
+const ambushesSurvived = (a) => (a < 0 ? 0 : a > 3 ? 3 : a);
+// Complement of the clamped progress against the target 3; total, never negative.
+const ambushesRemaining = (a) => (a < 0 ? 3 : a >= 3 ? 0 : 3 - a);
+
+// Sweep the host count across the band edges and just-inside/just-outside each cut:
+// the malformed negatives, 0, the 1/2/3 progression (2 = not-yet, 3 = exact win),
+// and over-counts (4..6) plus a large overflow so every clamp branch fires.
+const ATTEMPTS = [-5, -1, 0, 1, 2, 3, 4, 5, 6, 100];
+
+export default {
+  affine: "AmbushObjective.affine",
+  cases: [
+    { name: "ambush_target()", export: "ambush_target", args: [], oracle: () => 3 },
+    {
+      name: "is_objective_met over [-5..6]",
+      export: "is_objective_met",
+      args: [{ values: ATTEMPTS }],
+      oracle: isObjectiveMet,
+    },
+    {
+      name: "ambushes_survived over [-5..6]",
+      export: "ambushes_survived",
+      args: [{ values: ATTEMPTS }],
+      oracle: ambushesSurvived,
+    },
+    {
+      name: "ambushes_remaining over [-5..6]",
+      export: "ambushes_remaining",
+      args: [{ values: ATTEMPTS }],
+      oracle: ambushesRemaining,
+    },
+  ],
+};

proposals/idaptik/migrated/BalanceAnalyser/BalanceAnalyser.affine

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
+//
+// BalanceAnalyser -- the pure-integer impact-classification brain extracted from
+// src/app/screens/BalanceAnalyserModel.res (the numeric core its
+// BalanceAnalyserCoprocessor.res binding routes to balanceanalyser.wasm). The
+// model is overwhelmingly senses: it PARSES the balance-report JSON (every
+// string key, every Float field), formats recommendation STRINGS, and builds
+// the PixiJS display lines. Per the DESIGN-VISION ("AffineScript is the brain,
+// JS/Pixi the senses; only primitives cross the wasm boundary"), all of that
+// -- the JSON, the version/parameter/reason strings, the win-rate and
+// difficulty FLOATS, the per-impact colour ints -- stays host-side.
+//
+// RE-DECOMPOSITION. The separable integer decisions are the impact-level
+// comparison (getByImpact's filter) and the critical-issue test
+// (hasCriticalIssues). The ReScript switches the `impactLevel` variant
+// (Minor | Moderate | Major) to a 0..2 ordinal (impactValue) and then compares
+// ordinals; we re-decompose the variant as that 0..2 ordinal directly -- the
+// order the .res `impactValue` switch already imposes (Minor < Moderate <
+// Major). The variant IS the ordinal; no impact strings cross. The float
+// rounding helpers (round1 / pct100 / winRatePct) are senses and stay host-side.
+//
+//## Impact-level encoding (the header contract for the JS host)
+//   ord  level       (mirrors BalanceAnalyserCoprocessor IMPACT.{MINOR,MODERATE,MAJOR})
+//     0  Minor
+//     1  Moderate
+//     2  Major
+//   An ordinal outside 0..2 is not a defined impact: impact_valid reports 0 and
+//   impact_value returns the out-of-band sentinel -1 (never an in-band ordinal),
+//   so an off-domain input cannot pass as a real impact. -1 is a sentinel, not a
+//   clamp (assail stays clean).
+//
+//## Filter / threshold contract (the decisions getByImpact + hasCriticalIssues make)
+//   passes_impact(item_ord, min_ord) -> 1 when the item's impact meets or
+//     exceeds the minimum (item_ord >= min_ord), else 0. This is getByImpact's
+//     `impactValue(item.impact) >= impactValue(minImpact)` kept-row test.
+//   has_critical_issues(major_count) -> 1 when the report has any major issue
+//     (major_count > 0), else 0. This is hasCriticalIssues' `majorIssues > 0`.
+//   Both treat their inputs as plain counts/ordinals; the host owns the
+//   recommendation array, the strings, and the float fields.
+//
+// PURE: integers only, no floats, no strings, no arrays, no effects, no I/O.
+
+//## The number of impact levels (Minor, Moderate, Major).
+pub fn impact_level_count() -> Int { 3 }
+
+//## Whether a host integer names a defined impact level. 1 = valid, 0 = out of band.
+pub fn impact_valid(ord: Int) -> Int {
+  if ord < 0 { 0 } else { if ord > 2 { 0 } else { 1 } }
+}
+
+//## Canonicalise an impact ordinal: identity on a valid 0..2 ordinal, the
+// out-of-band sentinel -1 otherwise. Mirrors impactValue's role as the
+// variant's ordinal; -1 is never an in-band ordinal so out-of-band input can
+// never be confused with a real impact (sentinel, not a clamp).
+pub fn impact_value(ord: Int) -> Int {
+  if impact_valid(ord) == 1 { ord } else { -1 }
+}
+
+//## Whether an item's impact meets or exceeds the minimum: 1 keep, 0 drop.
+// getByImpact's `impactValue(item) >= impactValue(min)` row filter.
+pub fn passes_impact(item_ord: Int, min_ord: Int) -> Int {
+  if item_ord >= min_ord { 1 } else { 0 }
+}
+
+//## Whether the report has any major issue (majorIssues > 0): 1 yes, 0 no.
+// hasCriticalIssues' test. A non-positive count is never positive -> 0.
+pub fn has_critical_issues(major_count: Int) -> Int {
+  if major_count > 0 { 1 } else { 0 }
+}

proposals/idaptik/migrated/BalanceAnalyser/balanceanalyser.config.mjs

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MPL-2.0
+// hypatia: allow cicd_rules/javascript_detected -- Deno trial component for nextgen-evangelist; production target is Rust/AffineScript (see proposals/nextgen-evangelist/README.adoc)
+//
+// affine-parity config for BalanceAnalyser.affine (idaptik impact-classification
+// brain; scalar i32 ABI). The oracle re-derives each function from the ORIGINAL
+// BalanceAnalyserModel.res semantics (NOT from the .affine) so a codegen
+// regression surfaces as a differential mismatch.
+//
+// From BalanceAnalyserModel.res:
+//   getByImpact (lines 348-356): impactValue Minor=>0 Moderate=>1 Major=>2;
+//     keep iff impactValue(item.impact) >= impactValue(minImpact)
+//   hasCriticalIssues (lines 435-439): r.majorIssues > 0
+// Impact variant Minor/Moderate/Major maps to ordinals 0/1/2.
+
+// Independent re-derivation of the impact validity from the .res ordinal domain.
+const impactValid = (o) => (o >= 0 && o <= 2 ? 1 : 0);
+
+// Independent re-derivation of impactValue (the variant's ordinal) from the .res.
+const impactValue = (o) => (impactValid(o) ? o : -1);
+
+// Independent re-derivation of getByImpact's row filter from the .res.
+const passesImpact = (item, min) => (item >= min ? 1 : 0);
+
+// Independent re-derivation of hasCriticalIssues from the .res.
+const hasCritical = (n) => (n > 0 ? 1 : 0);
+
+export default {
+  affine: "BalanceAnalyser.affine",
+  cases: [
+    {
+      name: "impact_level_count()",
+      export: "impact_level_count",
+      args: [],
+      oracle: () => 3,
+    },
+    {
+      name: "impact_valid over ord[-3..6]",
+      export: "impact_valid",
+      args: [[-3, 6]],
+      oracle: (o) => impactValid(o),
+    },
+    {
+      name: "impact_value over ord[-3..6]",
+      export: "impact_value",
+      args: [[-3, 6]],
+      oracle: (o) => impactValue(o),
+    },
+    {
+      name: "passes_impact over (item[-1..3], min[-1..3])",
+      export: "passes_impact",
+      args: [[-1, 3], [-1, 3]],
+      oracle: (item, min) => passesImpact(item, min),
+    },
+    {
+      name: "passes_impact exact impact pairs 0..2 x 0..2",
+      export: "passes_impact",
+      args: [{ values: [0, 1, 2] }, { values: [0, 1, 2] }],
+      oracle: (item, min) => passesImpact(item, min),
+    },
+    {
+      name: "has_critical_issues over major_count[-2..10]",
+      export: "has_critical_issues",
+      args: [[-2, 10]],
+      oracle: (n) => hasCritical(n),
+    },
+  ],
+};

proposals/idaptik/migrated/EVIDENCE-C14-sense-sweep.adoc

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+= Cluster C14 (sense-heavy directory sweep) — migration evidence (2026-06-14)
+:toc: macro
+
+[IMPORTANT]
+====
+*Verdict: 12 new integer brains extracted; the remainder are host-side senses,
+FFI binding shims, or already-migrated.*
+
+This cluster completes the exhaustive corpus sweep begun in C13, covering the
+six remaining sense-heavy directory groups: `src/app/screens` (top-level),
+`src/app/screens/{training,locations}`, `vm/lib/ocaml`, `src/engine` +
+`shared/src`, `src/app/{verisimdb,proven}`, and the long-tail grab-bag
+(`narrative`, `tools`, `tea`, `pickups`, `pixi`, `burble`, `vm`, `bindings`,
+`idaptik-ums/src`, loose `src`/`src/app`). 148 `.res` files.
+
+All 12 new brains were *independently re-verified* by the parent session
+(G1 compile, G2 differential parity all-pass vs an independent JS oracle,
+G4 assail zero high findings). Total brain count: 79 -> 91.
+====
+
+== Disposition summary
+
+[cols="3,1,1,1,1",options="header"]
+|===
+| Directory group | Files | New | Already | No-brain
+| `src/app/screens` (top-level)        | 25 | 5 |  1 | 19
+| `screens/training`+`locations`       | 23 | 2 |  0 | 21
+| `vm/lib/ocaml`                       | 34 | 1 | 27 |  6
+| `src/engine`+`shared/src`            | 27 | 0 | 17 | 10
+| `src/app/verisimdb`+`proven`         | 16 | 3 |  0 | 13
+| long-tail grab-bag                   | 23 | 1 |  0 | 22
+| *Total*                              | *148* | *12* | *45* | *91*
+|===
+
+== New brains (12) — all G1/G2/G4 green
+
+[cols="2,1,4",options="header"]
+|===
+| Brain | G2 | Extracted logic
+| `VictoryScreen`         | 2430/2430 | performance-grade: victory_score (100 base, alert/time/command penalties, covert/crit bonuses) + S/A/B/C/D banding (4..0)
+| `PlayTimeSplit`         | 2040/2040 | total_minutes -> hours(/60)/minutes(%60)/has_hours (harness-Int form of the float-seconds render kernel)
+| `VeriSimError`          | 859/859   | HTTP status -> 20-category ordinal + is_retryable(category) + is_status_retryable
+| `MissionBriefing`       | 285/285   | difficulty/guard-count/threshold, objective-state predicates, completion + progress%, par-time & S-grade alert budget
+| `IntroScreen`           | 254/254   | tutorial paginator state machine: next_page (bounded), is_last_page, 1-based page_label
+| `InstructionCoprocessor`| 175/175   | opcode arity-and-reversibility taxonomy: count/valid/arity/tier/is_self_inverse/invert/invert_round_trip
+| `SkillTreeScreen`       | 114/114   | XP-threshold classification: rank 0..4 -> threshold, is_maxed, xp_fill_permille (0..1000)
+| `VeriSimModality`       | 80/80     | 8-member modality band (0..7) + 5-member drift-level ordinal (0..4) + drift_is_actionable/critical
+| `BalanceAnalyser`       | 68/68     | impact-level classification (Minor/Moderate/Major -> 0..2) + passes_impact + has_critical_issues
+| `LocationData`          | 61/61     | world-map attributes: location_count, environment_kind (idx -> ordinal), device_count
+| `AmbushObjective`       | 31/31     | 3-failed-ambush survival objective: is_objective_met (attempts>=3), clamped progress, remaining
+| `HighwayHits`           | 28/28     | hit-budget accounting (max 3, game_over, clamped remaining) + per-lane traffic-direction parity (+/-1)
+|===
+
+== NO_NEW_BRAINS (91) and ALREADY (45)
+
+* *Screens / locations (~40):* PixiJS lifecycle orchestrators, navigation, static
+  LocationData-record screens, i18n string menus, float layout/camera math.
+* *FFI binding shims + render-glue (~30):* `*Coprocessor.res`, Pixi/Motion/Sound
+  bindings (`Pixi.res` 321 externals), render-decision bridges (float ABI).
+* *Float-domain cores (~10):* SafeFloat/SafeAngle (NaN-guarded f64), Resize,
+  glitch-FX, training dt-physics state machines.
+* *String/JSON/HTTP cores (~15):* VeriSim HTTP/JSON FFI bridges, PhoenixSocket,
+  SafeJson, lore/DataFiles, terminal/editor IPC glue.
+* *Orchestration / host state (~10):* Main, GameLoop, GetEngine, VM orchestrator,
+  SubroutineRegistry, registries and circular-dep-breaker refs.
+* *VM instructions (23, ALREADY):* `Add.res`..`Xor.res` are each covered by the
+  migrated `Vm{Arith,Bitwise,MulDiv,Stack,Memory,Port,Control,Ancilla,Instruction}`
+  category brains (confirmed by reading each category `.affine`).
+* *`shared/src` (17, ALREADY):* a duplicate tree of `src/shared`; every brain was
+  already extracted (Coprocessor, Kernel_*, ResourceAccounting, DeviceType, ...).
+
+== Residual gap (closed in a follow-up)
+
+The screens sweep covered the top level and `training`/`locations`; the small
+`screens/main` (3), `screens/hub` (1), `vm/wasm/src` (2), and `devices/{types,
+common}` (2) leaves are swept separately. (`docs/.../templates/*.res` is a
+template, not source.)
+
+== Method note
+
+Brains stay `Int(...)->Int` (the parity harness passes integer arguments only);
+floats are carried as x1000 milli-units / permille where integer-exact, else
+host-side. Two recurring AffineScript authoring landmines were re-confirmed and
+worked around: `total` is a *reserved word* (use `acc`/`req_total`), and the flat
+early-`return N;` idiom (not deeply nested deferred-brace `if/else`) is the
+reliable many-branch style that stays G4-clean. Several brains are residual
+sub-brains earlier clusters scoped out (the Coprocessor/Kernel/Resource set,
+ThreatClass, the screen score/grade kernels), recovered here as separable
+pure-integer kernels matching the existing `*Coprocessor.res` host bridges.