KN-86 Deckline — Nodespace Gameplay Specification

Module Class: 0x0A — Network Strategy
Publisher: Kōji Interactive (Kyoto)
Category: Strategy
Release Tier: Launch Library
Target Duration: 20–100 turns per contract (single session to multi-session campaigns)

Version: 1.0
Date: April 11, 2026
Author: Josh Schairbaum / KN-86 Build Team
Status: Engineering Specification

CIPHER-LINE revision note (2026-04-24): Nodespace’s Cipher voice — territory assessments, adversary commentary, phase observations — renders on the CIPHER-LINE OLED, not the main 80×25 grid. The voice is academic but not pedantic — the Takezo Institute’s Go-player ancestry. See the CIPHER-LINE Contributions section at the end. 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 (DECIDE OBSERVE OBTAIN)
  :affinities (NETWORK PHYSICAL))

Nodespace is the launch library’s territory-strategy cart and a primary NETWORK anchor alongside ICE Breaker. CLAIM/FORTIFY commitments under opponent pressure satisfy DECIDE; SCOUT and reading opponent personality satisfy OBSERVE; capturing contested nodes satisfies OBTAIN. Affinities are NETWORK (topology of contested nodes and supply lines) and PHYSICAL (territorial ownership has real spatial extent). Default biases.

---

Table of Contents

1. Design Philosophy
2. The Strategic Loop
3. System 1: The Network
4. System 2: The Toolkit
5. System 3: The Opponent
6. System 4: Sound Design
7. Cell Architecture
8. Key Mapping
9. Hot Swap Integration
10. Mission Templates
11. Screen Wireframes
12. Session Walkthrough: The Campaign
13. Design Notes

---

Design Philosophy

Nodespace is the strategic counterweight to the tempo-driven modules. Where ICE Breaker forces split-second OODA cycles and Depthcharge demands constant environmental reaction, Nodespace inverts the pressure. The operator owns the clock. Turns are discrete, synchronized actions. The opponent — a procedurally generated AI personality — adapts and learns, but never surprises with time pressure.

The core metaphor is territory on abstract node networks. Go-like positioning and positional ownership. Each node is a contested foothold. Edges represent supply lines. Control comes from majority ownership, fortification, and the ability to read an opponent’s long-term strategy arc.

The design is contemplative, not urgent. No timer. No failing because you couldn’t decide fast enough. The pacing is determined by the operator’s thought process: analyze the board, commit to a strategy, resolve the consequences, reflect on what the opponent just revealed about itself. This rhythm — OBSERVE → ASSESS → COMMIT → RESOLVE — is turn-based and inherently different from ICE Breaker’s OODA loop.

The opponent is the second protagonist. Nodespace teaches the operator to recognize personality in algorithm. AGGRESSIVE is blunt. DEFENSIVE is reactive. ADAPTIVE learns from you. ASYMMETRIC reads the arc of history. Playing against them is less about winning and more about understanding the kind of mind you’re facing.

---

The Strategic Loop

Turn Structure: Operator Action Phase → Opponent Action Phase → State Transition

The game runs in discrete, synchronized turns. No time pressure. No simultaneous movement resolution — the operator sees the opponent’s move, responds, then the opponent responds to the response. Over many turns, this creates readable strategic narratives.

Operator Turn

The operator observes the current board state (network topology, node ownership, supply lines). They can:

1. CLAIM — Exert influence on an adjacent neutral node (costs influence action). Requires one adjacent node under operator control and line of sight (direct edge). Neutral nodes require 1 action; contested nodes (opponent-controlled) require 2 actions over two turns.
2. FORTIFY — Strengthen an owned node against capture (costs influence action). Increases the node’s defense level by 1 (max 3). Fortified nodes require more opponent actions to contest.
3. SCOUT — Examine opponent’s possible next moves (costs influence action, available only at Rep 15+). Operator sees opponent’s action pool and intended target.
4. WAIT — Pass the turn, preserving actions for the next round (no cost). Strategic patience.

Action Pool: The operator has 3 actions per turn. Actions reset on the opponent’s turn completion.

Opponent Turn

The opponent AI executes its programmed behavior. The operator watches (or uses SCOUT to read ahead). The opponent’s move advances its own strategy arc. The operator learns something about how this opponent thinks.

Phase Transitions (ASYMMETRIC Opponents)

Opponents with personality type ASYMMETRIC follow a multi-phase strategy that unfolds over the game’s turns. The opponent will NOT broadcast its current phase to the operator. Instead, the operator must infer from the pattern of moves:

• Phase 1 (Consolidation): Opponent defends its starting territory, rarely attacks. Operator often mistakes this for passivity.
• Phase 2 (Expansion): Opponent shifts to aggressive node claiming. Supply lines become critical. Operator must decide whether to defend or mirror-match.
• Phase 3 (Severance): Opponent abandons some nodes to isolate operator’s territory. High-risk, high-reward endgame play.

The operator wins Nodespace contracts by recognizing these phase transitions and timing their own strategic pivots accordingly.

---

System 1: The Network

Node Architecture

A network consists of 12–16 nodes (size varies by threat level and reputation). Each node is a discrete territorial unit.

Node States:

• Neutral: No owner. Requires 1 influence action to claim from an adjacent owned node.
• Operator Controlled: Amber text, filled circle (●). Grants operator 1 supply point per turn per adjacent owned node.
• Opponent Controlled: Red text, hollow circle (○). Opponent gets supply points from adjacent nodes.
• Contested: Alternating amber/red dot (⊙). Node is under dispute; ownership will shift this turn or next.
• Fortified: Node with defense level ≥ 1. Requires 2 opponent actions (instead of 1) to contest. Visually marked with a box: ■.

Supply Lines

Nodes gain supply strength based on the number of adjacent nodes they own. Supply strength affects:

• Defense: A fortified node with 2+ adjacent friendly nodes gains +1 defense (stacks with explicit fortification).
• Capture Cost: A node with high supply strength takes more opponent actions to capture (because it’s “well defended”).
• Territory Scoring: The game counts not just node count but also supply connectivity. Isolated node clusters are vulnerable.

Network Topology Types

Three procedurally generated layouts determine strategic complexity:

CLUSTERED

3–4 clusters of 4–5 connected nodes each, with 1–2 bridge nodes connecting the clusters. Strategic depth: operator and opponent start in opposing clusters and race to control bridge nodes.

Example:

┌─ NORTH ─┐           ┌─ SOUTH ─┐
│ ● ○ ○   │           │   ○ ○   │
│  \ | /  │           │   | |   │
│   [N2]──┼───[B1]────┼──[S1]   │
│  / | \  │           │   | |   │
│ ● ○ N1  │           │   ○ ● ● │
└────────┘           └─────────┘
  OPERATOR             OPPONENT

Bridge nodes (B1) are critical choke points. Control of bridge = dominance.

LINEAR

Nodes arranged in a single line (1D topology). Opponent on one end, operator on the other. Victory = claiming the center first.

Operator: ●─○─N─N─N─N─○─N─N─N─○─●─ :Opponent
         Start                 Start

Linear networks lead to direct confrontation. No encirclement; only breakthrough. Faster games (20–30 turns). Teaches direct combat rather than positional strategy.

RADIAL

Central hub with 8–12 spokes radiating outward. Operator and opponent each control 1–2 outer nodes. The hub is the prize. Reaches back-and-forth play because every approach to the hub is contested.

         ┌─ S1
         │
S8 ─ Operator
         │
    ┌────●────┐  ← Hub
    │         │
  S2 ─ HUB ─ S7
    │         │
 Opp─────────┴─ S6
   S3      S5 ─ S4

Radial is the highest-complexity topology. Every move toward the hub puts you on an axis where the opponent can respond. Games run 40–50 turns. Teaches reading multiple threats simultaneously.

Victory Conditions

Standard: Territory Majority
Operator wins by controlling ≥ 50.1% of nodes when:

• Explicitly claimed majority (50% + 1 node) with the current turn distribution, OR
• Opponent resigns (reputation drops below the AI’s calculated win probability)

Extended: Supremacy Marathon
Rare contracts (Rep 50+) run 50–100 turns. Victory is determined at the final turn, not the first majority. Both players may swing from leading to losing multiple times. The player with more nodes at turn limit wins. High strategic depth; tests endurance and adaptation.

Alternate: Node Encirclement
Operator wins if they isolate and capture the opponent’s starting territory (cut all edges connecting opponent nodes to the rest of the network). Requires careful supply line management. Opponent can counter by breaking out first.

---

System 2: The Toolkit

The operator’s toolkit consists of five actions, all driven by the numpad and cardinal keys. The core loop cycles through the action menu, selects a target, executes, and moves to the opponent’s turn.

Core Actions

CLAIM (Numpad: CAR, Numpad: [target node])

Exert influence on a node to bring it under operator control. The target must be:

• Adjacent to a node the operator already owns (direct edge connection)
• Neutral OR Opponent-controlled

Neutral Node: Costs 1 influence action. The node becomes amber (operator controlled) immediately.

Opponent Node: Costs 2 influence actions (over 2 consecutive turns). Turn 1 of contest: node becomes ⊙ (contested). Turn 2 of contest: node flips to amber (operator controlled). If the opponent spends actions to fortify during the contest, the cost rises to 3 actions.

Example:

Turn 12: Operator has nodes {1, 2, 3}. Node 4 is neutral, edge-adjacent to node 2.
         Operator spends 1 action: CLAIM node 4.
Turn 13: Node 4 is now amber (●). Operator controls {1, 2, 3, 4}. Opponent's turn.
         Opponent claims node 5 (adjacent to their territory).
Turn 14: Operator can contest opponent's node 7 (requires node 6 or neighbor). But node 6 is
         opponent-controlled and not owned by operator. Cannot claim node 7 yet.

FORTIFY (Numpad: CDR, Numpad: [target node])

Strengthen an owned node against capture. Target must be operator-controlled (amber).

• Base Cost: 1 influence action per fortification level
• Effect: Node gains +1 to defense rating (max +3)
• Defense Bonus: A fortified node with 2+ adjacent friendly nodes gains automatic +1 (stacks)
• Visual: Fortified nodes display as ■ (box) instead of ● (circle). Level shown as ■¹, ■², or ■³.

Opponent’s Perspective: When the opponent tries to capture a fortified node:

• Unfortified node: 1 action to contest, 1 more to claim (2 total over 2 turns)
• Fortified +1: 2 actions to contest, 1 to claim (3 total)
• Fortified +2: 2 actions to contest, 2 to claim (4 total)
• Fortified +3: 3 actions to contest, 2 to claim (5 total) — nearly impossible for weak AI to crack

Strategy: Fortification creates bottlenecks. A well-fortified bridge node can hold against a numerically superior opponent for many turns.

SCOUT (Numpad: INFO, Numpad: [target opponent node])

Availability: Rep 15+ only. Costs 1 influence action.

Examine the opponent’s intended move for the next turn. The operator sees:

• Which node the opponent will claim or fortify
• How many actions the opponent will spend
• Which nodes the opponent is considering as fallback targets

Limitation: SCOUT is not perfect. Opponent AI can lie (ASYMMETRIC opponents sometimes fake-signal to confuse). ADAPTIVE opponents randomize 10% of their decisions. AGGRESSIVE opponents are always transparent.

Example:

Turn 15: Operator uses SCOUT on opponent's turn planning.
         Opponent is deciding between [Claim Node 8] or [Fortify Node 4].
         SCOUT reveals: "Opponent intends Node 4 (fortification)."
         Operator can now defend Node 8, knowing it's safe for 1 more turn.

WAIT (Numpad: 5)

Pass the turn without spending actions. Preserves actions for the next round. Strategic patience.

When to Use:

• Opponent has only 1 action left; you want to see where they spend it before committing
• You’ve run out of viable claims/fortifications and want to preserve action economy
• You’re intentionally giving opponent a turn advantage (high-risk play testing)

QUOTE (Numpad: QUOTE, Numpad: [target node])

Availability: Rep 25+ only. Costs 0 actions.

Bookmark the current board state or a specific node for comparison. QUOTE is a runtime-level feature (cross-module). The operator can save up to 8 board snapshots and compare them using EQ.

Use Case: Operator records board state on Turn 10 and Turn 25 to visually compare how the opponent’s strategy has evolved. This is pure analysis, not tactical.

EQ (Numpad: EQ)

Availability: Rep 25+ only. Costs 0 actions (uses bookmarked QUOTE slots).

Compare two board states side-by-side. The display shows:

• Territory distribution at snapshot 1 vs. snapshot 2
• Node deltas (which nodes changed hands)
• Opponent’s net movement (e.g., gained 3 nodes, lost 1)
• Inferred strategy shift (if any)

---

System 3: The Opponent

The opponent is an AI personality. The operator does not see the algorithm — only its outputs. Understanding the opponent’s personality is the highest strategic skill Nodespace teaches.

Personality Types

AGGRESSIVE (Threat 1–2)

Strategy: Maximize node count as fast as possible. No subtlety. No defense investment. Opponent claims every available adjacent node each turn.

Characteristics:

• Predictable movement. Always expands unless blocked.
• Weak to encirclement. Aggressive opponent leaves its rear exposed.
• Fast games (20–25 turns typical). Early victory is common.
• No phase transitions. Behavioral consistency throughout.

Opponent Heuristic:

each_turn:
  for node in [adjacent_neutral_nodes]:
    if available_actions > 0:
      claim(node)
  if remaining_actions > 1:
    fortify(my_core_node)

When to Play: Learning operator (Rep 0–4). Tests positioning and supply line basics.

DEFENSIVE (Threat 2–3)

Strategy: Consolidate held territory. Create buffer zones. Respond reactively to operator advances. Rarely initiates attacks.

Characteristics:

• Reactive. Waits for operator to attack, then defends.
• Fortifies aggressively. Opponent nodes have high defense (avg. +2).
• Long games (30–40 turns). Defensive matches are grinds where territory trades slowly.
• No phases. Static strategy throughout.

Opponent Heuristic:

each_turn:
  threats = [operator_nodes_adjacent_to_mine]
  if threats:
    fortify(threatened_nodes)  // -1 action per threat
  else:
    claim(random_adjacent_neutral)  // or WAIT if none

When to Play: Intermediate operator (Rep 5–14). Tests patient positioning and long-game thinking.

ADAPTIVE (Threat 3–4)

Strategy: Learn from operator’s moves. Adapt tactics in response. Remembers patterns.

Characteristics:

• Learns. If operator uses encirclement in turns 1–5, opponent defends supply lines harder in turns 6+.
• Memory-based. Opponent tracks operator’s last 3 moves and shifts behavior accordingly.
• Variable games (30–50 turns). Early games differ drastically from late games.
• No hard phases, but behavior evolves continuously.

Opponent Heuristic:

each_turn:
  recent_ops = [operator_moves_last_3_turns]
  if "encirclement_pattern" in recent_ops:
    fortify(supply_nodes)  // Defend against encirclement
  elif "aggressive_claiming" in recent_ops:
    mirror_aggressive()    // Match operator's tempo
  else:
    cautious_consolidate()

Read: The operator must watch how the opponent’s behavior changes. By turn 20, they’ll notice the opponent stopped expanding (learned that expansion is exploited). This recognition is mastery.

When to Play: Advanced operator (Rep 15–24). Tests meta-game play.

ASYMMETRIC (Threat 4–5)

Strategy: Follow a hidden multi-phase plan unknown to the operator. Deploy tactics in preset sequence. Does not adapt to operator moves; instead, reveals strategy phases at predetermined turn thresholds.

Characteristics:

• Phase-based. Behavior is completely different in each phase, but phases are tied to turn count, not operator actions.
• Hidden agenda. Operator must infer what phase the opponent is in by watching moves.
• High surprise factor. Operator thinks they’re winning; opponent suddenly pivots to a phase they didn’t anticipate.
• No learning. Opponent does not react to operator’s tactics; only to timer-based phase transitions.

Phase Breakdown:

Turns 1–10: Consolidation Phase
Opponent defends core territory. Minimal aggression. Operator often mistakes this for weakness.

Turns 11–25: Expansion Phase
Opponent shifts to aggressive node claiming. Claims 2–3 nodes per turn. Operator must decide: defend or contest?

Turns 26+: Severance Phase
Opponent abandons peripheral nodes to isolate operator’s core. High-risk, high-reward endgame. Opponent is willing to lose nodes to cut supply lines.

Example Game Arc (ASYMMETRIC, 50 turns):

Turns 1–10:   Operator claims 5 nodes. Opponent claims 3. Operator feels ahead.
Turns 11–15:  Opponent suddenly aggressive. Claims 4 nodes. Operator panics.
              This is phase transition. Most operators don't recognize it yet.
Turns 16–25:  Mid-game dogfight. Both players at ~8 nodes. Opponent is learning
              to be aggressive and it's working. Operator must adapt.
Turns 26–35:  Opponent begins isolating operator's territory. Claims 2 nodes, then
              stops claiming. Why? Opponent is cutting supply lines instead.
              Operator territory now has islands (disconnected clusters).
Turns 36–50:  Endgame. Operator must break through to rejoin territory or lose.
              Opponent wins if it can hold isolation for 14 turns.

Read: The operator wins ASYMMETRIC contracts by recognizing the phase transitions early (turns 8–11, not turn 15) and timing counter-strategies accordingly.

When to Play: Expert operator (Rep 25–49). Tests strategic foresight.

Threat Scaling

Threat	Personality	AI Heuristic Depth	Action Efficiency	Game Length	Payout Base
1	AGGRESSIVE	2 (claim, fortify)	100%	20 turns	150 ¤
2	AGGRESSIVE / DEFENSIVE	3–4	80%	25–30 turns	250 ¤
3	DEFENSIVE / ADAPTIVE	5–6	70%	35–40 turns	400 ¤
4	ADAPTIVE / ASYMMETRIC	7–8	60%	45–50 turns	600 ¤
5	ASYMMETRIC	9+	50%	50–100 turns	800 ¤

---

System 4: Sound Design

Nodespace’s audio is contemplative and ambient. No urgency. No timers. Three PSG voices create a layered soundscape that reflects board state, opponent activity, and operator tension.

Voice Assignments

Voice 1: Territory Balance (Ambient Heartbeat)

Baseline: 220 Hz (A3), sustained sine wave, very low volume (-12dB).

Modulation: Pitch rises and falls based on territory ownership balance. When operator has 60% nodes, frequency rises. When opponent has 60%, frequency falls. Creates an equilibrium tone around 220 Hz at 50/50 control.

Envelope: Slow 2-second attack/decay. The tone is always present but breathing (never harsh).

Variation by Personality:

• AGGRESSIVE: Sharp 440 Hz pulses every 3 seconds (frenetic energy)
• DEFENSIVE: Slow, deep rumble (110 Hz baseline, very calm)
• ADAPTIVE: Frequency drifts subtly (±30 Hz) — unsettling, responsive
• ASYMMETRIC: Phase transitions trigger envelope shifts (clear audio signal of phase change)

Voice 2: Opponent Activity (Proximity Tone)

Baseline: 330 Hz (E4), pulsing envelope (0.5s on, 0.5s off).

Modulation: Pulsing rate accelerates based on opponent’s action pool remaining. Opponent with 3 actions = 1 pulse/second. Opponent with 1 action = 3 pulses/second. Opponent with 0 actions = silence.

This gives the operator an audio cue of when the opponent’s turn ends without looking at the display.

Silence Signal: When Voice 2 goes silent (opponent exhausted actions), operator knows opponent is “waiting” or has no viable moves.

Voice 3: Phase Transitions & Events (Feedback)

Baseline: Silence (no ambient).

Events:

• Operator claims neutral node: 440 Hz beep (0.2s) — success confirmation
• Node contested: 330–220 Hz pitch descent (0.3s) — tactical alert
• Opponent claims operator node: 165 Hz low tone (0.4s) — threat notification
• Encirclement detected: 880 Hz sharp burst × 3 (0.1s each) — danger signal
• Supply line cut: Filtered noise sweep 2kHz→500Hz (0.6s) — strategic loss
• Phase transition (ASYMMETRIC): Harmonic swell (220+330+440 Hz overlay, 1s) — major shift
• Victory: Rising arpeggio 440–554–659 Hz (1s) — triumph
• Defeat: Descending arpeggio 440–330–220 Hz (1s) — resignation

Audio Design Philosophy

The sound is non-diegetic (not “coming from” the device — it’s the game’s narration). It is never startling. All transitions are smooth. The operator should be able to play with eyes closed and understand board state from audio alone.

Voice 1 teaches overall balance. Voice 2 teaches opponent urgency. Voice 3 provides discrete event feedback. Together, they create a real-time audio representation of the game state.

---

Cell Architecture

Nodespace uses a hierarchical cell composition to represent the game state, board topology, and AI opponent. All cells fit within the 256-byte max and the 4096-byte pool.

Cell Type: NETWORK_CELL

Purpose: Root cell. Represents the entire contract (game state, topology, victory conditions).

CELL_DEFINE(NETWORK_CELL) {
    CellBase base;
    uint8_t contract_id;          /* 0–127 */
    uint8_t threat_level;         /* 1–5 */
    uint8_t personality_type;     /* 0=AGGRESSIVE, 1=DEFENSIVE, 2=ADAPTIVE, 3=ASYMMETRIC */
    uint8_t topology_type;        /* 0=CLUSTERED, 1=LINEAR, 2=RADIAL */
    uint8_t node_count;           /* 12–16 */
    uint8_t current_turn;         /* 0–255 */
    uint8_t turn_limit;           /* 20–100 */
    uint16_t operator_nodes;      /* Bitmask: which nodes (0–15) operator controls */
    uint16_t opponent_nodes;      /* Bitmask: which nodes opponent controls */
    uint16_t game_state_hash;     /* CRC16 of board for resume/load verification */
    uint8_t operator_action_pool; /* 0–3 actions remaining this turn */
    uint8_t opponent_action_pool; /* 0–3 actions remaining for opponent */
    uint8_t opponent_ai_phase;    /* 0=N/A, 1–3 for ASYMMETRIC */
    uint8_t operator_rep;         /* Reputation (0–255) affects UI/unlock access) */
    uint16_t payout_base;         /* Base payout for this contract (threat-derived) */
    uint8_t victory_bonus_pool;   /* Turns remaining × multiplier for speed bonus */
    uint8_t reserved[16];         /* Expansion */
};

Size: ~60 bytes. Comfortably fits in cell pool with room for children.

Cell Type: NODE_CELL

Purpose: Individual node. Represents a territory unit with ownership, fortification, and supply state.

CELL_DEFINE(NODE_CELL) {
    CellBase base;
    uint8_t node_id;              /* 0–15 */
    uint8_t owner;                /* 0=NEUTRAL, 1=OPERATOR, 2=OPPONENT */
    uint8_t defense_level;        /* 0–3 (base fortification) */
    uint8_t defense_bonus;        /* +0 to +2 from adjacent supply */
    uint8_t action_cost_to_claim; /* 1–5 (influenced by defense + supply) */
    uint8_t supply_strength;      /* Count of adjacent friendly nodes */
    uint8_t is_contested;         /* 0=no, 1=yes (turn 1 of 2-turn capture) */
    uint8_t years_held;           /* Turns this owner has held it (narrative) */
    uint8_t adjacent_node_ids[4]; /* Edge list (up to 4 neighbors) */
    uint8_t reserved[16];
};

Size: ~35 bytes per node. 16 nodes = 560 bytes total (fits in pool).

Cell Type: EDGE_CELL

Purpose: Connection between two nodes. Tracks supply line status and contest state.

CELL_DEFINE(EDGE_CELL) {
    CellBase base;
    uint8_t node_a;               /* Node ID 1 */
    uint8_t node_b;               /* Node ID 2 */
    uint8_t status;               /* 0=NEUTRAL, 1=OPERATOR_CONTROLLED, 2=CONTESTED, 3=OPPONENT_CONTROLLED */
    uint8_t is_bridge;            /* 1 if edge connects two major clusters (CLUSTERED only) */
    uint8_t reserved[16];
};

Size: ~20 bytes per edge. Typical network has 16–20 edges = ~400 bytes total.

Cell Type: AI_STATE_CELL

Purpose: Encapsulates opponent AI personality and decision state. Only one per NETWORK_CELL.

CELL_DEFINE(AI_STATE_CELL) {
    CellBase base;
    uint8_t personality;          /* 0=AGGRESSIVE, 1=DEFENSIVE, 2=ADAPTIVE, 3=ASYMMETRIC */
    uint8_t current_phase;        /* 0=N/A, 1–3 for ASYMMETRIC (hidden from operator) */
    uint8_t recent_moves[6];      /* Last 6 operator moves (ADAPTIVE uses this) */
    uint8_t learned_pattern;      /* Pattern ID (if ADAPTIVE has detected one) */
    uint8_t action_queue[3];      /* Next 3 opponent actions (pre-computed) */
    uint8_t threat_assessment;    /* How threatening opponent perceives operator (0–100) */
    uint8_t next_target_node;     /* Which node opponent will claim/fortify next turn */
    uint8_t random_seed;          /* LFSR seed for nondeterministic decisions (ADAPTIVE only) */
    uint8_t reserved[16];
};

Size: ~40 bytes. One per game.

Composition Example: TERRITORIAL CONTROL

┌─ NETWORK_CELL (Threat 2, DEFENSIVE, 14-node CLUSTERED network, Turn 8/30)
│  node_count: 14
│  operator_nodes: 0xAA55 (bitmask: nodes {0,2,4,6,8,10,12,14})
│  opponent_nodes: 0x55AA (nodes {1,3,5,7,9,11,13,15})
│  current_turn: 8
│  turn_limit: 30
│
├─ NODE_CELL[0] (node_id: 0, owner: OPERATOR, defense: 1, supply: 2, adjacent: {1,4,8})
├─ NODE_CELL[1] (node_id: 1, owner: OPPONENT, defense: 2, supply: 2, contested: 0)
├─ NODE_CELL[2] (node_id: 2, owner: OPERATOR, defense: 0, supply: 1, adjacent: {3,6})
├─ ... (12 more NODE_CELLs)
│
├─ EDGE_CELL (node_a: 0, node_b: 1, status: NEUTRAL)
├─ EDGE_CELL (node_a: 0, node_b: 4, status: OPERATOR_CONTROLLED)
├─ EDGE_CELL (node_a: 4, node_b: 8, status: CONTESTED) ← Bridge edge
├─ ... (13+ more EDGE_CELLs)
│
└─ AI_STATE_CELL (personality: DEFENSIVE, phase: 0, threat_assessment: 65, next_target: 7)

Total Size: ~500 bytes (within pool limits).

---

Key Mapping

All interactions use the 31-key Deckline layout. Nodespace respects universal key bindings but adds context-specific numpad actions.

Universal Keys (System-Level)

Key	Function
SYS (hold)	Abort contract, return to bare deck
BACK	Exit menu, return to board state, cancel action
INFO	Cycle display modes (3 views: Board / Node Tree / Opponent Profile)
INFO (2×)	Toggle between Board Grid View and Text Inspection Mode

Navigation Keys (Board-Level)

Key	Function
CAR	Select node (when in menu) / Drill into selected node detail
CDR	Scroll list (action history, opponent moves) / Cycle through nodes
LAMBDA	Record macro (sequence of moves for playback)
LAMBDA (double-tap)	Playback recorded macro

Numpad: Node Selection & Action (Data-Driven)

  7    8    9
  4  5(W)  6
  1    2    3

5 = WAIT / CENTER
8/2/4/6 = DIRECTIONAL SELECTION (N/S/W/E node, if applicable)
1,3,7,9 = DIAGONAL (rarely used, reserved)
NUMPAD_ENTER = CONFIRM selected action
NUMPAD_DOT = INSPECT selected node

Node Selection: When the operator presses numpad 8, the selection cursor moves “north” on the board (next node in the northward direction). 2 = south, 4 = west, 6 = east. The cursor wraps at board edges.

Action Menu Keys

Key	Function	Availability
APPLY	Execute selected action (CLAIM, FORTIFY, SCOUT, WAIT)	All
EVAL	Confirm action and end operator turn (submit to opponent phase)	All
QUOTE	Bookmark current board state for comparison	Rep 25+
EQ	Trigger comparison view (two QUOTE slots side-by-side)	Rep 25+

Example Interaction Sequence

Turn 8 / 30
Board displayed. Operator is at node 4 (amber, operator-controlled).

User presses: NUMPAD 6 (east)
  → Cursor moves east. Node 5 is now highlighted (neutral, green border).

User presses: CAR
  → Menu appears: [CLAIM (1 action)] [FORTIFY n/a (not owner)] [SCOUT n/a]

User presses: APPLY
  → Highlights [CLAIM]

User presses: EVAL
  → Action submits. Node 5 becomes contested. Operator action pool: 2/3 remaining.

Display updates. Opponent's turn begins.
Opponent AI moves. Operator watches.
Opponent's turn ends. Display resets for operator turn.

User presses: NUMPAD 2 (south)
  → Cursor moves south. Node 10 is now highlighted.

... (repeats for remaining actions)

User presses: EVAL with 0 actions remaining
  → Turn ends. Opponent phase begins.

---

Hot Swap Integration

Nodespace integrates with the capability model’s Hot Swap framework for multi-phase contracts. A strategic game can be interrupted, the cartridge swapped, and resumed in a second module, with the board state preserved.

Hot Swap Example: Network Mapping (3-Phase)

Contract: “NETWORK MAPPING”
Threat: 3
Phases:

1. Phase 1 (ICE BREAKER: Network Intrusion)

   • Duration: 2–3 turns
   • Operator: Intrude into a network, extract topology data
   • Output to phase_chain: network topology (node count, edge list)
   • Payout: 600 ¤

2. Phase 2 (NODESPACE: Territory Claim)

   • Duration: 30–40 turns
   • Operator: Play NODESPACE contract on extracted topology
   • Opponent AI: Seeded from ICE BREAKER threat level (higher threat = stronger AI)
   • Payout: 1200 ¤
   • Milestone: Reach 60% territory control before turn 40

3. Phase 3 (ICE BREAKER: Infrastructure Sabotage)

   • Duration: 1–2 turns
   • Operator: Sabotage opponent’s infrastructure (nodes you control in Phase 2)
   • Input: nodes operator controlled at Phase 2 end
   • Payout: 600 ¤ + 400 ¤ bonus (if nodes remain controlled)

Cartridge Swap Sequence:

Turn 3 of Phase 1 (ICE BREAKER): Operator completes intrusion.
  → Firmware: phase_chain[1] = {node_topology, threat_multiplier}
  → Display: "NETWORK TOPOLOGY EXTRACTED"
  → Display: "PHASE 2 REQUIRES: NODESPACE MODULE"
  → Display: "INSERT: NODESPACE CARTRIDGE"

User physically removes ICE BREAKER, inserts NODESPACE.

Firmware detects cartridge change.
The nOSh runtime loads NODESPACE.
  → Reads phase_chain[1]
  → Initializes NETWORK_CELL with topology from phase_chain
  → Spawns opponent AI (personality seeded by threat_multiplier)

NODESPACE boot screen:
  > MODULE LOADED: NODESPACE
  > PHASE 2 OF 3 — RESUMING
  > TERRITORY CLAIM — 30 TURNS

Game begins. Operator plays the territorial game on the extracted network.

[... 30 turns of NODESPACE gameplay ...]

Turn 30: Operator reaches 60% territory control. Phase complete.
  → Firmware: phase_chain[2] = {operator_nodes_bitmask, opponent_nodes_bitmask}
  → Display: "TERRITORY SECURED"
  → Display: "PHASE 3 REQUIRES: ICE BREAKER MODULE"
  → Display: "INSERT: ICE BREAKER CARTRIDGE"

User removes NODESPACE, reinserts ICE BREAKER.

The nOSh runtime loads ICE BREAKER Phase 3.
  → Reads phase_chain[2]
  → Initializes sabotage mission targeting operator's claimed nodes

[... Phase 3 gameplay ...]

Final Debrief:
  > NETWORK MAPPING COMPLETE
  > PAYOUT: 2400 ¤
  > REPUTATION: +6
  > TOTAL SESSION TIME: 45 minutes

---

Mission Templates

Nodespace offers four primary contract templates. The mission board generates variations by seeding with deck state (reputation, cartridge history, LFSR) and procedurally generating topology and opponent personality.

Template 1: TERRITORIAL CONTROL (Base Contract)

Description: “Claim majority territory on a contested network. Opponent personality and topology vary by threat level.”

Threat Range: 1–5
Typical Duration: 20–50 turns
Victory Condition: Control ≥ 50.1% of nodes when turn limit expires

Procedural Generation:

threat_level = 1–5 (from mission board seed)
node_count = 12 + (threat_level × 0.5) = 12–14.5, rounded
topology_type = RANDOM[CLUSTERED, LINEAR, RADIAL] or seeded by cartridge_history
personality_type = RANDOM[AGGRESSIVE, DEFENSIVE, ADAPTIVE, ASYMMETRIC] or gated by reputation
turn_limit = 20 + (threat_level × 6) = 20–50
payout_base = threat_level × 150

Worked Example (Threat 2, DEFENSIVE, Rep 8):

• Network: 14 nodes, CLUSTERED topology
• Opponent: DEFENSIVE personality
• Turn limit: 32
• Base payout: 400 ¤
• Speed bonus: (turns_remaining / 32) × 200 ¤

If operator wins in 25 turns: 400 + (7/32 × 200) = 400 + 44 = 444 ¤
If operator wins in 32 turns: 400 + (0/32 × 200) = 400 ¤
If operator loses: 0 ¤, -2 reputation

Template 2: NODE ENCIRCLEMENT

Description: “Isolate opponent’s starting territory by cutting all edge connections. Force opponent into a shrinking island.”

Threat Range: 2–4
Typical Duration: 30–50 turns
Victory Condition: Opponent’s territory is isolated (0 edges connecting to operator-controlled territory) AND operator controls ≥ 75% of the surrounding nodes

Procedural Generation:

topology_type = CLUSTERED (bridge nodes are the goal)
opponent_start_nodes = Precomputed in north/south clusters (known to operator)
operator_start_nodes = Opposite cluster
target_bridge_nodes = 2–3 critical nodes
turn_limit = 35 + (threat_level × 4)
payout_base = threat_level × 200 (higher risk = higher base reward)

Strategy Notes: Encirclement is pure positioning. Operator must trade node count for isolation. Winning with 5/14 nodes is possible if those 5 encircle opponent’s 4.

Template 3: NETWORK SEVERANCE

Description: “Cut the opponent’s territory into isolated segments. First to create 3 separate opponent clusters wins.”

Threat Range: 2–4
Typical Duration: 25–40 turns
Victory Condition: Opponent territory is split into 3+ disconnected clusters (0 edge connections between clusters)

Procedural Generation:

topology_type = LINEAR or RADIAL (creates natural "cut points")
operator_goal = Control 2–3 critical bridge nodes
turn_limit = 30 + (threat_level × 3)
payout_base = threat_level × 180

Strategy Notes: Severance is about control of chokepoints. Opponent’s total node count doesn’t matter; fragmentation does.

Template 4: SUPREMACY MARATHON

Description: “Extended 50–100 turn campaign. Territory ownership at final turn determines winner. No early victory condition.”

Threat Range: 4–5 (Rep 50+ only)
Typical Duration: 50–100 turns (multi-session)
Victory Condition: Operator controls > 50% nodes at turn 100 OR opponent concedes (AI calculates win probability < 5%)

Procedural Generation:

topology_type = RADIAL (highest complexity, many threat vectors)
personality_type = ASYMMETRIC (mandatory)
turn_limit = 50 + LFSR_RANDOM(0–50) = 50–100
payout_base = 1000 ¤ (highest tier)
victory_bonus = (turns_remaining / turn_limit) × 500 ¤

Design Intent: SUPREMACY MARATHON is a mini-campaign. Designed for play across 3–4 sessions. Each session is 20–30 turns (~40 min). The operator learns the ASYMMETRIC opponent’s strategy arc across sessions. Phase transitions become recognizable. The final turns are high-tension endgame.

---

Screen Wireframes

Screen 1: Contract Board (Bare Deck)

ROW 0: NODESPACE > CONTRACT BOARD [DECK STATE: READY] [REP: 15] [CREDITS: 1200]
ROW 1:
ROW 2: ▸ TERRITORIAL CONTROL — Threat 2                      [1 of 4]
ROW 3:   Network: CLUSTERED, 14 nodes
ROW 4:   Opponent: DEFENSIVE (learning algorithm)
ROW 5:   Duration: 30 turns
ROW 6:   Payout: 400 ¤ | Rep Gain: +2
ROW 7:   ────────────────────────────────────────────────────────────
ROW 8:
ROW 9: ▸ NETWORK MAPPING — Threat 3, Multi-Phase (ICE/NODESPACE/ICE)
ROW 10:   Duration: 45 min total (Phase 2: 30 turns NODESPACE)
ROW 11:   Payout: 2400 ¤ | Rep Gain: +6
ROW 12:   ────────────────────────────────────────────────────────────
ROW 13:
ROW 14: ▸ NODE ENCIRCLEMENT — Threat 2
ROW 15:   Isolate opponent in south cluster
ROW 16:   Duration: 35 turns
ROW 17:   ────────────────────────────────────────────────────────────
ROW 18:
ROW 19: ▸ SUPREMACY MARATHON — Threat 5 (Rep 50+ only)
ROW 20:   100-turn campaign. ASYMMETRIC opponent. Playtime: 3–4 sessions
ROW 21:   Payout: 3500 ¤ + bonuses | Rep Gain: +10
ROW 22:  [CAR=inspect] [CDR=next] [EVAL=accept] [BACK=decline]
ROW 23: NODESPACE │ CONTRACTS: 4 │ REP: 15 │ CREDITS: 1200 │ STATUS: SELECT
ROW 24: NODESPACE │ THREAT: ░░░░░ │ BOARD │ DECK STATE: READY

Screen 2: Briefing (Contract Details)

ROW 0: NODESPACE > TERRITORIAL CONTROL [THREAT 2] [REP: 15] [CREDITS: 1200]
ROW 1:
ROW 2: CONTRACT: ADAPTIVE OPPONENT
ROW 3: Network topology: CLUSTERED (3 clusters + 2 bridges)
ROW 4:
ROW 5: OPPONENT PROFILE
ROW 6:   Personality ......... ADAPTIVE (learns from your moves)
ROW 7:   Strategy ............ Consolidate + Respond to threats
ROW 8:   Difficulty .......... Threat 2 (Intermediate)
ROW 9:   Recent record ....... 7 wins, 3 losses
ROW 10:
ROW 11: NETWORK LAYOUT
ROW 12:   Total nodes ......... 14
ROW 13:   Your start .......... 2 nodes (north cluster)
ROW 14:   Opponent start ...... 2 nodes (south cluster)
ROW 15:   Neutral ............. 10 nodes
ROW 16:   Turn limit .......... 30 turns
ROW 17:
ROW 18: SCORING: Base 400 ¤ | Speed bonus up to 200 ¤ (if <15 turns)
ROW 19:          Rep gain: +2 (win) / -2 (loss)
ROW 20:
ROW 21: "ANOTHER ADAPTIVE MIND. IT WILL EVOLVE AGAINST YOUR STRATEGY."
ROW 22:  [CAR=accept] [BACK=decline]
ROW 23: BRIEFING │ THREAT: 2 │ REP: 15 │ CREDITS: 1200 │ STATUS: READY
ROW 24: NODESPACE │ CONTRACT: TERRITORIAL CONTROL │ NETWORK: 14 NODES

Screen 3: Board State (Main Game View)

ROW 0: NODESPACE > TERRITORIAL CONTROL [TURN 12 / 30] [POOL: 2/3] [OPPONENT: 1/3]
ROW 1:
ROW 2: NORTH CLUSTER      │    CENTER          │    SOUTH CLUSTER
ROW 3: ● ○ ○              │  ◯ ─[B1]─ ◯        │    ○ ○
ROW 4:  \│/               │   │    │           │   /│ROW 5:  [N2]              │  [B0]─[B2]         │  [S2]
ROW 6:  /│\               │   │    │           │   \│/
ROW 7: ● ○ N1             │  ◯ ─ [S0] ─ ◯      │    ○ ● ●
ROW 8:                    │                    │
ROW 9: 6 Operator ●       │  3 Neutral ◯       │  5 Opponent ●
ROW 10: 4 Opponent        │  1 Contested [S0]  │  (reserve pool)
ROW 11: 0 Neutral         │                    │
ROW 12:
ROW 13: BRIDGE STATUS: [B1] Contested | [B0] Operator-controlled | [B2] Neutral
ROW 14:
ROW 15: LAST ACTION: Operator claimed Node 4 (north cluster) — Supply +1
ROW 16: NEXT MOVE: Select node (numpad). CAR=drill. APPLY=action.
ROW 17:
ROW 18: OPPONENT POOL: 1/3 available | OPERATOR POOL: 2/3 available
ROW 19: SUPPLY BALANCE: +3 (Operator advantage)
ROW 20:
ROW 21:
ROW 22:  [8/2/4/6=select] [CAR=drill] [APPLY=action] [INFO=help]
ROW 23: TERRITORIAL │ TURN 12/30 │ 6-OP 5-OPP 3-NEU │ SUPPLY: +3
ROW 24: NODESPACE │ GAMEPLAY │ TURN 12 │ POOL: 2/3 │ OPPONENT: 1/3

Screen 4: Node Detail (Drilled Into Node)

ROW 0: NODESPACE > NODE DETAIL: NODE 7 (CONTESTED) [THREAT: 2] [TURN: 12/30]
ROW 1:
ROW 2: NODE IDENTITY
ROW 3:   ID ................. 7 (South bridge sector)
ROW 4:   Current Owner ...... OPPONENT (but contested)
ROW 5:   Defense Level ...... ■² (Fortified +2)
ROW 6:   Supply Strength .... 2 adjacent friendly nodes
ROW 7:   Action Cost ........ 3 points (to claim from opponent)
ROW 8:
ROW 9: ADJACENT NODES (supply map)
ROW 10:   [5] OPPONENT controlled (friendly to opponent) ● Supply: ★★
ROW 11:   [6] NEUTRAL (available to claim) ◯ Supply: ★
ROW 12:   [8] OPERATOR controlled (your side) ● Supply: ★★★
ROW 13:
ROW 14: VULNERABILITY ANALYSIS
ROW 15:   If claimed: Opponent loses strategic position in south
ROW 16:   If ignored: Opponent may fortify further (+1 def next turn)
ROW 17:   Advantage: Claiming cuts off Node 5 from reinforcement
ROW 18:
ROW 19: RECOMMENDATION: Claim now (3 points) before opponent reinforces
ROW 20: Risk Assessment: LOW (you have 2 points in pool)
ROW 21:
ROW 22:  [CAR=claim] [CDR=observe] [BACK=cancel]
ROW 23: NODE DETAIL │ NODE 7 │ ACTION COST: 3 │ RISK: LOW │ POOL: 2/3
ROW 24: NODESPACE │ DRILL MODE │ NODE 7 CONTESTED │ OPPONENT FORTIFIED

Screen 5: Game Over / Victory State

ROW 0: NODESPACE > TERRITORIAL CONTROL [COMPLETE] [VICTORY] [TURN 18 / 30]
ROW 1:
ROW 2:                          ★ VICTORY ★
ROW 3:
ROW 4:                    Territory Control: ACHIEVED
ROW 5:                    Opponent Nodes Captured: 9 / 10
ROW 6:                    Opponent Remaining: 1 (isolated south)
ROW 7:                    Time to Victory: 18 turns (60% efficiency)
ROW 8:
ROW 9:                          PERFORMANCE ANALYSIS
ROW 10:                    ═════════════════════════════════
ROW 11:                    Strategic Efficiency: 87% (excellent)
ROW 12:                    Supply Management: +5 (surplus)
ROW 13:                    Opponent Adaptation: Countered (5 moves)
ROW 14:                    Bridge Control: Perfect (all 3 bridges)
ROW 15:
ROW 16:                    Base Payout: 400 ¤
ROW 17:                    Speed Bonus: +150 ¤ (finished in <15 turns)
ROW 18:                    Perfect Supply: +50 ¤
ROW 19:                    Total Earned: 600 ¤
ROW 20:                    Reputation Gain: +2
ROW 21:
ROW 22:  [EVAL=accept] [BACK=contract board]
ROW 23: VICTORY │ PAYOUT: 600¤ │ REP: +2 │ SUPPLY: +5 │ EFFICIENCY: 87%
ROW 24: NODESPACE │ VICTORY │ TERRITORIAL CONTROL ACHIEVED

Screen 6: Game Over / Defeat State

ROW 0: NODESPACE > TERRITORIAL CONTROL [FAILED] [DEFEAT] [TURN 28 / 30]
ROW 1:
ROW 2:                          ✗ DEFEAT ✗
ROW 3:
ROW 4:                    Territory Control: LOST
ROW 5:                    Your Nodes Remaining: 3 / 6
ROW 6:                    Opponent Nodes: 11 / 14
ROW 7:                    Time Remaining: 2 turns
ROW 8:
ROW 9:                          FAILURE ANALYSIS
ROW 10:                    ═════════════════════════════════
ROW 11:                    Turn 15: Opponent adapted to your strategy
ROW 12:                    Turn 18: Opponent claimed contested bridge [B1]
ROW 13:                    Turn 22: Your supply lines severed
ROW 14:                    Turn 28: Isolated in north cluster — game over
ROW 15:
ROW 16:                    Lesson: Bridge control is critical.
ROW 17:                    Opponent learned your expansion pattern.
ROW 18:
ROW 19:                    Consolation: 50 ¤ (session refund)
ROW 20:                    Reputation Loss: -2
ROW 21:
ROW 22:  [EVAL=retry] [BACK=contract board]
ROW 23: DEFEAT │ REFUND: 50¤ │ REP: -2 │ OPPONENT STRATEGY: ADAPTIVE
ROW 24: NODESPACE │ DEFEAT │ TRY DIFFERENT STRATEGY

Screen 7: Multi-Phase Contract Intro (Phase 2 Start)

ROW 0: NODESPACE > NETWORK MAPPING [PHASE 2 / 3] [THREAT 3] [30-MIN MISSION]
ROW 1:
ROW 2:                    ★ PHASE 2: NODESPACE ENGAGEMENT ★
ROW 3:
ROW 4:                    You have extracted initial network data in ICE.
ROW 5:                    Now you must infiltrate NODESPACE directly.
ROW 6:
ROW 7:                    PHASE 2 OBJECTIVE:
ROW 8:                    ═════════════════════════════════════════════
ROW 9:                    Claim 60% of network before opponent fortifies.
ROW 10:                    Expected duration: 30 turns
ROW 11:                    Opponent: GUARDIAN (defensive algorithm)
ROW 12:                    Hazards: Firewall intrusions (random events)
ROW 13:
ROW 14:                    RESOURCES PROVIDED:
ROW 15:                    Starting pool: 4 supply points (vs opponent 3)
ROW 16:                    Network: 22 nodes (larger than Phase 1)
ROW 17:                    New mechanic: Firewall zones (cannot enter directly)
ROW 18:
ROW 19:                    ★ After this phase, you return to ICE to finish.
ROW 20:                    The cartridge swap will be simulated in gameplay.
ROW 21:
ROW 22:  [EVAL=begin] [BACK=briefing]
ROW 23: PHASE 2 │ NODESPACE ENGAGEMENT │ DURATION: 30 TURNS │ THREAT: 3
ROW 24: MULTI-PHASE │ CARTRIDGE SWAP │ NETWORK MAPPING CONTRACT

Screen 8: Performance Summary (Session Stats)

ROW 0: NODESPACE > SESSION SUMMARY [OPERATOR: [HANDLE]] [REP: 17]
ROW 1:
ROW 2: RECENT MATCHES:
ROW 3: ───────────────────────────────────────────────────────────────
ROW 4:
ROW 5: Match 1: Territorial Control vs DEFENSIVE     ✓ WIN   (18 turns)
ROW 6:   Payout: 600 ¤ | Rep: +2 | Strategy: Efficient supply chain
ROW 7:
ROW 8: Match 2: Node Encirclement vs AGGRESSIVE      ✗ LOSS  (28 turns)
ROW 9:   Refund: 50 ¤ | Rep: -2 | Error: Bridge control abandoned
ROW 10:
ROW 11: SESSION TOTALS:
ROW 12: ═════════════════════════════════════════════════════════════
ROW 13: Matches Played: 2
ROW 14: Win Rate: 50% (1 victory, 1 defeat)
ROW 15: Turns Spent: 46 total
ROW 16: Net Earnings: 600 ¤ (after refund)
ROW 17: Reputation Change: 0 (±2 cancel out)
ROW 18: Strategy Evolution: Opponent learning curve detected
ROW 19: Next Recommended: Study firewall mechanics before Phase 2
ROW 20:
ROW 21: Best Victory: Territorial Control (87% efficiency)
ROW 22: Worst Loss: Node Encirclement (bridge control loss)
ROW 23:  [EVAL=continue] [BACK=contract board]
ROW 24: SESSION SUMMARY │ MATCHES: 2 │ EARNINGS: 600¤ │ REP: +0

---

CIPHER-LINE Contributions

Nodespace’s voice: strategic analyst briefing a sparse room. Takezo Institute publisher; shares a few vocabulary pools with Takezo but reasons about networks not boards.

Vocabulary Pools

(:subject       "node" "territory" "adversary" "influence"
                "cluster" "bridge" "cut-point" "reach")
(:object        "edge" "hub" "chokepoint" "span" "cluster")
(:location      "quadrant" "cluster" "periphery" "core")
(:verb-present  "holds" "threatens" "bridges" "cuts" "extends"
                "contracts")
(:verb-past-participle "taken" "cut" "sealed" "extended" "contracted")
(:memory-keyword "cluster" "bridge" "cut" "chokepoint" "reach")
(:affect-word   "thin" "wide" "exposed" "solid" "drifting")

Production Fragments

(:mode-observe
  (3 (:subject) ". " (:affect-word) ".")
  (2 "reach " (:synthfence/direction) "."))  ; reuses direction token

(:mode-annotate
  (3 "their cluster. " (:affect-word) ".")
  (1 "bridge cut."))

(:mode-reflect
  (3 "same cluster. " (:memory-fragment))
  (2 "this adversary's shape. " (:memory-fragment)))

(:mode-drift
  (2 "the north quadrant. three campaigns back.")
  (1 "a cluster that kept rebuilding."))

:event-types
  ((:type :territory-captured :affect (:significant))
   (:type :territory-lost     :affect (:tense))
   (:type :bridge-cut         :affect (:significant))
   (:type :adversary-moved    :affect (:routine)))

Mode-Weight Biases

Beat	observe	annotate	reflect	drift	silent
:active-hack	—	+0.05	+0.05	—	+0.05
:phase-transition	—	—	+0.15	+0.05	—
:debrief	—	+0.10	+0.15	—	—

Style Deltas

((:active-hack (:terseness +24 :certainty +24))
 (:debrief     (:terseness +0 :certainty +40 :temporal-blur +16)))

Structurally Important Moments Preserved on CIPHER-LINE

Beat	Intent	CIPHER-LINE fragment(s)
Territory captured	”Cluster secured.”	cluster. ours.
Bridge cut	”Chokepoint severed.”	bridge cut.
Adversary counter-move	”Adversary pressing periphery.”	they moved. east.
Strategic victory	”Campaign won. Territory dominant.”	taken. whole. (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). Nodespace’s turn-based strategic character rewards pre-mission scripting — routing logic, influence predicates, and territory-assessment helpers written in the calm before the campaign. Unlimited per-turn thinking time in Nodespace maps perfectly to the ADR-0016 loadout-style framing of nEmacs + REPL as pre-run authoring.

Scripted Missions?

Yes — routing logic and territory scripting. Rep-12+ operators unlock Custom Doctrine contracts that reward scripted strategic evaluation — predicates that rank moves by influence, graph walks that find chokepoints, territory-classifiers. The cart ships canonical built-in versions of each; the scripted path is how an operator expresses their own Go-player intuition in Lisp form. Scripted missions remain optional on the critical path (ADR-0002); a low-rep operator plays Nodespace entirely with primitives.

Typical scripted-mission shapes:

• (territory-score region) — custom territory evaluation function.
• (chokepoint-find board) — graph analysis returning high-leverage nodes.
• (on-adversary-move (if (encroachment? :east) (reinforce :east))) — reactive handler.
• (influence-heatmap) — derived view surfaced on the main grid during the operator’s turn.

Cart Grammar Fragments

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

(emacs-extend-grammar
  ;; Board and position primitives
  (board)                                       ; current board state
  (board-size)                                  ; NxN dimension
  (node               (coord))                  ; board node at coord
  (neighbors          (coord))
  (owned-by           (coord))                  ; :self :adversary :neutral
  (connected-group    (coord))
  ;; Territory and influence
  (territory-score    (region &key :player))
  (influence-map      (&key :player))
  (liberties          (group))
  (chokepoint-find    (board))
  (encroachment?      (&key :direction))
  ;; Move primitives
  (place              (coord))                  ; commit a stone
  (cut                (bridge))                 ; bridge-cutting move
  (pass)
  (resign)
  (legal-moves)                                 ; all legal placements this turn
  (move-history       (&key :n))
  ;; Event binders
  (on-adversary-move  (&body handler))
  (on-phase-advance   (&body handler))
  ;; Clock / turns
  (turn-count)
  (campaign-phase))                             ; :opening :midgame :endgame

Vocabulary Contribution

Via (emacs-extend-vocabulary ...). Go-player / territory-strategy terms:

(emacs-extend-vocabulary
  "board" "node" "coord" "neighbor" "group" "chain"
  "territory" "influence" "liberty" "eye" "shape"
  "chokepoint" "bridge" "cut" "connect" "extend"
  "opening" "midgame" "endgame" "fuseki" "yose"
  "invasion" "reduction" "framework" "moyo"
  "adversary" "counter" "response" "sente" "gote"
  "east" "west" "north" "south" "corner" "edge" "center"
  "cluster" "captured" "secured" "press" "encroach"
  "doctrine" "campaign" "phase")

prompt-text FFI Usage

No. Nodespace is pure primitive-and-numpad orchestration. Move entry is keypad-based (coordinate addressing on the grid); doctrine names and campaign labels come from the cart’s catalog. The cart declares nothing via prompt-text per ADR-0016 §8’s expectation that most carts don’t need it.

Double-Tap and Long-Press Bindings

Nodespace opts into ADR-0016 §9 to surface strategic-analysis views without turn cost:

Key	:tap	:double-tap	:long-press
INFO	inspect-node — read the board cell	inspect-group — metadata for the whole connected group	influence-overlay — render influence-map over board (hold to view)
CAR	descend-into-group	—	—
EVAL	commit-move	—	commit-with-simulation — preview consequences before commit
QUOTE	flag-move	bookmark-position — add to post-game study list	—
EQ	compare-positions — two selected regions	—	—

Row 24 renders: INFO:CELL INFO²:GROUP INFO…:INFLUENCE EVAL:COMMIT EVAL…:SIMULATE QUOTE:FLAG EQ:COMPARE.

Context-Polymorphic Key Semantics (Cart Gameplay)

Nodespace has two primary contexts: board view (playing the game) and study view (post-game analysis, move-history scrub):

Key	Board view	Study view
INFO	inspect-node	inspect-move-metadata
CAR	descend-into-group	enter-variation
CDR	next-connected-group	next-move
CONS	link-two-groups (analysis)	compare-variations
EVAL	commit-move	re-play-from-here
QUOTE	flag-node	bookmark-move
EQ	compare-regions	compare-branches
BACK	close-overlay / undo-selection	exit-study
Numpad	coordinate entry (row/col)	move-number select

When the operator drops into nEmacs to author a doctrine predicate, dispatch yields to :nemacs-nav per ADR-0016 §3 — standard editor dispatch. Nodespace keeps the board state frozen during authoring and resumes when the operator returns.