NeonGrid — Gameplay Specification

Navigation Pedagogy & Spatial Mastery Module — KN-86 Deckline Pack-In Title

Version 2.0 | April 2026 | Status: Engineering-Ready (Supersedes KN-86-NeonGrid-BlackLedger-Gameplay-Spec.md Part One)

Scope: NeonGrid standalone spec. This document is the canonical, engineering-ready v2.0 NeonGrid module spec. It supersedes Part One of the combined KN-86-NeonGrid-BlackLedger-Gameplay-Spec.md (which remains on disk as a historical design-round artifact covering both NeonGrid and Black Ledger as a pair). For implementation, cite THIS document.

CIPHER-LINE revision note (2026-04-24): Every reference in this spec to the Cipher voice — navigation hints, sentry warnings, pedagogy commentary — renders on the CIPHER-LINE OLED, not the main 80×25 grid. NeonGrid’s spatial PSG design (cardinal tones, packet harmonics, sentry audio) remains unchanged; only Cipher text output migrates to the auxiliary display. See the CIPHER-LINE Contributions section at the end for NeonGrid’s vocabulary and biases. Canonical engine spec: docs/software/runtime/cipher-voice.md.

Mission Contributions

Mission Composition Grammar declaration — verb vocabulary, affinity tag set, and mission-contributions schema are defined in docs/plans/post-v0.1/2026-04-25-mission-composition-grammar.md §1–§3.

(mission-contributions
  :verbs (PENETRATE OBSERVE DECIDE)
  :affinities (PHYSICAL))

NeonGrid is the launch library’s pure-PHYSICAL cart — no DIGITAL or NETWORK overlay. Maze traversal satisfies PENETRATE (entering a defended grid through cleared cells); sonar/heatmap reading satisfies OBSERVE; checkpoint commitment under sentry pressure satisfies DECIDE. Default biases. Acts as a foundational PHYSICAL anchor that other carts (Pathfinder, Threshold, Depthcharge) can compose against.

Capability Registration

NeonGrid’s (cart-init) issues the following Mission Control capability declaration (canonical authoring contract: ../design-bibles/launch-titles-capability.md §2, ADR-0028 + ADR-0030):

(register-capabilities
  :module     :neongrid
  :bit        0x02
  :provides   '(:spatial-traversal :sentry-evasion
                :checkpoint-commitment :flow-state-training)
  :affinities '(:physical)
  :seeds      '(grid-topology sentry-patrol checkpoint-set)
  :supersedes :grid                    ; per ADR-0030 — supersedes the System-tier baseline
  :threat-cap 3)                       ; cart-tier ceiling; NEONGRID is training-tier so threat caps low

Relationship to baseline

NeonGrid supersedes the System-tier :grid baseline (../../runtime/baselines/grid.md) per ADR-0030. While inserted, NeonGrid amplifies the spatial-calibration domain — replacing GRID’s static checkpoint-traversal with full procedural mazes, sentry pressure, and the proficiency / flow-state arc, and lifting the threat ceiling from GRID’s training cap of 1 up to NeonGrid’s training-tier ceiling of 3. Eject the cart and the deck falls back to GRID’s bare calibration loop. See ../../runtime/mission-control.md §2.3 (the supersedes mechanic) and §3.2.1 (threat-cap inheritance).

Design Philosophy

NeonGrid is not a maze game. It is a navigation pedagogy that evolves into a persistent meditation practice and performance utility. The KN-86 Deckline has 31 keys, a Lisp-inspired input grammar, and a 31-key operator must learn those keys through embodied practice, not instruction. NeonGrid is that practice.

The operator navigates procedurally generated grid mazes (16×10 to 20×15 cells), collecting checkpoints while avoiding or predicting sentry patrol patterns. The core loop is OBSERVE-LEARN-EXECUTE-VERIFY: observe the grid, internalize its topology, execute movement decisions without error, verify mastery through clean completion. The metric is not speed but precision: fewer corrections, deeper spatial intuition, ultimate mastery = eyes-closed audio-only navigation.

NeonGrid teaches grammar through play. CAR (drill in/move forward), CDR (next sibling/traverse sideways), BACK (return), NIL (discard/clear path markers), ATOM (test for dead end), and EQ (compare two bookmarked positions) become muscle memory in the first two hours. The numpad (2/4/6/8 for N/S/W/E) becomes a spatial extension of the operator’s hand. By session end, the operator can navigate the entire KN-86 system because the foundational Lisp grammar is lived, not memorized.

But NeonGrid does not end at onboarding. It persists as an operator’s perpetual gym. ICE BREAKER specialists return weekly to maintain spatial precision and nerve steadiness before high-threat contracts. BLACK LEDGER auditors run NEONGRID flow state sessions to clear their minds. DEPTHCHARGE pilots use NeonGrid’s sonar-equivalent visualization to pre-simulate underwater routing. NeonGrid is the common language all modules speak.

1. THE CORE LOOP: ATOMIC UNIT OF PLAY

A single NeonGrid cycle is slower than ICE BREAKER’s OODA (5-15 seconds per decision vs. 0.5-2 seconds), but structurally identical: OBSERVE-LEARN-EXECUTE-VERIFY.

The Cycle

OBSERVE (1-2s): Operator sees the grid in its current state.

NEONGRID // WAVE 2, LEVEL 3 — STANDARD
TIME: 3:45 / 8:00    FLOW STATE: +45%    PROFICIENCY: +1

████████████████████
█      @      .    █
█  ███████████████  █
█  .           █  █ █
█  ███  █████  █  █ █
█  █         █ █ S█ █
█  █  █████  █ █░░█ █
█    .      █ █  ░ █
████████████████████

@ = You (Row 2, Col 7)   . = Checkpoint (3 remain)
S = Sentry (Row 6, Col 8)   ░ = Hazard (1 damage)
Sentry threat: Medium    Next move: ???

Operator presses INFO to see sentry patrol intelligence (second view-cycle):

SONAR/HEATMAP VIEW
Sentry A: (6,8) → East wall, 3-turn cycle, prediction: (6,10)
Sentry Distance: 4 cells (safe; threat: low)
Your Proximity to Next Checkpoint: 5 steps west
Optimal Path Available? YES (no collision risk)

The operator absorbs the state in 1-2 seconds. In training/standard mode, no time pressure. In FLOW STATE (advanced contract), each second of observation costs; faster reading becomes a learned skill.

LEARN (1-3s): Operator interprets the grid topology.

Mental model: “Sentry moves east-west. I’m 4 cells away, north of its patrol. Next checkpoint is west. If I move west, I gain 2 cells of sentry clearance. Path is clear.”

ORIENT phase. Expert operators (proficiency 70+) do this unconsciously in 0.5s. Trainees take 3s of deliberate conscious processing.

EXECUTE (1-2s per keystroke): Operator commits an action. They press numpad 4 (WEST).

Screen updates:

█      @      .    █     becomes    █    @ .      .    █

One keystroke = one cell movement = one game turn. Sentry moves (east, 1 cell). YM2149 plays: soft tom hit (keystroke acknowledge), then rising glissando in Voice 2 (sentry movement + distance).

In STANDARD mode, operator has unlimited thinking time. In FLOW STATE, they have ~0.5 seconds before the world cycles again and sentry moves without waiting.

VERIFY (0.5s): Operator checks: did result match prediction? Is sentry where expected? Am I on track to checkpoint?

YM2149 plays confirmation tone (Voice 2 pulse). Operator’s proficiency counter increments by +1 (invisible metric, accumulating).

2. SYSTEM ONE: THE GRID

The grid is a procedurally generated literal spatial field, not an abstract network. It has walls, corridors, hazards, and checkpoint positions with absolute coordinates.

Topology and State

Grid is seeded by contract parameters:

Wave (difficulty tier): 1-4. Wave 1 = introductory (6×8 grid, 1 sentry, 3 checkpoints, no hazards). Wave 4 = extreme (20×15 grid, 4 sentries, 5 checkpoints, plasma hazards).
Level within wave: 1-5 (procedural variation; same wave, different topology).
Grid size: 16×10 (Wave 1), 18×12 (Wave 2), 19×14 (Wave 3), 20×15 (Wave 4).
Wall density: 30-40% cells are walls (maze-like corridors).
Checkpoint count: 3 (Wave 1-2), 4-5 (Wave 3-4).
Sentry count: 1 (Wave 1), 2 (Wave 2), 3 (Wave 3), 4+ (Wave 4).
Hazards: None (Wave 1), SPIKE (1-2 damage, passable, 5% encounter chance per turn in hazard cell) (Wave 2+), PLASMA (instant mission fail, impassable) (Wave 3+).

Each cell has immutable state:

Passability: wall (✘), empty (✓), hazard (✓ but damage).
Checkpoint marker: null, or checkpoint ID (1-5).
Sentry patrol node: null, or sentry ID (A-D) and patrol sequence index.

Procedural Maze Generation

Using recursive backtracking with LFSR seeding:

Seed LFSR with contract threat level + level number + date-of-contract (deterministic, same seed = same maze).
Start at (0, 0), mark passable.
Recursive backtrack: pick random unvisited neighbor, mark passable, recurse.
Backtrack when stuck; unwind to last branching point.
Result: maze with exactly one solution path (plus optional shortcuts).

Checkpoint placement: Place checkpoints on grid such that they require visiting ~60-70% of maze cells (force exploration, but not exhaustive). Randomized via LFSR.

Sentry spawning: Spawn sentries on strategic chokepoints (corridor intersections, near checkpoints). Each sentry is assigned a patrol loop (5-8 nodes, revisited cyclically).

Checkpoint Architecture

Checkpoints are goal locations the operator must visit. Contract type determines visit rules:

TRAVERSE: Visit all checkpoints in sequence (1 → 2 → 3). Miss one, mission fails.
EXPLORE: Visit all checkpoints in any order. Optional: find optimal order (order bonus on clear).
PATROL: Revisit checkpoints cyclically (1 → 2 → 3 → 1 → …) for 5 cycles. Last minute timer pressure.
FLOW STATE: Infinite procedural grid; endless progression; complete 5 minutes without input error.

Checkpoint collection grants:

Audio cue: bright ascending arpeggio in Voice 3 (success confirm).
Screen update: checkpoint marker changes to [C] (collected).
Proficiency: +2 per checkpoint (visible on screen).
No time bonus. Time is irrelevant in NeonGrid. Precision matters.

3. SYSTEM TWO: SENTRIES & THREAT DETECTION

Sentries are patrol agents with deterministic routes, line-of-sight detection, and explicit state machine transitions that prevent infinite kiting exploits.

Sentry Behavior

Each sentry has:

Patrol loop: List of 5-8 waypoint coordinates (e.g., (3,2) → (3,8) → (7,8) → (7,2) → (3,2)).
Cycle time: 4-6 turns to complete full loop (depends on loop length).
Detection range: 4 cells (Manhattan distance). Operator in range = “detected.”
Detection persistence: Once detected, sentry “remembers” operator position for next 2 turns. Can predict operator movement.
Alert cascade: If one sentry detects, it broadcasts to other sentries (all adjust patrol to intercept).
Alert decay timer: Sentry alert level decays by -1 every 5 seconds (30 game turns) when operator is out of visual/audio range.
Patrol restoration: When alert level returns to 0, sentry resumes its original patrol loop from its current position.

Sentry State Machine (Explicit Transitions)

STATE: CALM (alert_level = 0)
├─ Visual detection (LOS, ≤4 cells) → ALERT (level := 3)
├─ Audio detection (keypress, ≤6 cells) → CAUTIOUS (level := 1)
├─ No input for >3 turns → CALM (level := 0, maintained)
└─ Patrol continues along assigned loop at normal cycle rate

STATE: CAUTIOUS (alert_level = 1–2)
├─ Visual detection (LOS) → ALERT (level := 3)
├─ Audio detection (keypress) → ALERT (level := 3)
├─ Operator >4 cells away AND silent for 5 turns → CALM (level := 0)
├─ Operator 2-4 cells away for 3+ turns → ALERT (level := 3)
├─ Patrol continues, may adjust bearing slightly toward last known player position
└─ Cycle rate: normal (no acceleration)

STATE: ALERT (alert_level = 3–4)
├─ Actively moves toward player's last known position (Manhattan pathfinding)
├─ Cycle speed halves: move every 1 turn (no wait between cells)
├─ Visual/audio contact renewed → ENGAGED (level := 5)
├─ No contact for 5 turns → CAUTIOUS (level := 2)
├─ After 8 turns total in ALERT → CAUTIOUS (level := 1) if still no contact
└─ Detection range increases to 5 cells (heightened alertness)

STATE: ENGAGED (alert_level = 5+)
├─ All-out pursuit; broadcasts distress to other sentries
├─ Cycle speed doubles: move every turn, no wait
├─ Detection range increases to 6 cells (maximum)
├─ Operator >6 cells away for 8 consecutive turns AND silent → ALERT (level := 4)
├─ Operator escapes and hides in dead-end for 5+ turns → ALERT (level := 3)
└─ Only de-escalates to ALERT, not directly to CAUTIOUS

IMPORTANT: Alert decay is **active decay only if operator is completely out of range.**
If operator is 5 cells away (just outside visual range) but sentry just detected them,
sentry does NOT immediately decay. It transitions to CAUTIOUS and waits 5 turns.
This prevents standing at 4.5-cell distance and kiting indefinitely.

Alert decay timer resets if operator comes back into range at any time.
If operator re-enters range during decay countdown, countdown pauses.

Detection Mechanics

Visual detection: Sentry can “see” operator if operator is ≤4 cells away AND no walls block line-of-sight (8-directional Bresenham raycasting). In ALERT or ENGAGED state, range extends to 5-6 cells.

Audio detection: Operator keypresses are “heard” by sentries within 6 cells. Each keypress increments alert level by +1 (max +1 per turn). Silent turns (no input) do not increase alert. After 5 silent turns beyond detection range, alert begins to decay.

Evasion routes: Operator can hide in dead-end corridors (sentry enters CAUTIOUS state, begins decay countdown). Operator can use SPIKE hazard as cover (sentry avoids hazard cells during patrol route generation, but will pass through them if pursuing operator aggressively).

Anti-kiting rule: Operator cannot stand at range=4.5 (between cells) to exploit distance. If sentry reaches alert level 3+, it enters ALERT state and actively pathfinds toward operator. Passive patrol mode is exited. Sentry will close distance or reset to patrol only via explicit decay mechanic (5 consecutive silent turns out of range).

Threat Escalation

Threat levels (UI display):

SAFE: 0 sentries detected, 0 alert level. Audio is calm (Voice 1 baseline hum ~200Hz).
CAUTIOUS: 1 sentry detected, alert level 1-2. Voice 1 rises to 300Hz, intermittent.
ALERT: 2+ sentries closing, alert level 3-4. Voice 1 at 600Hz, pulsing. Sentry actively pathfinding.
DANGER: Sentry adjacent (within 1 cell), alert level 5+. Voice 1 screaming (1600Hz+), all 3 voices cacophony.

Consequence of detection: If sentry reaches operator cell, mission aborts. No second chances. Operator respawns at last checkpoint visited (or grid start if no checkpoint yet collected).

Failure cost: Reputation -2 (in STANDARD contracts). Mission restart (in FLOW STATE).

4. SYSTEM THREE: PROFICIENCY & FLOW STATE

Proficiency is a hidden metric (invisible to operator, but influenced by their play) that tracks:

Precision: Correct moves without backtracking (undo). Each undo = -1 proficiency.
Consistency: Moving at steady tempo (measured via keystroke timing variance). High variance = -0.5 proficiency per outlier.
Prediction accuracy: Did sentry end up where you predicted? Correct prediction = +1 proficiency.
Checkpoint efficiency: How many extra moves to each checkpoint? Optimal path = +2, detour = +0.
Risk avoidance: How close did you get to sentries? 4+ cells away = +1, 2-3 cells away = +0, 1 cell away = -2.

Proficiency feeds into:

Flow state detection (Explicit Formula): System detects FLOW STATE when ALL of the following conditions are met in a single session:

flow_state_unlocked = (
    (proficiency_gained >= 20) AND                          // Must gain 20+ proficiency points
    (no_corrections_this_session == true) AND                // Zero backtracking / undos
    (average_move_interval_ms >= 800 AND <= 2500) AND       // 0.8–2.5 seconds per move
    (move_interval_variance_ms < 600)                        // Std dev < 600ms (allows deliberate pauses)
)

// Rationale:
// - 800ms minimum: Too fast = not deliberate (scanner mode, not flow)
// - 2500ms maximum: Too slow = operator is pausing to think (analytical, not flow)
// - 600ms variance: Allows for normal reaction time fluctuation but penalizes erratic tempo
// - No corrections: Single mistake breaks flow (requires full restart of flow counter)
// - 20+ proficiency: Demonstrates measurable skill gain during session

Flow multiplier (1.5x): When flow state is active, all rewards (proficiency, reputation, credits) multiply by 1.5x. Audio changes: Voice 1 drops to soft hum (focus mode), Voice 2 becomes rhythmic tom-tom heartbeat (tempo keeper at ~90 BPM), Voice 3 fades. Operator is in the zone.
Flow state duration: Once unlocked, flow state persists for the remainder of the session unless:
- Operator makes a single correction (backtrack/undo) → flow breaks, counter resets to 0
- Operator pauses for >5 seconds → flow stutters (multiplier drops to 1.2x, can recover)
- Operator makes a keypress error (wrong direction) → flow breaks immediately
Audio-only mastery mode: Proficiency 80+: operator can toggle screen off (SYS menu). Navigate by audio alone. EXTREMELY advanced. Only ~2% of operators reach this.

Proficiency also unlocks new mission types:

Proficiency 0-20: WAVE 1 only (training).
Proficiency 21-40: WAVE 2 unlocked (standard).
Proficiency 41-60: WAVE 3 unlocked (challenge).
Proficiency 61-100: WAVE 4 unlocked (extreme). CHAOS MODE unlocked (randomized dynamic sentries, unpredictable patrols).

5. SYSTEM FOUR: SOUND DESIGN

The YM2149 is the spatial feedback instrument.

Three Voices as Spatial Channels

Voice 1: Threat Ambient Drone

Base frequency (SAFE state): 200Hz (sub-audible baseline).
Frequency rises with threat level: 300Hz (cautious), 600Hz (alert), 1600Hz+ (danger).
Rate of change is tempo information: fast rise = sentry accelerating toward you, slow rise = sentry moving at patrol pace.
Expert operators hear Voice 1 and estimate sentry distance without looking at screen.
Sound design: Smooth glissando (sine wave), no stuttering. Changes feel organic, not digital.

Voice 2: Movement Feedback & Checkpoint Pulse

Keypresses trigger soft tom hit (50ms duration). Operator gets tactile audio feedback = move confirmed.
Checkpoint collection: rising arpeggio (5-note, 300-800Hz range). Celebrates success.
Sentry movement cycle: rhythmic pulse (every 1-2 seconds, depending on sentry cycle). Operator can count sentry ticks by ear.
In FLOW STATE: Voice 2 becomes a tempo keeper—metronomic heartbeat at ~90 BPM. Operator entrains to it. Unconscious synchronization.
Sound design: Mix of percussive (toms, kick drum samples) and pitched tones (arpeggios).

Voice 3: Environmental Hazard & Ambient

Hazard cells: Voice 3 emits white noise bursts (20ms every 1-2 seconds). Operator learns to avoid the noise.
Detection imminent (sentry closing): Voice 3 rises from silence to dissonant pulsing. Early warning system.
Calm exploration (safe state): Voice 3 is pure silence or very faint ambient pad.
Sound design: Mostly noise, sparse pitched elements. Eerie, immersive.

Audio Signature of Key Moments

Grid load: All three voices initialize with a quick “boot” chord (E-G-B, major triad). Clear, decisive.
Checkpoint collected: Voice 3 rises (ascending arpeggio), Voice 1 drops (relief tone). Celebration.
Sentry detected (visual): All three voices spike simultaneously (dissonant cluster). Unmistakable.
Sentry entering detection range: Voice 1 begins rising (slow glissando). 2-3 seconds before critical.
Forced movement (mission restart after death): All voices cut to silence, then re-initialize on new grid. Moment of reset.
Flow state unlocked: Voice 1 drops, Voice 2 locks into metronomic heartbeat, Voice 3 fades. Operator feels the shift—conscious transition into meditative state.

Audio-Only Mastery Mode

At proficiency 80+, operator can press SYS → AUDIO ONLY to toggle screen off. Navigate purely by audio.

Voice 1 pitch: Left-right distance estimate. Constant pitch = aligned with checkpoint/goal. Rising = getting closer.
Voice 2 rhythm: Sentry tick rate. Fast ticking = sentry cycling fast (close). Slow ticking = distant.
Voice 3 noise: Hazard proximity. Noise increases = moving toward hazard.

This is not a gimmick. Speedrunners use it competitively. Blind operators use it as primary interface. High-rep players use it as meditation. The audio is semantic, not decorative.

6. EMERGENT COLLISIONS

The four systems (grid, sentry, proficiency, sound) collide to produce unscripted moments.

The Sentry Prediction Collision

Operator predicts sentry will be at (5,6) in 2 turns. They plan their move accordingly. But operator makes a mistake: presses numpad 4 (west) when they meant numpad 2 (south). Sentry, now at (5,6), is 2 cells away instead of 4.

Operator realizes the error mid-move (audio Voice 1 jumps sharply = detection imminent). Operator must abort and backtrack. Proficiency drops (correction = -1). But they escaped. Lesson learned: tempo is not about speed, it’s about intention. Fast careless moves lose.

The Flow State Interruption Collision

Operator is 8 minutes into a FLOW STATE contract. Proficiency has risen 25 points. Flow meter is full. Tempo is locked at 1.2 seconds per move.

On turn 43, operator makes a typo: presses numpad 1 instead of 2. Flow state breaks. Voice 2 heartbeat stutters and dies. Voice 1 rises sharply (threat increasing, operator disoriented). Proficiency drops by 10 (massive penalty for mid-flow error).

Operator is shaken. They abort the contract. But they’ve learned: flow state is fragile. Concentration is everything.

The Hazard-Sentry Timing Collision

Operator is navigating Wave 3 (hazards present). They see a SPIKE hazard cell and a sentry patrol loop that passes through it. Operator thinks: “If I trigger the hazard, sentry will detect the audio (my damage cry). But the hazard damages me, and sentry will be alert level 3+.”

Operator chooses to not trigger the hazard. They take a longer route, avoiding both hazard and sentry. 3 extra moves. 3 extra turns. Sentry completes another cycle. But operator reaches checkpoint alive and undetected.

Cost: time (irrelevant in NeonGrid). Benefit: avoided damage, maintained stealth. NeonGrid rewards this strategic thinking. Proficiency rises.

The Checkpoint Sequence Collision

Operator is in EXPLORE contract (visit all checkpoints in any order). They’ve visited checkpoints 1 and 2. Checkpoint 3 is in the southwest corner. Sentry A is patrolling that corridor.

Operator could visit checkpoint 3 now (high risk: sentry is 3 cells away). Or find an alternate route (5 extra moves, but sentry will be on the far side of its loop in 2 turns, giving a safe window).

Operator waits 2 turns, lets sentry move. Takes the safe route. Visits checkpoint 3 unmolested. Proficiency rises (prediction accuracy + risk avoidance).

7. SESSION SHAPE: THE EMOTIONAL ARC

Sessions vary by contract type and proficiency level.

The 15-Minute Trainee Session (Wave 1, First-Time Player)

Minutes 0-2: Curiosity & Confusion. Operator loads WAVE 1, sees a 6×8 grid with 1 checkpoint, 1 sentry. YM2149 plays startup chord. Operator is disoriented. What do they do? They press INFO to see details. Good. Info overlay shows sentry patrol (simple: back-and-forth at row 3). Checkpoint is northwest. Operator has time to think.

Minutes 2-5: Building Confidence. Operator presses numpad 4 (west). Character moves. Screen updates. Operator feels the grid respond to their input. They press 4 again. West. Again. Again. They’re moving toward the checkpoint. No sentry in the way. Operator realizes: this is just spatial navigation. CAR/CDR principles but with up/down/left/right.

Minutes 5-8: Engagement. Operator reaches checkpoint. Screen flashes. Voice 3 arpeggio plays. Operator presses BACK (navigational return button). Screen shows “CHECKPOINT COLLECTED: 1/1.” Operator feels success. They understand the loop: observe → learn → execute → verify. Simple.

Minutes 8-15: Mastery Moment. Operator reads the sentry patrol. They see the sentry approaching. Instead of panic, they press numpad 2 (south) to move away. Sentry passes. Operator is safe. They move north, back to checkpoint. Operator reaches it unmolested. Mission Complete. Screen: “PROFICIENCY +15. REPUTATION +1. Wave 1 Complete: Good Job, Operator.”

Total time: 15 minutes. Operator has learned: the grid is navigable, sentry AI is predictable, and their hands control everything. They’re ready for Wave 2.

The 30-Minute Standard Session (Wave 2, Experienced Player)

Operator selects STANDARD difficulty, Wave 2, Level 2. Grid is 18×12, 2 sentries, 3 checkpoints, 1 SPIKE hazard. Time limit: 8 minutes.

Minutes 0-2: Rapid Assessment. Operator presses INFO immediately. Sees both sentry patrols at a glance. Holds a mental map of the grid topology. Plots optimal route: checkpoint 1 (west), checkpoint 2 (south, avoid sentry A), checkpoint 3 (east, sentry B will be out of the way in 3 turns).

Minutes 2-4: Execution Phase 1. Operator moves west steadily (4-4-4-4) reaching checkpoint 1. No sentry contact. Collects it. Voice 3 arpeggio. Proficiency +2.

Minutes 4-6: Execution Phase 2. Operator backtracks, moves south. Sentry A is patrolling nearby but moving away. Operator reaches checkpoint 2 undetected. Proficiency +2.

Minutes 6-8: High-Pressure Phase 3. Operator has 2 minutes left. Checkpoint 3 is 5 moves away, but sentry B is cycling. Operator observes: sentry will reach checkpoint 3 in 6 turns. Operator has 5 turns to get there. It’s tight.

Operator moves aggressively. No pauses. Tempo locks at 1.2 seconds per move. Voice 2 heartbeat speeds up (time pressure). Voice 1 rises (sentry approaching). Operator reaches checkpoint 3 with 10 seconds to spare. Mission complete.

Result: Clear time: 7:50. Rep +2. Proficiency +12 (includes flow bonus). Flow state detected: proficiency gain multiplied by 1.5x. Operator left satisfied. They dominated this challenge.

The 60-Minute Campaign Session (Wave 3, Expert + Linked Play)

Operator with Rep 45 (veteran) loads WAVE 3, PATROL contract with a linked partner. Goal: both operators navigate the same grid (one is Operator, one is Sysop). Operator must complete 5 patrol cycles (visit 5 checkpoints, 5 times each) while Sysop tries to intercept using sentry deployments (linked play mechanic).

Minutes 0-10: Reconnaissance. Operator does multiple INFO passes, building mental map. Sysop prepares countermeasures. Operator sees Sysop has deployed 2 extra sentries (linked play feature). Difficulty spike. Operator plans: use Wave 3 hazards as cover. Move unpredictably to throw off Sysop’s sentry deployments.

Minutes 10-45: Execution. Operator completes 3 patrol cycles. Constant sentry cat-and-mouse with Sysop. Operator is in flow state the entire time: tempo locked, audio is meditation. Voice 1 throbs but never reaches critical (operator stays 3+ cells from sentries at all times).

Minutes 45-50: Escalation. Sysop adapts: deploys sentries more aggressively. Operator’s flow state is tested. One near-miss (sentry reaches 1 cell away), but operator escapes. Proficiency drops briefly (-1 for scare), recovers (+3 for successful evasion).

Minutes 50-60: Final Push. Operator completes cycles 4 and 5. Sysop throws everything they have at this. But operator has won the pattern recognition game. They know Sysop’s deployment tendency (always guards checkpoints). Operator pre-positions before Sysop can react.

Result: Mission complete in 59:30. Rep +5 (linked play bonus). Proficiency +25. Operator and Sysop both gained reputation. Session was intense, cooperative, mutually satisfying. Both operators leave with stories.

8. ONBOARDING: THE FIRST FIVE MINUTES

NeonGrid is the onboarding module for the entire KN-86 platform. It teaches Lisp-inspired key semantics through play, not instruction. Every operator starts here (unless they skip, but they’ll regret it).

Boot Sequence

Screen 1 (3 seconds): Edgeware Systems wordmark assembles character by character (soft keyclick per character). Clean 440Hz tone on completion. NEONGRID v2.0 is initializing.

Screen 2 (automatic): “Welcome, new operator. I am CIPHER. You are about to learn the language of the Deckline. This is NeonGrid. Not a game. A practice.”

Cipher’s voice (soft, precise, androgenous) explains: “You have 31 keys. Left hand controls navigation. Right hand enters data. In a moment, you will see a grid. A small maze. You will move through it using four keys: 2, 4, 6, 8. Up, down, left, right. Yes?”

Screen 3 (automatic): “But first: the basic keys. Your left hand.”

A diagram appears:

[QUOTE]  [CONS]  [NIL]  [LAMBDA]
[INFO]   [CAR]   [APPLY] [SYS]
[LINK]   [BACK]  [CDR]   [ATOM]
 ========== EVAL ============   [EQ]

Cipher explains:

“CAR means drill in, examine, move forward.”
“CDR means traverse sideways, look at your options.”
“BACK means return, undo, go back.”
“NIL means discard, forget, clear.”

Screen 4 (operator controls): “Now you try. Press CAR.”

Operator presses the key labeled CAR on their Deckline. On screen, a cursor appears in a list of items. It moves to the first item. Cipher: “Good. CAR looked inside the first thing. Now press CDR.”

Operator presses CDR. Cursor moves to the next item (sibling). Cipher: “Good. CDR looked at the next thing.”

This is tactile Lisp learning. The keys are not abstract. They map to observable spatial behavior.

Screen 5 (automatic): “You understand the basic language. Now, the grid.”

A small 6×8 maze appears on screen. A ’@’ character is at the start. A ’.’ is a checkpoint. Voice 1 plays a soft baseline hum.

Cipher: “This is a maze. You are the @. The . is a goal. Use the numpad: 8 is up, 2 is down, 4 is left, 6 is right. Move to the goal.”

Screen 6 (operator controls, 2-4 minutes): Operator navigates. They press numpad 4. ’@’ moves left. Screen updates. They press 4 again. Again. Again. They reach the goal. Voice 3 plays an arpeggio. Checkpoint collected.

Cipher: “Excellent. You learned the first thing: spatial navigation. The grid obeys you. Now you learn the second thing: predicting sentries.”

Screen 7 (automatic): A new grid loads. This time, there’s an ‘S’ character. Cipher: “This is a sentry. It patrols. Watch it move. Do not get close. Move to the checkpoint without touching the sentry.”

Screen 8 (operator controls, 3-5 minutes): Operator navigates. They observe the sentry moving back and forth. They time their movements to avoid it. They reach the checkpoint. Tension and release. Mission clear.

Cipher: “You now know: grids have obstacles that move. You can predict and plan around them.”

Screen 9 (automatic): Cipher appears (text): “You have learned NeonGrid’s grammar in the last 5 minutes. CAR, CDR, BACK, NIL are now muscle memory. The numpad is spatial. Sentries move in patterns. Checkpoints are goals. You understand the language of the Deckline.”

“Return any time. I will be here. The grid will be different each time. Same language. New challenges.”

Operators are now ready to use the entire KN-86 system. Their hands know the keys. Their brain understands Lisp-inspired spatial navigation. The rest is domain-specific (ICE BREAKER’s networks, BLACK LEDGER’s ledgers, DEPTHCHARGE’s sonar). But the foundation is solid.

9. PROFICIENCY TRACKING & HIDDEN METRICS

Proficiency is invisible but deeply affects all subsequent modules.

The Proficiency Vector (4 bytes in SRAM)

Byte 0: BASE_PROFICIENCY (0-100)
  0-20: Novice
  21-40: Competent
  41-60: Skilled
  61-80: Expert
  81-100: Master (audio-only mode unlocks)

Byte 1: PRECISION_COUNTER (0-255, wraps)
  Increments on correct moves without backtrack.
  Decrements on mistakes, reversals, corrections.

Byte 2: FLOW_MULTIPLIER (0-255, as percentage 0-255% of normal)
  Starts at 100 (1.0x).
  Increases during detected flow state.
  Decays if flow breaks.

Byte 3: SENTRY_PREDICTION_ACCURACY (0-255, as percentage)
  Tracks: how often did operator correctly predict sentry position?
  0-50%: Bad predictions, many surprises.
  50-100%: Excellent predictions, rare surprises.

Cross-Module Integration

When operator loads ICE BREAKER with NEONGRID in history:

Cipher grades are reduced by 1 (operator’s spatial reasoning transfers to network node topology).
Network traversal is 15% faster (muscle memory from numpad pays dividends).
Proficiency 60+: Operator can preview network layout in NEONGRID-grid format before committing (strategic advantage).

When operator loads BLACK LEDGER with NEONGRID in history:

Pattern recognition contracts (identifying financial anomalies) are 20% easier (same spatial cognition applies to transaction flows).
Operator can visualize transaction paths as NEONGRID-like grids (BLACK LEDGER UI automatically offers this view).

When operator loads DEPTHCHARGE with NEONGRID in history:

Sonar bearing interpretation is intuitive (same numpad directionality applies: 8=north, 2=south, etc.).
Depth topology visualization uses NEONGRID-grid metaphor (operator feels at home).

In reverse: Loading NEONGRID after mastering ICE BREAKER introduces training interference. Operator’s ICE BREAKER navigation patterns (fast, aggressive) conflict with NEONGRID’s precision requirements. They must unlearn speed and relearn caution. Proficiency starts lower. But once mastered, both skills coexist and reinforce each other.

Reputation vs. Proficiency

Reputation is earned rep points from successful contracts across all modules. It feeds into access levels (threat ceilings, new mission types).

Proficiency is a hidden measure of operator skill at the Deckline itself. It is earned in NeonGrid but influences ALL modules.

Example:

Operator A: Rep 25 (average), Proficiency 75 (expert). They’re not famous, but they execute with precision. They succeed at Threat 4 contracts that a Rep 40 operator with Proficiency 20 would fail at.
Operator B: Rep 45 (famous), Proficiency 15 (sloppy). They’ve brute-forced many contracts through raw grinding. But ask them to execute a clean run without mistakes? They fail. ICE BREAKER contracts with them as Sysop are chaotic.

Both matter. Reputation opens doors. Proficiency executes flawlessly.

10. LINKED PLAY: SPECTATOR & VERSUS MODES

Two or more KN-86 decks can link via cable to create asymmetric multiplayer.

Spectator Mode (Passive)

Operator A runs a NeonGrid STANDARD contract. Operator B watches their performance on a second deck (read-only view of Operator A’s grid, position, sentry locations, score).

Spectator sees:

Real-time position updates (Operator A’s ’@’ and sentry positions).
Proficiency delta in real time.
Incoming sentry threats (Voice 1 pitch of Operator A’s deck transmitted to Operator B’s deck as secondary audio).

Use case: Coaching. Teaching. Two operators learning from each other.

Versus Mode (Active Sysop)

Operator A (Intruder) runs STANDARD NeonGrid contract. Operator B (Sysop) attempts to intercept using sentry placement.

Mechanics:

Intruder sees standard grid + 1 sentry (the Sysop-controlled sentry).
Sysop sees the grid + Intruder’s position in real time + 3 sentry pawns they can place.
Every 2 game turns, Sysop can move one sentry 1 cell (toward Intruder, away, or hold position).
Intruder doesn’t know Sysop’s strategy (Sysop’s deck screen not visible).
Win condition (Intruder): Collect all checkpoints without touching any sentry. Win condition (Sysop): Force Intruder into sentry cell.
Payout: If Intruder wins, both earn Rep +2. If Sysop wins, Sysop earns Rep +3, Intruder gets Rep -1 (harsh penalty, creates drama).

Example Scenario:

Turn 1-5: Intruder moves west (toward checkpoint 1). Sysop sees this. Sysop places a sentry in the west corridor (prediction: Intruder will go there). Intruder observes sentry appearing (Sysop’s move) and instantly pivots south instead (Intruder’s prediction skill activated). Sysop’s sentry arrives at Intruder’s old position 2 turns later (just missed).

Turn 10-15: Intruder has collected checkpoint 1. Sysop now places sentries around checkpoint 2 (Sysop predicts Intruder will visit there next, because it’s the only unvisited checkpoint). Intruder is prepared. They move in an unpredictable pattern, arriving from an unexpected angle. They collect checkpoint 2 just as Sysop’s sentry is repositioning. Close call.

Turn 20-end: Final checkpoint. Intruder vs. Sysop in full mind-game mode. Intruder is in flow state (calm, locked tempo). Sysop is flustered (trying multiple strategies, reactive instead of proactive). Intruder wins. Reputation and proficiency exchanged.

Linked Play Economics

Both operators gain reputation, but the split is asymmetric:

Outcome	Intruder Rep	Sysop Rep	Intruder Proficiency	Sysop Proficiency
Intruder wins	+2	-1	+5	-2
Sysop wins	-1	+3	-2	+4

This creates dynamic partnerships. Weaker players (low rep/proficiency) partner with stronger players to learn. High-rep players pair to test themselves. The asymmetric payout encourages diverse play.

11. DETAILED SCREEN LAYOUTS

All screens fit 80 columns × 25 rows. Row 0 = firmware status bar (bright). Rows 1-23 = content. Row 24 = firmware action bar (inverse, nOSh-runtime-owned).

Screen 1: Wave Select

ROW 0: NEONGRID > WAVE SELECT [REP: 34] [PROFICIENCY: 42] [CREDITS: 3500]
ROW 1:
ROW 2: ★ WAVE 1: TRAINING              ★ WAVE 2: STANDARD
ROW 3:   Difficulty: ░░░░░ (Easy)        Difficulty: ░░░░░ (Moderate)
ROW 4:   Grid: 6×8 | Sentries: 1         Grid: 18×12 | Sentries: 2
ROW 5:   Checkpoints: 3 | Time: ∞        Checkpoints: 3 | Time: 8:00
ROW 6:   Hazards: None                   Hazards: Spike (5%)
ROW 7:   Rep Gain: +1 | Credits: 50 ¤   Rep Gain: +2 | Credits: 200 ¤
ROW 8:   Status: COMPLETED [5/5]         Status: IN PROGRESS [3/5]
ROW 9:
ROW 10: ★ WAVE 3: CHALLENGE            ★ WAVE 4: EXTREME
ROW 11:   Difficulty: ░░░░░ (Hard)       Difficulty: ░░░░░ (Insane)
ROW 12:   Grid: 19×14 | Sentries: 3      Grid: 20×15 | Sentries: 4+
ROW 13:   Checkpoints: 4 | Time: 10:00   Checkpoints: 5 | Time: 12:00
ROW 14:   Hazards: Spike, Plasma         Hazards: Spike, Plasma (20%)
ROW 15:   Rep Gain: +3 | Credits: 500 ¤  Rep Gain: +5 | Credits: 1500 ¤
ROW 16:   Status: LOCKED                 Status: LOCKED
ROW 17:   (Proficiency 60+ required)     (Proficiency 85+ required)
ROW 18:
ROW 19: PROGRESS: Wave 1 (5/5 complete) | Wave 2 (3/5 complete) | Total Rep: 34
ROW 20:
ROW 21:
ROW 22:  [CAR=select] [CDR=next] [EVAL=start] [BACK=exit]
ROW 23: WAVE SELECT | OPERATOR: NEO | PROFICIENCY: 42 | FLOW: READY
ROW 24: NEONGRID │ WAVE 1 [★] │ WAVE 2 [→] │ WAVE 3 [lock] │ WAVE 4 [lock]

Screen 2: Maze Gameplay (Standard View)

ROW 0: NEONGRID > WAVE 2 LEVEL 3 [TIME: 4:32 / 8:00] [PROF: +8] [FLOW: +30%]
ROW 1:
ROW 2: MAZE GRID:                       Sentry A: (5,10)→(5,18) [SAFE]
ROW 3: ████████████████████             Sentry B: (12,8)→(12,2) [SAFE]
ROW 4: █ @    .      ░    █             Checkpoints: 3 / 3 remain
ROW 5: █ █████████████████              Next: Visit any checkpoint
ROW 6: █ █     .  █    █  █             Optimal path available? YES
ROW 7: █ █  █████████  █  █             Input accuracy: 100%
ROW 8: █ █  ░     █  █ S █ █            Threat level: MEDIUM
ROW 9: █ █  ████████████████             Distance to nearest sentry: 9 cells
ROW 10: █  .         █ █      █
ROW 11: ████████████████████
ROW 12:
ROW 13: KEY: @ = You | S = Sentry | . = Checkpoint | ░ = Hazard
ROW 14:
ROW 15: LAST MOVE: E → (2,3) [clean]
ROW 16: NEXT MOVE: [2/4/6/8] = Navigate by numpad direction
ROW 17:
ROW 18:
ROW 19:
ROW 20:
ROW 21:
ROW 22:  [2/4/6/8=move] [INFO=sonar] [EVAL=special] [BACK=pause]
ROW 23: MAZE GAMEPLAY | TIME: 4:32 / 8:00 | PROFICIENCY: +8 | FLOW: ACTIVE
ROW 24: NEONGRID │ WAVE 2 │ LEVEL 3 OF 5 │ THREAT: ░░░░░ | STATUS: IN PLAY

Screen 3: Sonar/Heatmap View (INFO toggle)

ROW 0: NEONGRID > SONAR/HEATMAP [TIME: 4:32 / 8:00] [ANALYSIS ACTIVE]
ROW 1:
ROW 2: MAZE GRID:                       Sentry A Status:
ROW 3: ████████████████████             ──────────────────────
ROW 4: █ @    .      ░    █             Position: Row 5, Col 10
ROW 5: █ █████████████████              Patrol: (5,10)→(5,18) [loop 8]
ROW 6: █ █     .  █    █  █             Cycle: 2 turns/cell
ROW 7: █ █  █████████  █  █             Distance: 4 cells [SAFE]
ROW 8: █ █  ░     █  █ S █ █            Direction: EAST (away)
ROW 9: █ █  ████████████████             Pred 2 turns: (5,14)
ROW 10: █  .         █ █      █
ROW 11: ████████████████████
ROW 12:
ROW 13: HEATMAP LEGEND:                 Sentry B Status:
ROW 14: ▓ Red = High danger              ──────────────────────
ROW 15: ░ Yellow = Medium threat          Position: Row 12, Col 5
ROW 16: · Green = Safe corridor           Patrol: (12,8)→(12,2) [loop 6]
ROW 17: ◆ Blue = Checkpoint               Cycle: 1 turn/cell (FASTER)
ROW 18:                                   Distance: 10 cells [SAFE]
ROW 19: PATH ANALYSIS:                   Pred 3 turns: (12,3)
ROW 20: Optimal route: 5 moves | Risk: NONE | Est: 2:15
ROW 21: Recommendation: MOVE WEST now to widen distance from B
ROW 22:  [INFO=grid] [CDR=details] [EVAL=dismiss] [BACK=cancel]
ROW 23: SONAR/HEATMAP | SENTRY A: EAST | SENTRY B: WEST | ANALYSIS: ACTIVE
ROW 24: NEONGRID │ HEATMAP MODE │ RECOMM: WEST │ EST: 2:15 │ SAFETY: ✓

Screen 4: Level Clear / Checkpoint Collected

ROW 0: NEONGRID > MISSION COMPLETE [WAVE 2 LEVEL 3] [TIME: 6:48 / 8:00]
ROW 1:
ROW 2:                           ★ MISSION COMPLETE ★
ROW 3:
ROW 4:                     Time: 6:48 / 8:00 (85% efficiency)
ROW 5:                     Checkpoints: 3 / 3 collected
ROW 6:                     Sentry Encounters: 0 (perfect evasion)
ROW 7:                     Movement Errors: 0 (flawless)
ROW 8:
ROW 9:                          PROFICIENCY GAINS
ROW 10:                    ═════════════════════════════
ROW 11:                    Checkpoints +6    (2 per checkpoint)
ROW 12:                    Sentry Evasion +5 (stayed 4+ cells)
ROW 13:                    Path Optimization +4 (near-optimal)
ROW 14:                    Consistency +2    (no corrections)
ROW 15:                    ─────────────────────────────
ROW 16:                    TOTAL PROFICIENCY GAIN: +17
ROW 17:                    Flow State Bonus: ×1.5 (ACTIVE)
ROW 18:                    ADJUSTED GAIN: +26
ROW 19:
ROW 20:                     Wave 2 Rep Gain: +2 reputation
ROW 21:                     New Proficiency: 68 | Credits: 200 ¤
ROW 22:  [EVAL=return] [BACK=scores]
ROW 23: MISSION COMPLETE │ PROFICIENCY: +26 │ REP: +2 │ CREDITS: +200
ROW 24: NEONGRID │ WAVE 2 │ LEVEL 3 CLEARED │ NEXT WAVE AVAILABLE

Screen 5: Game Over / Mission Failed

ROW 0: NEONGRID > MISSION FAILED [WAVE 2 LEVEL 3] [TIME: 4:21 / 8:00]
ROW 1:
ROW 2:                            ✗ MISSION FAILED ✗
ROW 3:
ROW 4:                    Sentry Detection: YES (Sentry B)
ROW 5:                    Detection Location: Row 12, Col 6
ROW 6:                    Time Remaining: 2:15
ROW 7:                    Checkpoints Collected: 1 / 3
ROW 8:
ROW 9:                          FAILURE ANALYSIS
ROW 10:                    ═════════════════════════════
ROW 11:                    You miscalculated Sentry B's cycle.
ROW 12:                    Entered detection range at (Row 12, Col 6)
ROW 13:                    while moving EAST. Sentry B was at
ROW 14:                    (Row 12, Col 7) — no escape possible.
ROW 15:                    ─────────────────────────────
ROW 16:                    Error Type: Miscalculated sentry speed
ROW 17:                    Distance to checkpoint: 3 cells (unreached)
ROW 18:
ROW 19:                     Proficiency Loss: -5 (detection penalty)
ROW 20:                     Reputation Loss: -1
ROW 21:                     Consolation: 50 ¤ (session fee refund)
ROW 22:  [EVAL=retry] [BACK=scores]
ROW 23: MISSION FAILED │ PROFICIENCY: -5 │ REP: -1 │ REFUND: 50¤
ROW 24: NEONGRID │ WAVE 2 │ RETRY AVAILABLE │ DIFFICULTY: STANDARD

Screen 6: Wave Unlock Animation (Progression)

ROW 0: NEONGRID > WAVE UNLOCK [PROFICIENCY: 60+] [STATUS: UNLOCKED]
ROW 1:
ROW 2:                          ★ WAVE 3 UNLOCKED ★
ROW 3:
ROW 4:                    You have reached proficiency threshold 60+.
ROW 5:                    The Challenge Wave is now available.
ROW 6:
ROW 7:                          WAVE 3: CHALLENGE
ROW 8:                    ═════════════════════════════════════════
ROW 9:                    Grid Size: 19×14 | Sentries: 3 (faster)
ROW 10:                    Hazard Density: HIGH | Spike + Plasma
ROW 11:                    Checkpoints: 4 | Time Limit: 10:00
ROW 12:                    Rep Gain: +3 | Credits: 500 ¤
ROW 13:                    ─────────────────────────────────────────
ROW 14:
ROW 15:                    ★ NEW FEATURES UNLOCKED:
ROW 16:                    • Audio-only navigation mode (experimental)
ROW 17:                    • Sentry learning AI (adapts to your moves)
ROW 18:                    • Hazard zones (new mechanic)
ROW 19:
ROW 20:                    "You are becoming legend, Operator.
ROW 21:                     The grid no longer confuses you."
ROW 22:  [EVAL=ready] [BACK=wave select]
ROW 23: WAVE UNLOCK │ PROFICIENCY: 60+ │ CHALLENGE AVAILABLE │ REP: 34
ROW 24: NEONGRID │ PROGRESSION │ WAVE 3 UNLOCKED │ NEW FEATURES: ✓

Screen 7: Audio Analysis HUD (Variant)

ROW 0: NEONGRID > AUDIO ANALYSIS [MODE: EXPERIMENTAL] [FLOW: ACTIVE]
ROW 1:
ROW 2: AUDIO HUD (Synesthetic Maze Navigation):
ROW 3: ───────────────────────────────────────────────────────
ROW 4:
ROW 5: SENTRY A (300 Hz tone):           SENTRY B (200 Hz tone):
ROW 6: ▓▓▓▓░░░░░░ Frequency: 300 Hz    ▓▓░░░░░░░░░░ Frequency: 200 Hz
ROW 7: ════════════════════════════════ ════════════════════════════════
ROW 8: Volume: medium-high             Volume: medium
ROW 9: Direction vector: EAST          Direction vector: WEST (closing)
ROW 10: Distance estimate: 4 cells      Distance estimate: 6 cells
ROW 11: Threat: CONTAINED               Threat: MONITORING
ROW 12:
ROW 13: CHECKPOINT BEACON (800 Hz, pulsing):
ROW 14: ▓▓▓▓▓▓░░░░ Volume: quiet (distant)
ROW 15: Direction: NORTH | Distance: ~8 cells
ROW 16: Status: ACQUIRED
ROW 17:
ROW 18: ENVIRONMENTAL NOISE:
ROW 19: Ambient hum: 50 Hz baseline | Hazard zone buzz: active NW sector
ROW 20:
ROW 21: (Audio-only navigation is EXPERIMENTAL. Use traditional grid if lost.)
ROW 22:  [INFO=grid] [CDR=focus] [EVAL=confirm] [BACK=disable]
ROW 23: AUDIO ANALYSIS │ SYNESTHETIC MODE │ FLOW: ACTIVE │ CLARITY: HIGH
ROW 24: NEONGRID │ AUDIO HUD │ EXPERIMENTAL │ EST TIME REMAINING: 3:45

Screen 8: Session Stats / Summary

ROW 0: NEONGRID > SESSION SUMMARY [OPERATOR: NEO] [REP: 34]
ROW 1:
ROW 2: RECENT SESSION PERFORMANCE:
ROW 3: ───────────────────────────────────────────────────────
ROW 4:
ROW 5: Wave 2, Level 1: ✓ PASS (5:12) | Proficiency: +8 | Rep: +1
ROW 6: Wave 2, Level 2: ✓ PASS (4:45) | Proficiency: +7 | Rep: +1
ROW 7: Wave 2, Level 3: ✗ FAIL (4:21) | Proficiency: -5 | Rep: -1
ROW 8: Wave 2, Level 3: ✓ PASS (6:48) | Proficiency: +17 | Rep: +2
ROW 9:
ROW 10: SESSION TOTALS:
ROW 11: ═════════════════════════════════════════════════════════
ROW 12: Playtime: 21 min 6 sec
ROW 13: Waves Completed: 2 (8 / 5 levels in Wave 2)
ROW 14: Success Rate: 75% (3 passed, 1 failed)
ROW 15: Proficiency Gained: +27
ROW 16: Reputation Gained: +3
ROW 17: Credits Earned: 450 ¤
ROW 18: Average Threat Handling: CONTROLLED
ROW 19: Flow State Duration: 18 min (active throughout)
ROW 20: Improvement Trend: ↑ Rising confidence
ROW 21:
ROW 22:  [EVAL=continue] [BACK=wave select]
ROW 23: SESSION SUMMARY │ PLAYTIME: 21:06 │ PROFICIENCY: +27 │ FLOW: ↑
ROW 24: NEONGRID │ SESSION COMPLETE │ NEXT AVAILABLE: WAVE 2 LEVEL 4

12. CELL ARCHITECTURE

Every interactive element in NeonGrid is a cell. The cartridge grammar (nosh_cart.h) defines cell types.

Cell Types

// CELL_TYPE: GRID
// The maze itself. Contains all walls, checkpoints, hazards, sentries.
CELL_TYPE(grid) {
    CELL_FIELDS {
        uint8_t width;
        uint8_t height;
        uint8_t *cells;              // Flat array: width * height cells
        uint8_t checkpoint_count;
        uint8_t sentry_count;
        Checkpoint checkpoints[5];   // Max 5 checkpoints
        Sentry sentries[4];          // Max 4 sentries
        uint32_t seed;               // Procedural generation seed
        uint8_t wave;                // Difficulty tier (1-4)
    };

    ON_DISPLAY {
        render_grid_view(self);      // Render maze, player, sentries
    }
    ON_INFO {
        render_sonar_view(self);     // Render threat heatmap
    }
    ON_NUMPAD(digit) {
        player_move(self, digit);    // 2/4/6/8 = cardinal directions
    }
    ON_EVAL {
        // Not used in grid. Only movement keys and INFO.
    }
};

// CELL_TYPE: CHECKPOINT
// A goal location in the maze.
CELL_TYPE(checkpoint) {
    CELL_FIELDS {
        uint8_t row;
        uint8_t col;
        uint8_t id;                  // 1-5
        uint8_t collected;           // 0 = uncollected, 1 = collected
        uint16_t collection_time;    // Turn when collected
    };

    ON_DISPLAY {
        // Rendered as part of grid display, not standalone.
        // But if operator navigates into checkpoint (CAR), show details.
        nosh_text_puts(0, 0, "CHECKPOINT ");
        nosh_text_printf(11, 0, "%d", self->id);
        nosh_text_puts(0, 1, "Status: ");
        nosh_text_puts(8, 1, self->collected ? "COLLECTED" : "UNCOLLECTED");
    }
    ON_CAR {
        if (!self->collected) {
            checkpoint_collect(self);
            proficiency_add(2);
        }
    }
};

// CELL_TYPE: SENTRY
// An enemy patrol agent.
CELL_TYPE(sentry) {
    CELL_FIELDS {
        uint8_t id;                  // A, B, C, D
        uint8_t row;
        uint8_t col;
        uint8_t *patrol_route;       // Array of waypoints
        uint8_t patrol_length;
        uint8_t patrol_index;        // Current position in route
        uint8_t cycle_rate;          // Turns per cell movement
        uint8_t detection_range;     // 4 cells (Manhattan)
        uint8_t alert_level;         // 0-5 (0=calm, 5=chasing)
    };

    ON_DISPLAY {
        // Rendered as 'S' on grid. But if operator examines (INFO), show details.
        // (Handled by grid's INFO handler, not standalone.)
    }
    ON_TICK {
        // Called every game turn by the nOSh runtime.
        sentry_advance_patrol(self);
        sentry_detect_player(self);
        sentry_update_alert(self);
    }
};

// CELL_TYPE: CONTRACT
// Describes a mission template (wave + difficulty + objective).
CELL_TYPE(contract) {
    CELL_FIELDS {
        char name[32];
        uint8_t wave;                // 1-4
        uint8_t level;               // 1-5 within wave
        uint8_t contract_type;       // TRAVERSE, EXPLORE, PATROL, FLOW_STATE
        uint16_t payout;             // Credits
        uint8_t rep_gain;            // Reputation on success
        uint32_t seed;               // Grid generation seed
    };

    ON_DISPLAY {
        nosh_text_puts(0, 0, "WAVE ");
        nosh_text_printf(5, 0, "%d", self->wave);
        nosh_text_puts(10, 0, "LEVEL ");
        nosh_text_printf(16, 0, "%d", self->level);
        draw_threat_bar(self->wave, 0, 1);  // Visual difficulty
        nosh_text_puts(0, 2, "PAYOUT: ");
        nosh_text_printf(9, 2, "%d ¤", self->payout);
    }
    ON_CAR {
        // Start this contract
        mission_begin(self);
    }
    ON_CDR {
        // Next contract in list
        next_sibling();
    }
};

// CELL_TYPE: PROFICIENCY_STAT
// Shows operator's hidden proficiency metrics (dashboard view).
CELL_TYPE(proficiency_stat) {
    CELL_FIELDS {
        char stat_name[24];          // "Base Proficiency", "Precision", etc.
        uint8_t value;               // 0-100
        uint8_t max_value;
    };

    ON_DISPLAY {
        nosh_text_puts(0, 0, self->stat_name);
        draw_progress_bar(self->value, 25, 0, 50);  // Visual bar
        nosh_text_printf(76, 0, "%d%%", self->value);
    }
};

Handler Signatures

// All handlers have this signature:
// void handler_name(cell_type *self)

// Example: Player moves east (numpad 6)
void on_numpad_handler(cell_grid *self, uint8_t digit) {
    if (digit == 6) {  // East
        if (can_move_east(self)) {
            move_player(self, EAST);
            game_tick();  // Advance sentry positions, check collisions
        } else {
            sfx_error();
        }
    }
}

// Example: Player presses INFO to see sentry details
void on_info_handler(cell_grid *self) {
    render_sonar_view(self);
    // Display heatmap, sentry predictions, safe paths
}

// Example: Player reaches a checkpoint
void on_checkpoint_collect(cell_checkpoint *self) {
    self->collected = 1;
    proficiency_add(2);
    sfx_confirm();
    // Check mission status: all checkpoints collected?
    if (mission_all_checkpoints_visited()) {
        mission_complete();
    }
}

13. KEY MAPPING TABLE: ALL 30 KEYS

Key	Name	Value	NeonGrid Behavior	Notes
LISP PRIMITIVES (Amber)
CAR	Drill In	5	Enter checkpoint cell for details	Move forward is numpad, not CAR
CDR	Next Sibling	10	Scroll contract list (wave select screen)	Not used during maze play
CONS	Construct	1	Not used in NeonGrid	Reserved for module composition
NIL	Discard	2	Clear all path markers (if in tactical view)	Unused in standard gameplay
ATOM	Is Leaf?	11	Test if current cell is a dead-end corridor	Useful for audio-only players
EQ	Equal?	13	Compare two QUOTE’d positions	Advanced: detect symmetry patterns
ACTION VERBS (White)
EVAL	Execute	12	Not used during maze. Confirm contract on wave select	Primary action key is numpad movement
QUOTE	Bookmark	0	Bookmark current position (advanced: save waypoint for tactical planning)	8 slots available, stored in SRAM
LAMBDA	Macro	3	Record movement sequence (advanced: replay path segments)	Useful for speedrunning
APPLY	Deploy	6	Not used in NeonGrid	Reserved for module composition
SYSTEM (Gray/Red)
BACK	Navigate Up	9	Cancel current view overlay. Return from INFO sonar to grid view. Exit contract to wave select.	Critical for UI navigation
INFO	Inspect	4	Toggle sonar/heatmap view. Shows sentry predictions, safe corridors, optimal paths. Double-tap cycles views.	Most important key for advanced play
LINK	Link	8	Initiate linked play. Connect second deck for spectator or versus mode.	Firmware-level, cartridge passes through
SYS	System	7	Tap: System menu (brightness, volume, proficiency dashboard). Hold 2s: Hard abort to boot.	Standard nOSh runtime behavior
DATA GRID (White Numerals)
PAD_0 to PAD_9	Digits 0-9	14-26	2/4/6/8 = Movement. 2=South, 4=West, 6=East, 8=North. 5=Wait/Hold. Other digits unused.	Numpad is primary control
PAD_DIV, PAD_MUL, PAD_SUB, PAD_ADD	Operators	17, 21, 25, 29	Not used in NeonGrid	Reserved for data entry
PAD_DOT, PAD_ENTER	Decimal, Enter	27, 28	Not used in NeonGrid	Reserved for data entry

Key Usage Summary — COMPREHENSIVE (All 30 Keys Explicit)

During maze gameplay (standard grid navigation):

Key	Behavior	Result
Numpad 2 (South)	Move south (down)	Player advances 1 cell south; game ticks; sentries advance
Numpad 4 (West)	Move west (left)	Player advances 1 cell west; game ticks; sentries advance
Numpad 6 (East)	Move east (right)	Player advances 1 cell east; game ticks; sentries advance
Numpad 8 (North)	Move north (up)	Player advances 1 cell north; game ticks; sentries advance
Numpad 5 (Wait/Hold)	Pass turn without moving	Player waits 1 turn (no movement); sentries still advance; counts as valid move
INFO (single-tap)	Toggle sonar/heatmap view	Switch from Grid View ↔ Sonar View. Shows sentry positions, predictions, threat heatmap, optimal paths
INFO (double-tap)	Cycle views	Cycle through Grid View → Sonar View → Tactical View (if unlocked by proficiency 60+)
BACK	Abort mission	Return to wave select screen; current progress is lost (no auto-save during active mission)
SYS (tap)	System menu	Open menu: brightness, volume, audio-only toggle, proficiency stats, return to game
SYS (hold 2s)	Hard abort to boot	Force reboot; all unsaved progress lost; only use for emergency exit
CAR	Not used in maze gameplay	Produces `sfx_error()` (error beep); no action taken
CDR	Not used in maze gameplay	Produces `sfx_error()`; no action taken
CONS	Not used in maze gameplay	Produces `sfx_error()`; no action taken
NIL	Not used in maze gameplay	Produces `sfx_error()`; no action taken
ATOM	Test dead-end (advanced)	Audio-only players: triggers sonar pulse to detect if current cell is a dead-end corridor. Useful for blind navigation. Produces subtle tone feedback.
EQ	Compare positions (advanced)	Requires two QUOTE-bookmarked positions. Triggers sonar comparison: tells operator if two positions are equidistant from checkpoint. Useful for pattern recognition.
EVAL	Not used in maze gameplay	Produces `sfx_error()`; no action taken
QUOTE	Bookmark position (advanced)	Saves current position to one of 8 bookmark slots (SRAM). Operators can revisit or reference waypoints. Speedrunners use this for route optimization. Does NOT pause game; bookmark operation is instantaneous.
LAMBDA	Record macro (advanced speedrunning)	Begins recording a movement sequence (up to 20 keystrokes). Operator can replay with single key press. Used for repeating complex maneuvers in speedruns. Does NOT pause game.
APPLY	Not used in maze gameplay	Produces `sfx_error()`; no action taken
LINK	Initiate linked play	Request connection to second deck (spectator or versus mode). Firmware-level operation; triggers connection handshake.
Numpad 0	Not used	Produces `sfx_error()` (error beep)
Numpad 1	Not used	Produces `sfx_error()`
Numpad 3	Not used	Produces `sfx_error()`
Numpad 7	Not used	Produces `sfx_error()`
Numpad 9	Not used	Produces `sfx_error()`
Numpad . (DOT)	Not used	Produces `sfx_error()`
Numpad ENTER	Not used	Produces `sfx_error()`
PAD_DIV, PAD_MUL, PAD_SUB, PAD_ADD	Not used	All produce `sfx_error()`

On wave select screen (contract selection):

Key	Behavior	Result
CAR	Enter selected contract	Load selected wave/level; display contract details; prepare grid generation
CDR	Scroll to next contract	Advance to next wave or next level within wave
BACK	Return to main menu	Go back to deck state dashboard
EVAL	Start contract	Confirm selection and begin mission; grid is procedurally generated; mission timer starts
Numpad 2, 4, 6, 8	Navigate wave/level selection	Highlight previous/next option in contract list
All other keys	Not used	Produce `sfx_error()`

In proficiency dashboard (SYS → view stats):

Key	Behavior	Result
CAR	View session details	Display breakdown of last 5 sessions with proficiency deltas
CDR	View recommendations	Display personalized recommendations (“Master sentry prediction”, “Try Wave 3”, etc.)
BACK	Exit dashboard	Return to wave select screen
All other keys	Not used	Produce `sfx_error()`

Implementation Notes for Engineering

Error sound (sfx_error()): A brief, discordant tone (200Hz-400Hz chirp, 100ms duration) that immediately signals “invalid input for this context.” No screen change, no game state change.
No ambiguity: Every key has explicit behavior for every game state (maze play, wave select, dashboard, sonar view). If behavior is undefined, the default is error sound.
Numpad 5 semantics: Wait/Hold is mechanically equivalent to a move (triggers sentry advancement, counts as input for proficiency tracking). It is a valid strategic choice (e.g., “wait for sentry to pass before advancing”).
Advanced key features (ATOM, EQ, QUOTE, LAMBDA): These are discoverable through tutorial or experimentation. They are not required for core gameplay but unlock advanced play patterns (audio-only navigation, speedrunning).
Context sensitivity: All key behaviors are context-dependent (maze vs. wave select vs. dashboard). The nOSh runtime’s phase system manages dispatch to correct handler.

14. MISSION TEMPLATE DEFINITIONS

Contracts are procedurally generated from templates. Each template has a seeded contract type, threat level, and payout formula.

Contract Types

TRAVERSE (Sequence-Based)

MISSION_TEMPLATE(TRAVERSE) {
    .contract_type = TRAVERSE,
    .description = "Visit checkpoints 1 → 2 → 3 in sequence. Skip one, fail.",
    .threat_range = {1, 4},
    .wave_requirement = {1, 4},

    .generator = {
        grid_size = 8 + wave * 2,              // Wave 1: 8, Wave 2: 10, ...
        checkpoint_count = 3 + (wave-1),
        sentry_count = wave - 1,
        hazard_density = wave >= 3 ? 0.05 : 0,
    },

    .payout_formula = (threat_level * 100) + (time_bonus * 20),
    .reputation_formula = threat_level,
    .completion_condition = "all_checkpoints_visited_in_order",
    .time_limit = (4 + wave) * 60,            // Wave 1: 5 min, Wave 2: 6 min, ...
};

Example: TRAVERSE Wave 2 Level 3

Threat level: 2
Grid: 18×12
Checkpoints: 3 (must visit 1→2→3)
Sentries: 2
Time limit: 8 minutes
Base payout: 200 ¤
Rep gain: +2

EXPLORE (Any Order)

MISSION_TEMPLATE(EXPLORE) {
    .contract_type = EXPLORE,
    .description = "Visit all checkpoints in ANY order. Find optimal sequence for bonus.",
    .threat_range = {2, 5},
    .wave_requirement = {2, 4},

    .generator = { /* same as TRAVERSE */ },

    .payout_formula = (threat_level * 150) + (efficiency_bonus * 50),
    // Efficiency bonus = time saved vs. worst-case route

    .reputation_formula = threat_level + (efficiency_bonus > 0 ? 1 : 0),
    .completion_condition = "all_checkpoints_visited",
    .time_limit = (5 + wave) * 60,
};

Example: EXPLORE Wave 3 Level 2

Checkpoints: 4 (visit in any order)
Bonus for optimal order: +50 ¤
Rep gain: +3 (or +4 if optimal route found)

PATROL (Cyclic)

MISSION_TEMPLATE(PATROL) {
    .contract_type = PATROL,
    .description = "Revisit checkpoints cyclically: 1→2→3→1→2→3→... for 5 full cycles.",
    .threat_range = {2, 4},
    .wave_requirement = {2, 4},

    .payout_formula = (threat_level * 200) + (cycle_completion_bonus * 100),
    .reputation_formula = threat_level + 1,  // Always +1 bonus for patrol difficulty
    .completion_condition = "5_full_cycles_completed",
    .time_limit = (10 + wave * 2) * 60,      // Longer: 5 cycles
};

Example: PATROL Wave 2 Level 4

Visit checkpoint 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3 (15 visits total)
Time limit: 14 minutes
Base payout: 400 ¤
Rep gain: +3

FLOW STATE (Infinite Progression)

MISSION_TEMPLATE(FLOW_STATE) {
    .contract_type = FLOW_STATE,
    .description = "Endless grid. Navigate 5 minutes without a single input error.",
    .threat_range = {1, 3},
    .wave_requirement = {1, 4},

    .generator = {
        grid_regenerate = every_3_checkpoints,  // New grid procedurally generated
        sentry_count = wave,
        hazard_density = 0,                     // No hazards in flow state
    },

    .payout_formula = 500 + (proficiency_level * 10),
    .reputation_formula = 2 + (flow_bonus ? 1 : 0),
    .completion_condition = "5_minutes_no_errors",
    .time_limit = 5 * 60,
};

Example: FLOW STATE Wave 1

5-minute continuous navigation
No time pressure (time doesn’t decrease; mission ends at 5:00)
Payout: 500 ¤ + proficiency bonus
Rep gain: +2 (or +3 if flow state was achieved)
Proficiency gain: Up to +30 (if perfect flow detected)

Payout Formula (Cross-Template)

base_payout = threat_level × 100
time_bonus = (time_remaining / time_limit) × 0.5 × base_payout
efficiency_bonus = (optimal_moves / actual_moves) × 0.3 × base_payout
proficiency_multiplier = 1 + (proficiency_level / 100)

final_payout = (base_payout + time_bonus + efficiency_bonus) × proficiency_multiplier
final_reputation = threat_level + bonus_conditions

15. CROSS-MODULE INTEGRATION

NeonGrid in the Capability Ecosystem

Designation: NAVIGATION (TRAINING) (MODULE CLASS: 0x02) Publisher: Edgeware Systems Co., Ltd. (Tokyo) — KEC first-party Cartridge History Bit: Bit 1 (set on first load)

Integration with ICE BREAKER

When operator loads ICE BREAKER with NeonGrid in cartridge history:

Cipher difficulty reduced by 1 grade. Operator’s spatial reasoning transfers to network node topology understanding.
Network traversal 15% faster. Muscle memory from numpad = faster CDR (list traversal).
At proficiency 60+: Operator can preview network layout as a NEONGRID-grid visualization before committing to mission. Strategic advantage.
Surveillance Implant contract complication: If operator has high NEONGRID proficiency (70+), surveillance becomes noisier. Their predictable patrol-pattern knowledge interferes with target prediction. Training interference effect (realistic).

Integration with BLACK LEDGER

When operator loads BLACK LEDGER with NeonGrid in history:

Pattern recognition 20% easier. Same spatial cognition applies to transaction flow visualization.
Operator can choose “Grid View” for ledger navigation. BLACK LEDGER displays transactions as a NEONGRID-like grid (rows = accounts, columns = time periods). Operator feels at home.
Proficiency 50+: BLACK LEDGER’s cipher-pattern puzzles become 15% faster to solve. Transfer effect.

Integration with DEPTHCHARGE

When operator loads DEPTHCHARGE with NeonGrid in history:

Sonar bearing interpretation is intuitive. Same numpad directionality applies: 8=north bearing, 2=south bearing, 4=west, 6=east.
Depth topology visualization uses NEONGRID-grid metaphor. DEPTHCHARGE renders sonar contacts as a grid. Operator feels at home.
Proficiency 60+: Submersible drone positioning becomes 20% faster (muscle memory).

Reverse Integration: Learning Interference

Loading NEONGRID after mastering ICE BREAKER:

Operator’s learned tempo (fast, aggressive, high-tempo OODA cycles) conflicts with NEONGRID’s precision requirements (steady, cautious, deliberate spacing). Operator must unlearn speed and relearn caution. This is mechanically enforced.

Reverse Integration Penalty Formula

IF operator_has_ice_breaker_completion_history AND loading_neongrid_first_time:

    // Initial state
    initial_neongrid_proficiency = 0  // Start completely fresh

    // First 10 sessions: cumulative penalty
    first_session_penalty = -2  // Penalty applied to every move in first session

    // Penalty decay over time
    sessions_completed_in_neongrid = current_session_number
    penalty_decay = max(0, -2 × (1 - sessions_completed_in_neongrid / 10))

    // Formula: After session N, penalty is:
    // sessions 1-10:   -2.0 per move (decaying)
    // sessions 11-15:  -1.0 to 0.0 per move (continued decay)
    // sessions 16+:    0.0 (penalty lifted, full proficiency gain available)

    // Example progression:
    // Session 1:  -2.0 penalty per move (feels 25% clumsy vs. baseline)
    // Session 5:  -1.0 penalty per move (feels 12% clumsy)
    // Session 10: 0.0 penalty per move (penalty expires, full growth resumes)

    // Proficiency ceiling during penalty period
    max_proficiency_while_penalized = 30  // Cannot exceed 30 while interference active

Interference Manifestation in Gameplay

Session 1-3 (Severe Interference):

Operator plays at ICE BREAKER pace (0.5-1.0 seconds per decision)
NEONGRID requires 1-2 seconds per move minimum for flow state
Flow state formula triggers move_interval_variance < 600ms, but operator’s intervals are 500ms
Result: No flow state possible. Proficiency gains are baseline only (no multiplier).
Operator feels “rushed” and makes errors (sentry predictions fail -2 to -3 proficiency per wrong guess)
Tempo warning appears: “SLOW DOWN. Precision requires deliberation.”

Session 4-7 (Moderate Interference):

Operator consciously slows down to 1.2-1.5 seconds per move
Flow state occasionally triggers (when intervals stay within 800-2500ms with <600ms variance)
But muscle memory still causes sudden speed bursts (old habit from ICE BREAKER)
Speed bursts break flow state (penalty -10 proficiency when flow breaks)
Proficiency gain is reduced by half (interference penalty still active)

Session 8-10 (Minimal Interference):

Operator has integrated the two tempos
Flow state unlocks consistently
Penalty decay to 0; full proficiency gains resume
Can now switch between ICE BREAKER and NEONGRID without major disruption

Session 11+:

No interference; full ICE BREAKER + NEONGRID skill synthesis
Operator can leverage both skill sets simultaneously
Example: “ICE BREAKER taught me network topology; NEONGRID taught me precision. I can now navigate complex ICE BREAKER networks with perfect tempo control.”

Cipher Commentary (Narrative Layer)

When operator loads NEONGRID for first time after ICE BREAKER:

[Cipher voice, measured and direct]

"I recognize your tempo. ICE BREAKER taught you speed.
The grid demands something different: precision.
Fast and careful are not enemies—they are skills that must be learned separately.

You will feel clumsy at first. This is correct.
Your hands know the pace of pursuit.
Your mind must learn the pace of evasion.

In 10 sessions, they will coexist.
In 15, they will reinforce.
But today, you must unlearn."

[Pause]

"Begin."

This frames the penalty as a narrative beat, not a punishment. Operators understand they are integrating two different skill trees.

Reverse Integration Completion

After 15 sessions:

Proficiency penalty is completely lifted
Operator has access to all proficiency-unlock features (WAVE 3, WAVE 4, CHAOS MODE)
Reputation and credits gains are no longer penalized
Cipher commentary changes: “Pattern recognized. You have integrated two disciplines. Rare.”

This is realistic and mechanically modeled. Skill transfer is not free.

15.5. CHAOS MODE SENTRY AI SPECIFICATION

CHAOS MODE (Wave 4, Proficiency 85+, available only during Wave 4 Standard or Challenge contracts) fundamentally changes sentry behavior from deterministic patrol loops to biased random walk. This section specifies the algorithm precisely.

CHAOS MODE vs TRAINING MODE Sentry Behavior

TRAINING MODE (Waves 1-3, standard sentry behavior):

Sentries follow fixed patrol loops (deterministic, seeded by LFSR)
Each sentry advances predictably along patrol_route[patrol_index]
Operator can learn and memorize patrol patterns

CHAOS MODE (Wave 4, random sentry behavior):

Sentries abandon patrol loops entirely
Each sentry performs a biased random walk on each game tick
Operator cannot memorize or reliably predict next position
However, seeding is deterministic—same grid seed produces identical sentry paths (enables speedrunning)

Biased Random Walk Algorithm

CHAOS_MODE_SENTRY_TICK(sentry, operator_position, turn_number) {

    // Step 1: Calculate distance and threat assessment
    distance_to_operator = manhattan_distance(sentry.pos, operator_position)

    // Step 2: Determine bias probability based on distance
    if (distance_to_operator >= 5) {
        // Operator is far; low bias toward operator (40% chance to move toward)
        bias_toward_operator = 0.40

    } else if (distance_to_operator >= 2 AND distance_to_operator < 5) {
        // Operator is medium distance; moderate bias (70% chance to move toward)
        bias_toward_operator = 0.70

    } else {
        // Operator is adjacent (1 cell away); direct pursuit (100% toward)
        bias_toward_operator = 1.0
    }

    // Step 3: LFSR-based seeding for determinism
    // Each sentry has a unique LFSR seeded at grid generation:
    //   lfsr_seed = grid_seed XOR sentry_id XOR turn_number
    // This ensures same grid+sentry+turn produces same random number.

    random_value = lfsr_next(sentry.lfsr)  // Returns 0.0–1.0

    // Step 4: Direction selection
    if (random_value < bias_toward_operator) {
        // Biased choice: move toward operator
        direction = manhattan_direction_toward(sentry.pos, operator_position)

    } else {
        // Unbiased choice: pick random cardinal direction (4 neighbors)
        direction = random_cardinal_direction(sentry.lfsr)
    }

    // Step 5: Boundary check
    next_position = sentry.pos + direction
    if (out_of_bounds(next_position) OR is_wall(next_position)) {
        // Cannot move in chosen direction; re-roll
        direction = random_cardinal_direction(sentry.lfsr)
        next_position = sentry.pos + direction
    }

    // Step 6: Movement and detection (same as standard mode)
    sentry.pos = next_position
    if (distance(sentry.pos, operator_position) <= detection_range) {
        sentry_detect_operator(sentry, operator_position)
    }
}

// Helper: Manhattan direction toward target
manhattan_direction_toward(current, target) {
    // Return ONE cardinal direction (N/S/E/W) that moves toward target
    // Use tie-breaking to ensure deterministic choice:
    //   Prefer vertical (N/S) if vertical distance > horizontal distance
    //   Prefer horizontal (E/W) otherwise

    dy = target.y - current.y
    dx = target.x - current.x

    if (abs(dy) > abs(dx)) {
        return (dy > 0) ? SOUTH : NORTH
    } else {
        return (dx > 0) ? EAST : WEST
    }
}

// Helper: Random cardinal direction
random_cardinal_direction(lfsr) {
    roll = lfsr_next(lfsr) % 4
    return [NORTH, SOUTH, EAST, WEST][roll]
}

Practical Examples

Scenario 1: Operator 6 cells away (SAFE zone)

Bias = 40% chance sentry moves toward operator
60% chance sentry moves randomly
Result: Sentry drifts randomly but occasionally turns toward operator
Audio cue: Voice 1 stays relatively low (no immediate threat)

Scenario 2: Operator 3 cells away (ALERT zone)

Bias = 70% chance sentry moves toward operator
30% chance sentry moves randomly
Result: Sentry mostly chases operator, occasional random detours
Audio cue: Voice 1 rises significantly (threat is real)

Scenario 3: Operator 1 cell away (DANGER zone)

Bias = 100% (guaranteed pursuit)
Sentry moves directly toward operator every turn
No randomness; deterministic pursuit
Audio cue: Voice 1 at maximum (sentry is adjacent or attacking)

Seeding & Determinism (Speedrunning Support)

CHAOS MODE is fully deterministic when given the same starting conditions:

grid_seed = contract_parameters.seed
sentry_A.lfsr = seed_lfsr(grid_seed XOR 0x0001 XOR 0)  // Sentry A
sentry_B.lfsr = seed_lfsr(grid_seed XOR 0x0002 XOR 0)  // Sentry B
sentry_C.lfsr = seed_lfsr(grid_seed XOR 0x0003 XOR 0)  // Sentry C
sentry_D.lfsr = seed_lfsr(grid_seed XOR 0x0004 XOR 0)  // Sentry D

// Rerun the same grid with the same seed:
// - Maze topology is identical
// - Sentry movements are identical
// - Operator can memorize and speedrun

Operators who master CHAOS MODE often replay the same grids multiple times to optimize routing and exploit memorized sentry paths. This is the intended design.

Audio Feedback in CHAOS MODE

The unpredictability of CHAOS MODE demands heightened audio reliance:

Voice 1 (Threat ambient) becomes the primary navigation tool. Constant pitch = no threat. Rising pitch = sentry approaching. Falling pitch = sentry receding.
Voice 2 (Movement feedback) persists but cannot predict sentry ticks. Operator must react to Voice 1 changes in real time.
Voice 3 (Environmental) is absent in CHAOS MODE (no hazards). Silence = pure focus.

Advanced operators (proficiency 85+) navigate CHAOS MODE primarily by ear, using Voice 1 as real-time threat sonar.

16. DETAILED DESIGN NOTES FOR ENGINEERS

Physics & Collision

Grid cells are atomic units. No sub-cell movement. Player occupies one cell. Sentry occupies one cell. Collision = same cell at same turn.
Movement is synchronous. Every keystroke = 1 game turn. All sentries advance simultaneously on the same turn the operator moves.
Wall passability is binary. A wall cell is impassable. There is no “sliding” along walls. Operator must navigate around.
Hazard cells are passable but damaging. Operator can enter a hazard cell but takes 1-2 damage. Hazards do not block sentries (sentries avoid them via patrol route generation).

Sentry AI

Patrol routes are deterministic. Seeded by LFSR at grid generation. Identical route every time operator plays the same grid (same seed).
Detection is line-of-sight + audio. Raycasting for visual LOS. Keypresses generate audio detectable up to 6 cells away.
Alert escalation: Once detected, sentry increases alert level by +1 per turn until contact is lost (3 turns of no detection = reset).
At alert level 5+: Sentry’s cycle speed doubles. Effectively: sentry moves every turn instead of every 2 turns.

Proficiency Calculations

proficiency_gain_per_session = checkpoint_bonus
                              + sentry_evasion_bonus
                              + path_optimization_bonus
                              + consistency_bonus
                              + mistake_penalty
                              + flow_state_multiplier

checkpoint_bonus = checkpoints_collected * 2
sentry_evasion_bonus = (min_distance_to_sentry >= 4) ? 1 : 0
path_optimization_bonus = (moves_used / optimal_moves) <= 1.1 ? 2 : 0
consistency_bonus = (no_corrections_this_session) ? 2 : 0
mistake_penalty = corrections_made * -1
flow_state_multiplier = (detected_flow_state) ? 1.5 : 1.0

final_gain = (checkpoint_bonus + sentry_evasion_bonus + path_optimization_bonus
              + consistency_bonus + mistake_penalty) * flow_state_multiplier

Save State

Universal Deck State (64 bytes SRAM) stores:

struct DeckState {
    uint8_t operator_handle[16];        // Operator name
    uint32_t credits;                   // Currency
    uint8_t reputation;                 // 0-255 (capped)
    uint32_t cartridge_history;         // 32 bits: which modules loaded

    // NeonGrid-specific proficiency
    uint8_t neongrid_proficiency;       // 0-100
    uint8_t neongrid_precision;         // 0-255
    uint8_t neongrid_flow_multiplier;   // 100-255 (as percentage)
    uint8_t neongrid_sentry_accuracy;   // 0-255
};

Performance Targets

Grid render: <16ms (60 FPS target).
Sentry AI update: <4ms (per turn, synchronous).
Input latency: <50ms (keypress to screen update).
Proficiency calculation: <2ms (per mission complete).
Memory footprint: <32 KB (entire module + grid state).

CONCLUSION

NeonGrid is both a teaching tool and a persistent skill-building platform. It is the first module every operator experiences, the foundation upon which all other modules are built. By mastering NeonGrid’s grammar—the 31 keys, the numpad as spatial extension, the audio as spatial feedback—operators internalize the Deckline’s philosophy: information is everywhere, speed is tempting, precision is everything.

An operator who completes the first 50 hours of NeonGrid will navigate the entire KN-86 ecosystem with confidence. Their hands will know the keys. Their ears will hear threat patterns. Their mind will hold spatial models of arbitrary complexity. They will be ready for any cartridge module.

And some operators never leave NeonGrid. They return weekly to maintain sharpness, to meditate, to compete. The grid becomes their practice field. The sentry becomes their opponent. The proficiency metric becomes their score. NeonGrid is complete unto itself.

Welcome to the Deckline, Operator. The grid awaits.

END OF SPECIFICATION

CIPHER-LINE Contributions

NeonGrid declares the following cipher-grammar block.

Vocabulary Pools

(:subject       "grid" "sentry" "packet" "route" "corridor"
                "checkpoint" "drone" "node" "cell")
(:object        "path" "corner" "dead-end" "loop" "shortcut")
(:location      "grid" "corridor" "sector" "corner" "ring")
(:verb-present  "patrols" "routes" "hums" "holds" "crosses"
                "turns" "watches")
(:verb-past-participle "traced" "cleared" "mapped" "missed"
                       "looped")
(:memory-keyword "sentry" "packet" "corridor" "checkpoint" "loop")
(:affect-word   "clean" "loud" "tight" "watched" "quiet")

Production Fragments

(:mode-observe
  (3 (:subject) ". " (:heading?))
  (2 (:location) ". " (:verb-present) ".")
  (2 "turn " (:neongrid/cardinal) ".")
  (1 "checkpoint."))

(:mode-annotate
  (3 "clean line. " (:affect-word) ".")
  (2 "corner. " (:affect-word) ".")
  (1 "too loud."))

(:mode-reflect
  (3 "same corridor. " (:memory-fragment))
  (2 "this sentry. " (:memory-fragment)))

(:mode-drift
  (2 "three loops in that ring.")
  (1 "the cold corner.")
  (1 "the packet that never arrived."))

(:neongrid/cardinal
  (3 "north.") (3 "south.") (3 "east.") (3 "west."))

:event-types
  ((:type :checkpoint-reached :affect (:routine))
   (:type :sentry-line-of-sight :affect (:tense))
   (:type :packet-dropped     :affect (:tense))
   (:type :grid-complete      :affect (:significant)))

Mode-Weight Biases

Beat	`observe`	`annotate`	`reflect`	`drift`	`silent`
`:active-hack` (= navigation)	+0.05	—	—	—	+0.05
`:high-tense` (sentry close)	—	—	—	—	+0.15
`:debrief` (clean run)	—	+0.10	+0.05	—	—

Rationale. NeonGrid is pedagogy — the voice shouldn’t tell the operator what to do. It observes and shuts up. Silence lets the PSG cardinal tones own the learning channel.

Style Deltas

((:active-hack (:terseness +48 :certainty +16))
 (:high-tense  (:terseness +56 :certainty +0))
 (:debrief     (:terseness -8 :certainty +32)))

NeonGrid’s voice is more certain than Depthcharge’s — the grid is knowable, and at debrief the voice is confident: “clean.”

Structurally Important Moments Preserved on CIPHER-LINE

Beat	Intent	CIPHER-LINE fragment(s)
First checkpoint	”Checkpoint reached. Continue.”	`checkpoint. keep going.`
Sentry line-of-sight	”Sentry scanning. Freeze or duck corner.”	`seen. corner.` (tense)
Packet collected	”Data packet acquired.”	`packet.`
Clean grid complete	”Grid cleared. No corrections. Excellent.”	`clean. no corrections.` (annotate at debrief)

nEmacs Contributions

Per ADR-0016 (nEmacs + REPL + Input Model), each cart declares what its scripted-mission surface looks like — grammar fragments contributed to the predictive palette, domain vocabulary that earns the +5 ranking boost (ADR-0016 §7), whether it uses prompt-text for raw text entry (§8), and whether any of its keys bind :double-tap or :long-press events (§9). NeonGrid teaches the KN-86 grammar through play — and scripting, uniquely, is where the operator closes the loop on that learning: after forty hours of embodying CAR/CDR, the operator who opens nEmacs to script a checkpoint-sequence is using the exact same verbs in a new mode.

Scripted Missions?

Yes — checkpoint sequencing and pattern recognition scripting. Rep-8+ operators unlock Flow State contracts that reward pre-authored checkpoint routes and sentry-avoidance heuristics. NeonGrid’s scripting is deliberately lightweight — the cart is a pedagogy piece, so its scripted-mission surface is intentionally shaped to feel like natural extension of grid navigation, not an escape to a different paradigm. Scripted missions remain optional on the critical path (ADR-0002); most NeonGrid play is direct navpad input.

Typical scripted-mission shapes:

(route-to checkpoint) — A* from current position.
(avoid-sentries (pattern :standard-patrol)) — pathing heuristic.
(on-sentry-seen (freeze)) — reactive handler.
(grid-describe) — emits a structured view of the current grid.

Cart Grammar Fragments

Contributed via (emacs-extend-grammar ...) at cart-load:

(emacs-extend-grammar
  ;; Grid primitives
  (grid)                                        ; current grid state
  (cell               (coord))
  (neighbors          (coord))
  (checkpoints)                                 ; list of remaining
  (visited?           (coord))
  (wall?              (coord))
  ;; Sentries
  (sentry             (id))
  (sentry-patrol      (id))                     ; pattern / cycle
  (sentry-line-of-sight)                        ; current LoS cells
  (sentries-aware?)                             ; any in alarm state?
  ;; Movement primitives
  (move               (direction))              ; :n :s :e :w
  (route-to           (coord))
  (avoid-sentries     (strategy))
  (freeze)
  (backtrack          (n))
  ;; Event binders
  (on-sentry-seen     (&body handler))
  (on-checkpoint      (&body handler))
  (on-grid-complete   (&body handler))
  ;; Progress
  (packets-collected)
  (corrections-made)
  (flow-state?))                                ; zero-correction predicate

Vocabulary Contribution

Via (emacs-extend-vocabulary ...). Navigation / spatial / sentry-pedagogy terms:

(emacs-extend-vocabulary
  "grid" "cell" "coord" "neighbor" "wall"
  "checkpoint" "packet" "route" "path" "segment"
  "sentry" "patrol" "cycle" "awareness" "alarm"
  "line-of-sight" "corner" "freeze" "duck"
  "north" "south" "east" "west" "diagonal"
  "flow" "clean" "correction" "precision"
  "traversal" "visited" "backtrack" "loop"
  "maze" "layout" "topology" "entry" "exit")

`prompt-text` FFI Usage

No. NeonGrid is pure primitive-and-numpad; every input is a direct key press. The cart declares nothing via prompt-text. Training-mode variant names and grid-pack labels come from the cart’s catalog, not typed input.

Double-Tap and Long-Press Bindings

NeonGrid opts into ADR-0016 §9 minimally — the pedagogy cart teaches single-press clarity, and multi-level bindings are reserved for analysis / debrief rather than mid-run:

Key	`:tap`	`:double-tap`	`:long-press`
`INFO`	`inspect-cell`	`inspect-sentry-pattern` — current sentry’s full patrol cycle	`show-corrections-this-run` — debrief helper
`CAR`	`descend-into-cell` (marker layer)	—	—
`QUOTE`	`drop-path-marker`	—	`clear-all-markers`

Row 24 renders: INFO:CELL INFO²:PATROL INFO…:STATS CAR:MARK QUOTE:MARKER QUOTE…:CLEAR.

Context-Polymorphic Key Semantics (Cart Gameplay)

NeonGrid has two primary cursor contexts: navigation (actively moving through the grid) and debrief (post-run review):

Key	Navigation	Debrief
`INFO`	inspect-cell	show-segment-stats
`CAR`	descend-into-cell	drill-into-segment
`CDR`	next-marker	next-correction-event
`EVAL`	(unused — grid uses direct numpad)	export-replay
`QUOTE`	drop-marker	flag-segment
`BACK`	return-to-grid-overview	exit-debrief
Numpad 2/4/6/8	N/S/W/E directional move	grid-cell navigation

When the operator opens nEmacs to script a route helper, dispatch yields to :nemacs-nav per ADR-0016 §3 — standard editor dispatch. NeonGrid’s “structural” nature (CAR/CDR muscle memory from nav) means operators find the editor keymap familiar faster than they do for other carts. | Hot-swap invitation (to ICE Breaker) | “Spatial reasoning ready. Network waits.” | grid mapped. then network open. |