wip(C7 drafts): preserve UNVERIFIED player-cluster .affine drafts

The C7 (player) migration agent produced 8 .affine kernel drafts but
timed out before writing any parity oracle (config.mjs), boundary proof,
or evidence. These are UNVERIFIED — no gate has been run on them. They
are committed only to preserve the re-decomposition head-start (the
container is ephemeral); they are NOT claimed as 4-gate-green and the PR
stays draft until they are.

Status recorded as IN_PROGRESS / drafted_unverified in
proposals/idaptik/migration-map.json (cluster C7). Next: write
independent oracles, run compile/parity/boundary/assail, fix as needed,
then mark C7 DONE.

Kernels (unverified): CriticalRoll, PlayerAttributes, QCertifications,
SkillRank, SkillAbilities, QPrograms, JessicaLoadout, JessicaBackground.

https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s

Author: claude

proposals/idaptik/migrated/CriticalRoll/CriticalRoll.affine

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// CriticalRoll -- the pure probability/threshold kernel re-decomposed from
+// src/app/player/CriticalRoll.res. The ReScript original entangles three things:
+// a non-deterministic draw (Math.random()), two attribute-driven threshold
+// formulae for Jessica, and a three-way classification of the draw against a
+// success and a failure threshold shared by Jessica and Q. Per the DESIGN-VISION
+// ("AffineScript is the brain, JS/Pixi the senses; only primitives cross the wasm
+// boundary"), neither the draw nor the variant labels are the unit of migration.
+// What crosses is the deterministic arithmetic: the two thresholds and the band
+// the comparison falls into. The host owns the entropy (Math.random), the rate
+// tables QCertifications already serves, the rollResult record, and the outcome
+// labels and colours. The kernel is stateless and total: every Float the boundary
+// admits yields a defined Int verdict or Float threshold, never a trap.
+//
+//## Why this split, not a port of jessicaRoll/qRoll
+// jessicaRoll and qRoll each draw a random number, look thresholds up (Jessica by
+// formula, Q by host rate table), then classify. The draw is impure and the Q
+// lookups are discrete table reads with no arithmetic, so both stay host senses.
+// The arithmetic that remains -- the two Jessica formulae and the one shared
+// classification -- is what the co-processor owns. Both call sites feed the same
+// classify_outcome with their respective thresholds, so the brain has one decision
+// rule and the host supplies the two numbers however it sourced them.
+//
+//## Outcome encoding (the header contract for the JS host)
+// The rollOutcome variant collapses to an ordinal the host maps back to the
+// variant and thence to a label/colour:
+//   0 CriticalSuccess   1 Normal   2 CriticalFailure
+// classify_outcome returns exactly one of these three. The boundaries match the
+// ReScript verbatim: roll < critSuccess -> 0; else roll > 1 - critFail -> 2; else
+// 1. The success test wins ties at the lower edge (strict <), the failure test at
+// the upper edge (strict >), so a roll sitting exactly on a threshold is Normal,
+// identical to the ReScript if/else chain.
+//
+//## Float contract
+// roll, crit_success and crit_fail cross as f64 (proven to marshal both ways;
+// cf. migration/bindings/Maths.wasm and PlayerHP.wasm). roll is the host's draw in
+// [0, 1); crit_success and crit_fail are probabilities in [0, 1]. The float
+// comparisons drive an Int verdict, which the wasm backend compares as i32, the
+// working subset for float-fed branches. jessica_crit_success and
+// jessica_crit_fail return f64 thresholds the host either feeds straight back into
+// classify_outcome or displays in the rollResult.
+
+//## Jessica's critical-success threshold
+// min(0.25, 0.05 + (primaryStat - 100)/1000), the jessicaRoll line verbatim in
+// f64. Higher primary stat raises the chance; the cap at 0.25 is the design
+// ceiling. primaryStat arrives as a Float, so the division is pure f64 and no
+// int->float is implicated. Branchless via min_float rather than a Float if/else.
+pub fn jessica_crit_success(primary_stat: Float) -> Float {
+  min_float(0.25, 0.05 + (primary_stat - 100.0) / 1000.0)
+}
+
+//## Jessica's critical-failure threshold
+// max(0.01, 0.10 + (100 - wil)/1000), the jessicaRoll line verbatim in f64.
+// Higher willpower lowers the chance; the floor at 0.01 is the design minimum.
+// Branchless via max_float. wil is a Float host-side, so the subtract and divide
+// are pure f64.
+pub fn jessica_crit_fail(wil: Float) -> Float {
+  max_float(0.01, 0.10 + (100.0 - wil) / 1000.0)
+}
+
+//## Shared three-way classification
+// The outcome if/else chain shared by jessicaRoll and qRoll, in isolation:
+//   if roll < crit_success            -> CriticalSuccess (0)
+//   else if roll > 1.0 - crit_fail    -> CriticalFailure (2)
+//   else                              -> Normal          (1)
+// Flat guarded returns rather than nested if/else; the parser dislikes deep
+// nesting and the order of the guards preserves the ReScript precedence (success
+// tested first, then failure, Normal as the fall-through). The strict comparisons
+// mean a roll exactly on a boundary is Normal, matching the ReScript.
+pub fn classify_outcome(roll: Float, crit_success: Float, crit_fail: Float) -> Int {
+  if roll < crit_success { return 0; }
+  if roll > 1.0 - crit_fail { return 2; }
+  1
+}

proposals/idaptik/migrated/JessicaBackground/JessicaBackground.affine

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+//
+// JessicaBackground -- the operative-background numeric core extracted from
+// src/app/player/JessicaBackground.res. The rank/XP progression tables
+// (rankValue, rankXpThreshold, canPromote) already live in the SkillRank
+// co-processor and are NOT duplicated here; this binding carries the remaining
+// numeric tables that switch on the `background` variant: the per-background
+// attribute-bonus matrix that getBonus folds, and the starting-skill grant that
+// makeSkillSet applies (which skill category a background seeds at Trained).
+//
+// Per the DESIGN-VISION ("AffineScript is the brain, the JS/Pixi host the
+// senses; only primitives cross the wasm boundary"), the host keeps every
+// string (display names, descriptions), the attributeBonus and skill records,
+// the skillSet construction, and the variant tags. AffineScript owns only the
+// scalar tables. The `background` variant collapses to its JessicaBackground.all
+// index (0 Assault .. 5 Logistics), exactly the dense tag order the .res.mjs
+// emits; each attribute collapses to a column ordinal; each skill category to
+// its JessicaBackground skillCategory index.
+//
+// getBonus returns a six-field float record per background. A record cannot
+// cross the boundary, so it re-decomposes into a single bonus(background, attr)
+// kernel selected by an attribute-column ordinal; the host reassembles the six
+// columns into its attributeBonus record. The values are the baseline shifts
+// added to the base 100.0 — ALL of the bonus shifts are whole numbers (e.g.
+// Assault: str+20, dex+10, con+15, int_-5, wil+5, cha-5), so they cross as Int
+// without loss. The host receives an integer shift and applies it to the float
+// base (100.0 + shift). The signed integer suffices and avoids Float literals
+// in the wasm codegen, which the v0.1.1 backend does not lower cleanly to f64
+// at the ABI level.
+//
+//## Background encoding (the header contract for the JS host)
+// Backgrounds index the JessicaBackground.all array order:
+//   0 Assault  1 Recon  2 Engineer  3 Signals  4 Medic  5 Logistics
+// An off-domain background index yields 0 from bonus (a neutral shift) and -1
+// from start_skill (a sentinel the host reads as "no grant").
+//
+//## Attribute-column encoding (the second contract, for the bonus selector)
+// Columns index the attributeBonus record field order:
+//   0 str  1 dex  2 con  3 int_  4 wil  5 cha
+// An off-domain column yields 0.
+//
+//## Skill-category encoding (the third contract, for the starting grant)
+// Categories index the JessicaBackground skillCategory variant order:
+//   0 Infiltration  1 CombatSkill  2 Athletics  3 Observation
+//   4 TechLiteracy  5 Fieldcraft   6 Composure
+// start_skill returns the category index a background seeds at Trained, or -1
+// when the background is off-domain.
+//
+// PURE: integers only, no floats, no strings, no arrays, no effects, no I/O.
+// Each entry point is a flat sequence of guarded returns rather than nested
+// if/else, which keeps the wasm backend's parser within its nesting tolerance.
+
+//## Attribute bonus for the STR column
+// All shifts are whole numbers; crossing as Int preserves the value exactly.
+fn bonus_str(background: Int) -> Int {
+  if background == 0 { return 20; }
+  if background == 1 { return -5; }
+  if background == 2 { return 5; }
+  if background == 3 { return -5; }
+  if background == 4 { return 0; }
+  if background == 5 { return 10; }
+  0
+}
+
+//## Attribute bonus for the DEX column
+fn bonus_dex(background: Int) -> Int {
+  if background == 0 { return 10; }
+  if background == 1 { return 15; }
+  if background == 2 { return 5; }
+  if background == 3 { return 5; }
+  if background == 4 { return 5; }
+  if background == 5 { return 0; }
+  0
+}
+
+//## Attribute bonus for the CON column
+fn bonus_con(background: Int) -> Int {
+  if background == 0 { return 15; }
+  if background == 1 { return 0; }
+  if background == 2 { return 5; }
+  if background == 3 { return 0; }
+  if background == 4 { return 20; }
+  if background == 5 { return 10; }
+  0
+}
+
+//## Attribute bonus for the INT column
+fn bonus_int(background: Int) -> Int {
+  if background == 0 { return -5; }
+  if background == 1 { return 10; }
+  if background == 2 { return 15; }
+  if background == 3 { return 10; }
+  if background == 4 { return 10; }
+  if background == 5 { return 5; }
+  0
+}
+
+//## Attribute bonus for the WIL column
+fn bonus_wil(background: Int) -> Int {
+  if background == 0 { return 5; }
+  if background == 1 { return 10; }
+  if background == 2 { return 5; }
+  if background == 3 { return 10; }
+  if background == 4 { return 10; }
+  if background == 5 { return 0; }
+  0
+}
+
+//## Attribute bonus for the CHA column
+fn bonus_cha(background: Int) -> Int {
+  if background == 0 { return -5; }
+  if background == 1 { return 0; }
+  if background == 2 { return -5; }
+  if background == 3 { return 10; }
+  if background == 4 { return 0; }
+  if background == 5 { return 10; }
+  0
+}
+
+//## Attribute bonus selector
+// bonus(background, attr): getBonus re-decomposed to a single signed integer
+// shift per (background, attribute-column) pairing. The host calls this six
+// times, once per column ordinal, and applies each shift to the float base
+// (100.0 + shift). Off-domain column yields 0; off-domain background yields 0
+// from each column kernel.
+pub fn bonus(background: Int, attr: Int) -> Int {
+  if attr == 0 { return bonus_str(background); }
+  if attr == 1 { return bonus_dex(background); }
+  if attr == 2 { return bonus_con(background); }
+  if attr == 3 { return bonus_int(background); }
+  if attr == 4 { return bonus_wil(background); }
+  if attr == 5 { return bonus_cha(background); }
+  0
+}
+
+//## Starting-skill grant
+// makeSkillSet re-decomposed. Each background seeds exactly one skill category
+// at Trained rank; this returns that category's index. Mirrors the switch:
+//   Assault -> CombatSkill(1)   Recon -> Observation(3)
+//   Engineer -> TechLiteracy(4) Signals -> TechLiteracy(4)
+//   Medic -> Composure(6)       Logistics -> Fieldcraft(5)
+// Off-domain background yields -1 (no grant), distinct from any valid 0..6 index.
+pub fn start_skill(background: Int) -> Int {
+  if background == 0 { return 1; }
+  if background == 1 { return 3; }
+  if background == 2 { return 4; }
+  if background == 3 { return 4; }
+  if background == 4 { return 6; }
+  if background == 5 { return 5; }
+  -1
+}

proposals/idaptik/migrated/JessicaLoadout/JessicaLoadout.affine

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// JessicaLoadout -- the loadout selection/validation co-processor, the pure
+// integer core extracted from src/app/player/JessicaLoadout.res. Per the
+// DESIGN-VISION ("AffineScript is the brain, JS/Pixi the senses; they pass
+// primitives across the wasm boundary"), the JS host keeps every string (item
+// display names, descriptions), the metadata records, and the array filters that
+// build the available-item lists; AffineScript owns only the access arithmetic
+// and the consumable charge bookkeeping.
+//
+// The ReScript original folds each weapon/tool variant through getWeaponInfo /
+// getToolInfo to a tier plus an allowedBackgrounds array, then canUseWeapon /
+// canUseTool grant access when the tier is T1, or when the allowed set is empty,
+// or when it contains the operative's background. We re-decompose those getInfo
+// switches (whose strings and arrays cannot cross the boundary) into the integer
+// bands the switch already produces: each item is its index, each tier its
+// ordinal, each background its index, and the allowed-set membership becomes a
+// flat guarded comparison per (item, background) pairing. No strings, no arrays,
+// no effects cross; the encoding IS the access rule.
+//
+//## Item encoding (the header contract for the JS host)
+// Weapons index the allWeapons array order:
+//   0 StunPistol  1 TacticalBaton  2 TranqRifle
+//   3 BreachingShotgun  4 Railgun  5 EMPPistol
+// Tools index the allTools array order:
+//   0 LockpickSet  1 GrapplingHook  2 MotionSensor  3 SignalJammer
+//   4 TraumaKit    5 C4Charge       6 GhillieWrap   7 FieldSurgeryKit
+// Consumables index the allConsumables array order:
+//   0 Flashbang  1 SmokeGrenade  2 ZipTies
+//   3 AdrenalineShot  4 DecoyPhone  5 FibreTap
+// Any index outside its band is off-domain: the tier functions return 0 (a
+// sentinel the host reads as "no such item"), can_use_weapon / can_use_tool
+// return 0 (denied), and consumable_uses returns 0.
+//
+//## Background encoding (the second contract, for the access predicate)
+// Backgrounds index the JessicaBackground.all array order, exactly the dense
+// tag order the .res.mjs emits:
+//   0 Assault  1 Recon  2 Engineer  3 Signals  4 Medic  5 Logistics
+// An off-domain background index matches no allowed set, so a T2/T3 item with a
+// non-empty set denies it, mirroring the ReScript Array.some returning false.
+//
+//## Tier encoding
+// The implicit tier ordering the access switch walks:
+//   1 T1 (universal)  2 T2 (background OR Trained)  3 T3 (background AND Veteran+)
+// can_use only distinguishes T1 (always granted) from T2/T3 (set-gated); the
+// rank arithmetic the T2/T3 distinction feeds lives in SkillRank, not here.
+
+//## Weapon tier
+// weapon_tier(): the tier ordinal each getWeaponInfo arm assigns. Off-domain
+// weapon indices yield 0. Flat guarded returns avoid the deep if/else nesting the
+// parser dislikes.
+pub fn weapon_tier(weapon: Int) -> Int {
+  if weapon == 0 { return 1; }
+  if weapon == 1 { return 1; }
+  if weapon == 2 { return 2; }
+  if weapon == 3 { return 2; }
+  if weapon == 4 { return 3; }
+  if weapon == 5 { return 3; }
+  0
+}
+
+//## Tool tier
+// tool_tier(): the tier ordinal each getToolInfo arm assigns. Off-domain tool
+// indices yield 0.
+pub fn tool_tier(tool: Int) -> Int {
+  if tool == 0 { return 1; }
+  if tool == 1 { return 1; }
+  if tool == 2 { return 2; }
+  if tool == 3 { return 2; }
+  if tool == 4 { return 2; }
+  if tool == 5 { return 2; }
+  if tool == 6 { return 3; }
+  if tool == 7 { return 3; }
+  0
+}
+
+//## Consumable charges
+// consumable_uses(): the initial charge count each getConsumableInfo arm assigns,
+// the value makeLoadout seeds consumableUsesLeft with. Off-domain indices yield 0.
+pub fn consumable_uses(consumable: Int) -> Int {
+  if consumable == 0 { return 2; }
+  if consumable == 1 { return 2; }
+  if consumable == 2 { return 3; }
+  if consumable == 3 { return 1; }
+  if consumable == 4 { return 2; }
+  if consumable == 5 { return 1; }
+  0
+}
+
+//## Weapon access predicate
+// canUseWeapon re-decomposed. T1 weapons are universal (return 1 regardless of
+// background). The two T1 weapons (0, 1) short-circuit first. The four gated
+// weapons each carry a non-empty allowed set, so the empty-set arm of the
+// ReScript switch is unreachable for them and need not be modelled; access is
+// granted iff the background index is a member, tested as a flat guarded compare
+// per (weapon, background) pairing. Any unmatched pairing falls through to 0
+// (denied), which also covers every off-domain weapon and background.
+//   2 TranqRifle       -> Assault(0), Recon(1)
+//   3 BreachingShotgun -> Assault(0), Engineer(2)
+//   4 Railgun          -> Assault(0)
+//   5 EMPPistol        -> Engineer(2), Signals(3)
+pub fn can_use_weapon(weapon: Int, background: Int) -> Int {
+  if weapon == 0 { return 1; }
+  if weapon == 1 { return 1; }
+  if weapon == 2 { if background == 0 { return 1; } if background == 1 { return 1; } return 0; }
+  if weapon == 3 { if background == 0 { return 1; } if background == 2 { return 1; } return 0; }
+  if weapon == 4 { if background == 0 { return 1; } return 0; }
+  if weapon == 5 { if background == 2 { return 1; } if background == 3 { return 1; } return 0; }
+  0
+}
+
+//## Tool access predicate
+// canUseTool re-decomposed, same shape. The two T1 tools (0, 1) are universal.
+// The six gated tools each carry a single-background allowed set.
+//   2 MotionSensor    -> Recon(1)
+//   3 SignalJammer    -> Signals(3)
+//   4 TraumaKit       -> Medic(4)
+//   5 C4Charge        -> Engineer(2)
+//   6 GhillieWrap     -> Recon(1)
+//   7 FieldSurgeryKit -> Medic(4)
+pub fn can_use_tool(tool: Int, background: Int) -> Int {
+  if tool == 0 { return 1; }
+  if tool == 1 { return 1; }
+  if tool == 2 { if background == 1 { return 1; } return 0; }
+  if tool == 3 { if background == 3 { return 1; } return 0; }
+  if tool == 4 { if background == 4 { return 1; } return 0; }
+  if tool == 5 { if background == 2 { return 1; } return 0; }
+  if tool == 6 { if background == 1 { return 1; } return 0; }
+  if tool == 7 { if background == 4 { return 1; } return 0; }
+  0
+}
+
+//## Consumable charge decrement
+// useConsumable re-decomposed. The ReScript guard is `if usesLeft > 0 then
+// usesLeft - 1`. This returns the charges remaining AFTER one use: one fewer when
+// any remain, else a floored 0 so a malformed negative or zero count can never
+// drive the counter below empty. The host reads "decremented < before" as the
+// boolean success the ReScript returns.
+pub fn use_consumable(uses_left: Int) -> Int {
+  if uses_left > 0 { return uses_left - 1; }
+  0
+}