ICE BREAKER — Gameplay Specification

Playtest Blueprint, KN-86 Deckline Pack-In Title

Design state: all three tiers are re-anchored on Josh’s premise and his 2026-07-30 answers on session shape and the breaker roster. The retired tempo-sport walkthrough was removed on 2026-07-31; git history holds it. v2.1 | 2026-07-31

World model (2026-07-29): ICE and visibility are specified in aethernet.md. ICE attacks invisibility rather than data, and the operator-facing states are the canon words: invisible, emitting a signature, hunted. Any parallel vocabulary below is a prior draft.

Scope note: This spec supersedes all prior ICE Breaker design in the KN-86-Launch-Titles docs.

CIPHER-LINE revision note (2026-04-24): Every reference in this spec to “Cipher voice” narrating, warning, or commentary now describes output that renders on the CIPHER-LINE OLED above the keyboard, not on the main grid. Main-grid Cipher dialogue is superseded. Where this spec shows a Cipher line as a full sentence (e.g., “CAPABILITY GAP DETECTED — NETWORK DEPTH EXCEEDS CURRENT MODULE.”), read it as the intent of the beat; the actual rendering on CIPHER-LINE is a clipped fragment pair honoring the voice heuristic (gap. network deeper. / not this one.). See the CIPHER-LINE Contributions section in Tier 3 for the authoritative vocabulary, production fragments, and mode-weight biases ICE Breaker declares. Canonical engine specification: docs/software/runtime/cipher-voice.md.

Tier 1 — Treatment

Operator fantasy

The operator enters a chain of hostile systems carrying a small set of programs bought beforehand. ICE watches every system. Getting through means staying unseen, and staying unseen means spending the right program on the right watcher before its sweep lands.

A system, and what ICE does

A system is a handful of zones. Each zone holds a lock, and one ICE unit watches each zone.

Cutting a lock is the work. A lock takes three cuts. Cut every lock in a system and the way to the next one opens.

Every ICE unit sits in one of the three states the world model defines (aethernet.md): invisible, meaning it has registered nothing; emitting a signature, meaning it has picked up activity in its zone without attaching it to anyone; and hunted, meaning it has attached that activity to this session. Every cut pushes the unit watching that zone up the scale.

ICE also acts on its own. Each unit sweeps on a fixed cadence, and a sweep raises the unit if the operator is standing in the zone it watches. The cadence is visible, so the operator sees the next sweep coming and chooses whether to cut before it or wait it out. Cutting is one pressure and standing still is the other, so there is no safe place to pause.

Classes climb at different speeds. JUNK and RED move one step per provocation. A HUNTER climbs faster and pulls neighbouring zones up with it. BLACK jumps to hunted on contact and forces the deck to broadcast its position, which is why recon names BLACK nodes before entry.

Breakers

A breaker is a program bought with credits before the run and carried in a finite loadout. Running one against an ICE unit pushes that unit back down the scale. Each breaker works cleanly against some classes and badly against others, so a cheap breaker that walks JUNK back to invisible makes noise against a HUNTER and lifts the zones around it. A few breakers remove a unit outright, which is the loudest option available.

Breakers are consumed on use. A run that spends everything shallow arrives at the deep systems empty.

Opening the way, and the chain

A system opens when every lock in it is cut, and LINK takes the connection onward. The whole chain runs in one sitting.

Leaving a system quiet, with every unit back to invisible, is optional and is what pays. The operator can walk out of a loud system, and the trace goes with them.

One trace meter covers the entire contract. It rises while any unit is hunted and falls as units come back down, so exposure earned in the first system is still on the meter in the last. The chain tightens as it goes without any new rule.

The decision the operator repeats

Cut again, or spend a breaker first.

Every cut is progress and every cut is noise. The operator can drive straight through a system and leave it screaming, or stop and quiet a unit before the next cut, or move to a quieter zone and come back. Which breaker, on which unit, and before or against the next sweep is the same question asked from the other side.

The answer moves with what is awake, what is left in the loadout, and how much room the trace meter has. Half the decision happens earlier, at the mission board, because a loadout assembled for shallow JUNK work fails on a deep chain.

What the operator sees

Every breaker run changes something on screen in the same frame as the keypress. The target unit’s glyph steps through a density ramp, the trace meter moves, and the sweep counters advance. Awareness reads through glyph density on one amber phosphor, so nothing depends on colour.

Scoring

The cart reports the outcome and the engine prices it (ADR-0055). The ceiling belongs to a run that finished the chain with no unit reaching hunted and no unit destroyed. Loud clears still finish the contract, at a discount. Breakers are consumed either way, so a loud run also leaves less for the next contract.

Time

Pressure comes from sweep cadence, counted in beats the operator watches approach. Reaction speed is out of scope, and the tempo-sport framing in the sections below is retired. The skill is reading the cycle and committing on the right beat.

Boundaries

CONDUIT holds the dial-in, and bzbx maps the chain before entry. DOSSIER keeps what the run learns. Whatever the cleared chain reached is Kommander’s to take. ICE Breaker covers one contest: a finite loadout against the system’s attention.

Implementation seam

Sweeps running on their own cadence need wall-clock heat armed for a live cart mission. The sweep seam (GWP-775) arms it: on contract accept with a live mission world, the policy module system-image/lib/sweep/sweep.lsp calls world_heat_arm and registers one recurring sched beat, through primitives mission_sweep.c binds, and the beat invokes the cart’s (on-sweep-beat). The chain sharing one trace meter needs nothing new, since a mission is one world region and a region carries one meter.

Tier 2 — Operator spec

Gate: draft (written 2026-07-30 against the re-anchored Tier 1; supersedes the tempo-sport operator spec).

Identity

ICE Breaker is the intrusion cartridge. The operator carries a finite loadout of purchased breaker programs into a chain of hostile systems and spends them against stationary ICE to keep every system quiet enough to carry the connection onward. The contest is the loadout against the system’s attention, and nothing else in the cart competes with it.

The system

A system holds 4 to 6 zones. Each zone holds a lock. One ICE unit watches each zone.

The operator moves to a zone and cuts its lock. A lock takes 3 cuts. Every cut raises the unit watching that zone by one state. Cut all the locks in a system and the way to the next system opens.

A chain is 3 to 5 systems, run in one sitting. Clearing a system opens the connection to the next.

Awareness

Each ICE unit holds one of the three canon states from aethernet.md:

State	Meaning	Glyph
Invisible	The unit has registered nothing.	░
Emitting a signature	The unit has picked up activity in its zone and has not attached it to the operator.	▒
Hunted	The unit has attached the activity to this session.	▓

Two rules govern movement between them:

1. One step per crossing. A unit climbs one state at a time and never two. Arriving at hunted always takes at least two provocations, so the alarm is reachable only through decisions the operator watched accumulate.
2. Cuts and sweeps. Every cut raises the unit watching that zone. Separately, each unit sweeps on its own cadence and raises itself if the operator is standing in a zone it watches. Cutting is one pressure; standing still is the other.

The region trace meter sits above the units. It rises while any unit is hunted and falls as units come back down. One meter covers the whole chain, so exposure earned in the first system is still on the meter in the last. The engine owns the meter and the cart moves it through play.

ICE classes

Class	Climbs	Behaviour
JUNK	one step per provocation	The cheap common case. Watches one zone.
RED	one step per provocation	The cheap common case, with a shorter sweep cadence than JUNK.
HUNTER	faster	Sweeps for the session rather than the zone, and pulls neighbouring zones up with it.
BLACK	to hunted on contact	Rare. Strips invisibility outright and forces the deck to broadcast its position. Recon names a BLACK node before entry.

BLACK is the dread object. It stays rare, it is telegraphed, and any on-glass rendering of its attack stays inside photosensitivity safety limits per aethernet.md.

Breakers

A breaker is a program bought with credits at the mission board and consumed on use. Ten types exist. The operator carries six slots, filled in any mix, duplicates allowed.

Breaker	Effect	Tier
GHOST	Demote one unit one step.	cheap
STALL	Push the next sweep back several beats. No state change.	cheap
TAP	Reveal a unit’s threshold, watch set, and next sweep. No noise.	cheap
HUSH	Demote every unit watching one zone one step.	mid
CLOAK	One unit’s sweeps stop finding the operator for several beats. No state change.	mid
SPIKE	Move one unit’s watch to a different zone.	mid
SHIM	One unit cannot climb for several beats.	mid
SCRUB	Demote one unit to invisible.	dear
DECOY	Plant a false signature in a zone; units watching it climb toward the decoy.	dear
CRACK	Remove a unit outright. Always succeeds.	dear

The class grain

Each breaker reads clean, noisy, or wasted against each class. Clean applies the effect at low noise. Noisy applies it and raises every unit covering the zone. Wasted consumes the slot and does nothing.

	JUNK	RED	BLACK	HUNTER
GHOST	clean	clean	wasted	noisy
HUSH	clean	noisy	wasted	noisy
SCRUB	clean	clean	noisy	clean
CLOAK	wasted	clean	wasted	clean
SPIKE	clean	clean	noisy	wasted
DECOY	clean	clean	noisy	clean
STALL	clean	clean	clean	clean
SHIM	clean	clean	wasted	noisy
TAP	clean	clean	clean	clean
CRACK	noisy	noisy	noisy	noisy

Three consequences the operator learns:

• CLOAK answers HUNTER. A HUNTER sweeps for the session, so hiding the session defeats it while demoting it barely helps. A chain carrying HUNTERs demands CLOAK in the bag.
• SPIKE answers JUNK and RED. Redirecting a watch works on a unit that watches a zone. A HUNTER follows the operator, so it has no watch to redirect.
• BLACK resists nearly everything. Only STALL and TAP read clean against it. The play against BLACK is to see it coming and route around it.

A wasted breaker burns. Spending one consumes the slot and produces no state change, which teaches the matrix through a single mistake. The action is never refused.

Clearing and the chain

A system is open when every lock in it is cut. LINK then takes the connection onward.

A system is quiet when every unit on it is invisible. Quiet is optional and it is what scores: the operator can leave a system open and loud, and the trace rides along to the next one.

Three resolutions end a run:

Resolution	Condition
Chain complete	Every lock in the last system is cut.
Withdrawal	The operator leaves from an open system before the chain ends.
Lockout	Every unit on the current system reaches hunted at once.

Scoring

The cart reports and the engine prices (ADR-0055).

Outcome	Condition
:success	Chain complete.
:partial	Withdrawal from a cleared system.
(mission-fail)	Lockout.

Bonuses reuse the names the runtime baselines already carry:

Bonus	Earned when
:no-alert-bonus	No unit reached hunted at any point.
:stealth-bonus	The chain finished with zero CRACK spent.
:no-damage-bonus	No breaker was spent wasted.

The ceiling belongs to a run that never alerted a unit, destroyed nothing, and wasted nothing. Breakers are consumed on every outcome, so a loud run leaves less for the next contract.

Keys

Key	Action
CAR / CDR	Move to another zone.
CONS	Cut the lock in this zone. Three cuts open it. Each cut raises the watching unit.
PAD-1 … PAD-6	Select a loadout slot.
APPLY	Spend the selected breaker on the unit under the cursor.
INFO	Inspect the unit under the cursor: class, state, next sweep.
LINK	Take the connection to the next system, once every lock is cut.
EVAL	Report the outcome and end the run.
BACK	Withdraw from the chain.
TERM	Router-owned; leaves the cart surface.

Selecting with the numpad and committing with APPLY keeps the action bar inside its width budget and matches the numbered-selection idiom the first-party programs already use.

The surface

Composed from named slots in the ASCII design system. Carts draw Rows 1 through 73; Row 0 and Row 74 are firmware-owned.

Region	Holds	Slot
Identity band	System name, position in the chain, trace meter, trace sparkline	frame/hero, data/meter, data/spark
Zone map	One cell group per zone, each carrying its unit’s density glyph and class mark	network map
Unit detail	The cursor unit: class, state, watch set, beats to next sweep	frame/inset, data/kv
Loadout strip	Six slots with type and remaining count, selected slot inverted	data/list
Status echo	The result of the last action	input/field

Awareness reads through glyph density on one amber phosphor, so nothing depends on colour. Animation uses only the sanctioned styles in animation.md; SCANLINE fits a unit sweeping its zone.

What ICE Breaker does not own

• The dial-in. Opening and holding a session is CONDUIT (../../programs/conduit.md).
• Recon. Mapping the chain before entry and reading captures is bzbx (../../programs/bzbx.md).
• The durable record. What survives the run is DOSSIER’s (../../programs/dossier.md).
• Extraction. Carrying out what the cleared chain reached belongs to Kommander (../../programs/kommander.md).
• The trace meter. The engine owns it. The cart moves it by moving units.

Tier 3 — Detailed design

Implementation seam: cell types, field names, FFI signatures, and ADR contracts appear from here down. Tuning numbers (sweep intervals, noise values, breaker prices) belong in the career simulators rather than in this document.

The cell model

A system is a cell tree. The cart registers three types through register-cell-type and dispatches Lisp lambdas per the tagged-union handler contract.

Cell type	Fields	Notes
system	:name :zone-count :chain-index :cleared?	One per system in the chain. The root the operator enters.
zone	:index :cuts-left :occupied? :decoy?	4 to 6 per system. :cuts-left starts at 3 and reaching 0 opens the zone. :occupied? marks where the operator stands.
ice	:class :state :watch :threshold :accum :cadence :next-sweep :shielded-until :cloaked-until	One per zone. :watch is the zone index it covers, which SPIKE rewrites.

:state is 0 invisible, 1 emitting a signature, 2 hunted. :class is one of :junk :red :hunter :black. Fields are read and written through get-cell-field / set-cell-field! (@ / !@).

The awareness step

One pure function, which is what makes the model testable in Lisp with no render harness. It follows the precedent terminal-slow-hunter-tick set: take state, return a verdict, and let the caller commit.

; (ice/step state accum threshold) -> new-state
;   Climbs at most ONE state per call, however far accum exceeds threshold.
;   Returns state unchanged when accum is below threshold.
(defn ice/step (state accum threshold)
  (if (< accum threshold) state
      (if (< state 2) (+ state 1) 2)))

Two callers commit its result: a cut in the watched zone, and the unit’s own sweep. A unit whose :shielded-until is in the future ignores both. A unit whose :cloaked-until is in the future ignores the sweep path and still climbs on provocation.

Breaker resolution

Every breaker resolves through one table keyed by breaker and target class, returning :clean, :noisy, or :wasted. The grain table in Tier 2 is that data. Resolution then applies:

Grade	Effect
:clean	The breaker’s effect lands. No collateral.
:noisy	The effect lands, and every other unit whose :watch covers the same zone takes one provocation.
:wasted	The slot is consumed. No state changes, and the status line says so.

Effects, as field writes:

Breaker	Applies
GHOST	:state minus 1, floored at 0
SCRUB	:state to 0
HUSH	:state minus 1 on every unit whose :watch is the cursor zone
CLOAK	:cloaked-until to now plus N beats
SHIM	:shielded-until to now plus N beats
SPIKE	:watch to a different zone index
DECOY	:decoy? on a zone; units watching it take provocation from the decoy rather than the operator
STALL	:next-sweep pushed back N beats on every unit in the system
TAP	No write. Reveals :threshold, :watch, and :next-sweep in the detail pane
CRACK	The ice cell is destroyed through destroy-cell

Sweeps, and the clock the cart does not have

A cart cannot drive a timer. run-with-timer comes from the mode library that cartridge.c never loads, and nothing in the cart tier reads monotonic time. Sweeps are therefore scheduled by the runtime and observed by the cart, through the GWP-775 sweep seam. Per the language policy (docs/_meta/language-policy.md) the seam splits in two: the decisions (arm condition, cadence, teardown) live in system-image/lib/sweep/sweep.lsp, and mission_sweep.c keeps the mechanisms (bus subscription, the arm/disarm primitives, the cart hook pump):

1. On NOSH_EVENT_MISSION_ACCEPTED with a LIVE mission world, sweep/on-accepted arms wall-clock heat for the region (world_heat_arm, bridged to the ADR-0045 scheduler by world_heat.c) and registers ONE recurring sched_every entry at the same cadence, so the beat and the heat clock advance off the same virtual clock.
2. Each fired beat invokes the cart’s optional (on-sweep-beat) under the GWP-773 hook contract (bound check, callable check, silent when the cart never defined it).
3. (on-sweep-beat) decrements every unit’s :next-sweep, runs the sweep path for units whose counter reached zero, resets :next-sweep from :cadence, and re-renders.

MISSION_COMPLETED and MISSION_ABANDONED disarm the beat; a stale region self-disarms from the callback; a cart unload leaves the beat armed so a mid-mission physical swap resumes beats on the next cart.

Move-driven ticks stay the floor, so a deck that never arms heat still plays: sweeps then advance one beat per operator action through the same cart-side path. That degradation is the honest fallback rather than a broken state. The first arriving runtime beat flips the cart off the move-driven floor.

Learning the contract

Mission accept reaches the cart through two read-only seams (GWP-773):

• The readers (mission-contract-id), (mission-contract-kind), and (mission-contract-threat) return the accepted contract’s id, template kind as a symbol (PENETRATE, EXTRACT, SABOTAGE, SURVEIL), and threat tier. All three return nil outside a contract-backed mission, so (cart-init) polls them without a guard in the accept-then-load order a physical swap produces.
• When the cart is already loaded at accept time, the runtime calls a bound (on-mission-accepted id kind threat). ICE Breaker uses the kind and the threat tier to seed the identity band and the run setup; a cart that never defines the hook loads and runs unchanged.

Trace coupling

The cart never writes the region meter. trace rises while any unit is at state 2 and falls as units come down, and the mission layer owns that arithmetic. The cart reads it back through (world-trace *world*) for the meter and the sparkline, guarding with (world-handle? *world*) and falling back to the launch snapshot.

The loadout

Purchased at the mission board and carried as run-state, six slots:

; each slot: (breaker-symbol . remaining)
(set *ib-loadout* '((ghost . 2) (cloak . 2) (spike . 1) (crack . 1)))

PAD_1 through PAD_6 select a slot index. APPLY resolves the selected breaker against the ice cell under the cursor, decrements the slot, and removes it at zero. Spent breakers do not return; the run ends with whatever remains, and the next contract starts from a fresh purchase.

Key dispatch

A cond over this many keys blows the Fe GC root stack, which caps at 256 and has been blown once by a 14-branch on-key expansion. Dispatch is a static alist built at cart-init and looked up per press.

(set *ib-keys*
  (list (cons 'car   ib/key-prev)     (cons 'cdr   ib/key-next)
        (cons 'cons  ib/key-cut)      (cons 'apply ib/key-spend)
        (cons 'info  ib/key-inspect)  (cons 'link  ib/key-advance)
        (cons 'eval  ib/key-report)   (cons 'back  ib/key-withdraw)
        (cons 'pad-1 ib/key-slot-1)   (cons 'pad-2 ib/key-slot-2)
        (cons 'pad-3 ib/key-slot-3)   (cons 'pad-4 ib/key-slot-4)
        (cons 'pad-5 ib/key-slot-5)   (cons 'pad-6 ib/key-slot-6)))

The key names are the bridge event vocabulary (lisp_event_name_to_slot in nosh_lisp_bridge.c: kebab-case, pad-1 through pad-6), the same names register-cell-type accepts, so the alist doubles as the registration table for the system cell type. TERM stays router-owned and never reaches the cart.

ICE Breaker takes no typed input. Every action is a verb key or a digit, so the cart needs nothing from the text-entry work that landed with ADR-0062. A cart that later wants a string calls prompt-text, the runtime-owned modal already bound in the cart bridge, which echoes on CIPHER-LINE Row 4 and returns a string or nil.

Render

The cart tier embeds ui/ui/draw.lsp only; render/* and the System-tier kit are unbound in a cart context by design. Every element below composes from draw.lsp over the cell-* tier.

Region	Rows	Drawn with
Identity band	1 to 6	draw/box-hb, trace meter and sparkline as half-block runs
Zone map	8 to 40	One group per zone; the unit’s density glyph plus a class mark
Unit detail	42 to 56	draw/box-hb with key and value rows
Loadout strip	58 to 64	Six cells, selected slot inverted
Status echo	66	One line, the last action’s result

Density glyphs go in as codes, never strings. render/text does not decode UTF-8, so the shade ramp is 0xA5 light, 0xA6 medium, 0xA7 dark, written through cell-set. Animation uses SCANLINE for a unit sweeping its zone, per the named library in animation.md.

Outcome reporting

(mission-complete credits rep)   ; EVAL, gated on (mission-contract-id)
(abandon-mission)                ; BACK

The bound surface (GWP-719/720, per ADR-0055): mission-complete prices from the posted contract snapshot, clamping the cart-reported credits at the posted payout, and abandon-mission resolves a withdrawal at the engine-owned rep cost. Both raise :not-in-mission outside an active mission, so the cart gates each call on the (mission-contract-id) reader and a headless run stays safe. The three bonus conditions (:no-alert-bonus no unit ever reached hunted, :stealth-bonus zero CRACK spent, :no-damage-bonus zero wasted spends) ride a plain list in cart state; the richer complete-mission :outcome :bonuses record shape stays future ADR-0055 work.

Tests

Cases live in KEC Lisp under runtime/tests/lisp/, with a thin C runner, per the house rule.

1. ice/step climbs one state per call and never two, however far accumulation exceeds the threshold.
2. A cut lowers :cuts-left by one, and the zone opens at zero.
3. A cut raises the unit watching that zone; a unit watching another zone is untouched.
4. A system reports open exactly when every zone is at zero cuts left.
5. Each grade resolves correctly: clean applies the effect alone, noisy applies it and provokes every unit covering the zone, wasted consumes the slot and changes nothing.
6. CLOAK suppresses the sweep path and leaves the provocation path intact.
7. SHIM suppresses both paths for its duration.
8. SPIKE rewrites :watch, and the unit then accumulates from the new zone.
9. CRACK destroys the unit and provokes the rest of the zone.
10. A system reports quiet exactly when every unit is at state 0.
11. A zero-CRACK, zero-hunted, zero-wasted run yields all three bonuses.

Case 11 asserts the bonus set as a plain list, so it passes before the ADR-0055 surface is bound.

On-glass

tools/record-demo.sh against kn86rec: a system at ▒ ▒ ░, the operator selecting a slot, spending GHOST twice and CLOAK once, the density ramp dropping to ░ ░ ░, the trace meter falling, and the system reporting clear. What the recording proves is that awareness is legible from density alone on one phosphor, and that the meter moves in the same frame as the keypress.

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 (deleted 2026-07-29; recover from git history) §1–§3.

(mission-contributions
  :verbs (PENETRATE OBTAIN DESTROY OBSERVE)
  :affinities (DIGITAL NETWORK))

ICE Breaker is the canonical DIGITAL+NETWORK cart and the launch library’s primary anchor for the four offensive verbs. Network intrusion satisfies PENETRATE; data extraction satisfies OBTAIN; sabotage contracts satisfy DESTROY; surveillance implants satisfy OBSERVE. Default :payout-bias (1.0) and :threat-bias (0); ICE Breaker is the calibration baseline.

Capability Registration

ICE Breaker’s (cart-init) issues the following Mission Control capability declaration (canonical authoring contract: ADR-0028 + ADR-0030):

(register-capabilities
  :module     :ice-breaker
  :bit        0x01
  :provides   '(:network-penetration :network-extraction
                :network-sabotage :network-surveillance)
  :affinities '(:digital :network)
  :seeds      '(network-topology ice-placement encryption-depth)
  :supersedes :terminal                ; per ADR-0030 — supersedes the System-tier baseline
  :threat-cap 6)                       ; cart-tier ceiling (vs TERMINAL's 2)

Relationship to baseline

ICE Breaker supersedes the System-tier :terminal baseline (../../runtime/baselines/terminal.md) per ADR-0030. While inserted, ICE Breaker amplifies the network-intrusion domain, providing the full PENETRATION / EXTRACTION / SABOTAGE / SURVEILLANCE schema set and lifting the threat ceiling from TERMINAL’s training cap of 2 up to the cart’s full operations ceiling of 6. Eject the cart and the deck falls back to TERMINAL’s training-tier penetration verb and capped contract pool. See ../../runtime/mission-control.md §2.3 (the supersedes mechanic) and §3.2.1 (threat-cap inheritance).

CIPHER-LINE Contributions

Per the CIPHER-LINE Grammar Framework, ICE Breaker declares the following cipher-grammar block in its .kn86 container. The nOSh runtime merges these contributions into the active grammar tables at cart-load and removes them at pull. The coherence stack persists across pulls.

Vocabulary Pools

(:subject              "ice" "trace" "node" "packet" "relay" "shell"
                       "handshake" "core" "perimeter" "sentry")
(:object               "firewall" "core" "shell" "perimeter" "handshake"
                       "pipe" "edge" "gate")
(:location             "sector" "node" "subnet" "backbone" "edge"
                       "deep-node" "shallow-node")
(:verb-present         "pings" "hums" "watches" "routes" "slips"
                       "locks" "mirrors" "siphons")
(:verb-past-participle "compromised" "extracted" "burned" "mirrored"
                       "cracked" "slipped" "pinned")
(:memory-keyword       "ice" "trace" "handshake" "shadow" "relay"
                       "hunter" "black ice" "junk" "kraken")
(:affect-word          "loud" "clean" "watched" "silent" "noisy"
                       "cold" "wrong")

Production Fragments (merged into nOSh baseline)

(:mode-observe
  (3 (:subject) ". " (:heading?))
  (2 (:location) " " (:verb-present) ".")
  (2 (:object) ". " (:affect-word) ".")
  (1 "trace up."))

(:mode-annotate
  (3 "that one. " (:affect-word) ".")
  (2 (:ice-breaker/ice-class) " " (:affect-word) ".")
  (1 "too clean.")
  (1 "watched."))

(:mode-reflect
  (3 "same " (:memory-keyword) ". " (:memory-fragment))
  (2 "this node. " (:memory-fragment))
  (1 (:memory-fragment) ". then the trace."))

(:mode-drift
  (2 "the one that pinged back.")
  (2 "last relay. three decks ago.")
  (1 "handshake at dawn.")
  (1 "kraken. sector nine."))

; Cart-scoped non-terminal — only callable by ICE Breaker productions
(:ice-breaker/ice-class
  (3 "black.") (3 "red.") (2 "junk.") (1 "kraken.") (1 "shadow."))

; Event-types registered globally; any cart may emit these once registered
:event-types
  ((:type :ice-crack        :affect (:tense))
   (:type :trace-spike      :affect (:tense :significant))
   (:type :hunter-spawn     :affect (:tense :anomalous))
   (:type :hot-swap-prompt  :affect (:anomalous))
   (:type :egress           :affect (:significant)))

Mode-Weight Biases

Per-beat additive deltas (clamped ±0.20 by the framework):

Beat	observe	annotate	reflect	drift	silent
:active-hack	+0.05	—	—	—	+0.05
:high-tense	—	−0.05	—	—	+0.10
:phase-transition	—	—	+0.05	—	—
:cart-swap-lull	—	—	+0.05	+0.10	—
:debrief	—	+0.05	+0.05	—	—

Rationale. ICE Breaker’s tempo is fast in :active-hack: the voice should observe and stop there. :high-tense tightens silence further so the trace rising without a voice line hits harder. :phase-transition and :cart-swap-lull push reflect/drift to make cross-cartridge memory stick around. :debrief leans into annotate+reflect: the Cipher earns its editorial after the run ends.

Style Deltas

((:active-hack    (:terseness +32 :certainty -16))
 (:high-tense     (:terseness +48 :certainty -32))
 (:cart-swap-lull (:temporal-blur +24))
 (:debrief        (:terseness -16 :certainty +24)))

Fast phases → clipped and uncertain. Debrief → slightly looser, more sure.

Structurally Important Moments Preserved on CIPHER-LINE

These are beats the main-grid spec currently narrates via Cipher lines. On CIPHER-LINE they become fragment pairs rendered across Rows 2–3:

Beat	Intent	CIPHER-LINE fragment(s)
Orient assist, low rep	”This node’s ICE is JUNK-class, slow. You can brute-force it or traverse.”	junk. slow. then brute. or slip. (two ticks, mode observe then annotate)
Orient assist, high rep	(silent, operator on their own)	(silent tick) for 3–5 ticks; operator sees Rows 2–3 freeze
Capability gap warning	”CAPABILITY GAP DETECTED — NETWORK DEPTH EXCEEDS CURRENT MODULE.”	gap. then not this one. (annotate, anomalous-tagged)
HUNTER spawn at trace=30	”PERIMETER ALERT ISSUED”	perimeter. awake. (annotate, tense)
Hot Swap initiation	”INITIATING CAPABILITY SWAP”	swap. then hold. (the nOSh runtime emits; cart-swap-lull)
Successful egress	”NETWORK COMPROMISED. DATA EXTRACTED. NO TRACE.”	clean. then no trace. (annotate + observe; significant)
Compromised egress	”EXTRACTED. BURNED.”	got it. burned. (annotate; tense + significant)

The intent is preserved; the surface and length change. No structurally important beat is dropped: every one still lands, it just lands on the OLED in fragments the operator catches in peripheral vision while they work the main grid.

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). The context-polymorphic dispatch model (§3) means ICE Breaker’s verbs on Row 74 are rendered by firmware from the cart’s own keymap, when the player is in an ICE Breaker run (not inside nEmacs/REPL), the keys mean exactly what ICE Breaker says they mean.

Scripted Missions?

Yes: scan-orchestration and loadout scripting. ICE Breaker is a tempo-driven cart but operators at Journeyman+ reputation may author pre-run scripts at the deck (Lisp snippets in nEmacs) that automate repetitive CONS combinations, pre-stage observational sweeps, or codify a hot-swap handoff routine. These are loadout-style scripts per the pre-run framing of ADR-0016’s narrative: the operator writes logic at the deck, deploys, watches it execute. Scripted missions remain fully optional on the critical path (ADR-0002); a low-rep operator can clear every contract without touching nEmacs. High-rep operators use scripts to raise their personal ceiling.

Typical scripted-mission shapes:

• (orient-sweep): chains observe, scan-class, trace-check primitives on node entry.
• (cons-loadout :mirror :cloak): pre-stages a capability combination so the operator only needs to hit EVAL at the right moment.
• (on-hunter-spawn (egress-if-clean)): reactive handler bound to the :hunter-spawn event.

Cart Grammar Fragments

Contributed via (emacs-extend-grammar ...) at cart-load. These forms become legal in :nemacs-nav scope when ICE Breaker is loaded, filtered into the palette by the ADR-0009 legal-form filter:

(emacs-extend-grammar
  (scan            (node))                      ; returns (:subject ... :class ...)
  (scan-class      (node))                      ; shorthand for (scan) | :class
  (trace-level)                                 ; returns current 0..100
  (cons-pair       (tool-a tool-b))             ; the CONS combination matrix
  (break-ice       (node tool))                 ; commits a crack; fires :ice-crack event
  (egress          (&optional :clean :burned))  ; terminates run
  (hunter-nearby?)                              ; boolean predicate
  (on-hunter-spawn (&body handler))             ; event binder
  (when-trace-above (level &body body))         ; conditional on trace
  (slip-to         (node)))                     ; graph traversal primitive

Vocabulary Contribution

Via (emacs-extend-vocabulary ...). Overlaps the CIPHER-LINE Contributions :memory-keyword pool but serves a different purpose: the CIPHER-LINE version seeds the voice; this one biases T9 prediction so when an operator types ic on the 2-key, ice ranks higher than icy:

(emacs-extend-vocabulary
  "ice" "trace" "handshake" "node" "relay" "sentry"
  "hunter" "perimeter" "junk" "black" "red" "kraken"
  "shadow" "mirror" "cloak" "crack" "slip" "cons"
  "compromise" "egress" "burned" "clean")

prompt-text FFI Usage

No. ICE Breaker has no raw text entry. All interaction is primitive-key orchestration: no handle-entry prompts mid-run, no typed commands. The cart declares nothing via prompt-text and ships without the Nokia multi-tap path.

Double-Tap and Long-Press Bindings

ICE Breaker opts into the ADR-0016 §9 event model on two keys:

Key	:tap	:double-tap	:long-press
INFO	observe: basic telemetry	orient-assist: Cipher narrates (low-rep) / silent (high-rep)	—
CONS	open-combo-matrix	—	show-recent-combos: surface last 3 successful pairings as a quick-pick
CAR	descend: enter node	scan-deep: scan then descend	—

All other ICE Breaker keys bind :tap only: tempo is fast and the operator benefits from deterministic single-press verbs; multi-level bindings are reserved for drill-down affordances where the second press is genuinely different work.

Row 74 action bar renders these per ADR-0016 §9: INFO:OBS INFO²:ORIENT CAR:ENTER CAR²:SCAN+ENTER CONS:COMBO CONS…:RECENT EVAL:COMMIT QUOTE:SWAP.

Context-Polymorphic Key Semantics (Cart Gameplay)

During an active ICE Breaker run (not nEmacs/REPL), keys resolve via the cart’s keymap as declared in its Lisp handlers. Row 74 reflects the current context; Row 0 remains firmware-owned status. Summary of verbs:

Key	Verb in ICE Breaker
INFO	OBSERVE (tap) / ORIENT (double-tap)
CAR	Enter/descend node (tap) / Scan+descend (double-tap)
CDR	Traverse back up
CONS	Open combination matrix (tap) / Recent combos (long-press)
EVAL	Commit action
QUOTE	Initiate Hot Swap
BACK	Return to network map
Digit keys 1–6	Select listed option / node / tool

When the player exits the ICE Breaker run to nEmacs (via SYS → Edit), these semantics hand off to :nemacs-nav scope and cursor-polymorphic dispatch resumes; this is the ADR-0016 §3 boundary, and Row 74 flips to the editor’s action verbs automatically.

Migration notes

Tier-ladder migration pass, 2026-07-18 (GWP-726), per documentation-standard.md:

• Content regrouped under tier headings; section numbers are preserved from v1.0 so existing cross-references keep resolving. They read out of ladder order across tiers by design: the Design Philosophy, the Summary, and the 8-Fallacies design note sit in Tier 1; §1–§11 sit in Tier 2; the Mission Contributions (capability registration), §12 (Appendix A), the CIPHER-LINE Contributions, the nEmacs Contributions, and the Batch 10 list sit in Tier 3.
• The legacy status line (Status: Definitive (Supersedes all prior ICE Breaker design in KN-86-Launch-Titles docs)) retires in favor of the ladder header; the supersession claim survives as the scope note under the header. Gates: T1/T2/T3 approved (the monolith carried content at all three tiers and merged under the legacy status).
• Impl is partial: the shipped icebreaker.lsp is a reduced launch cart implementing a subset of this spec; the real-time tempo engine, Hot Swap, Sysop Mode, and the full CONS combination matrix as specified here are not in the shipped cart.
• Drift corrections (against canonical-spec.md and current ADRs):
  • Rows (ADR-0036, canonical-spec rule 5): every prose “Row 24” action-bar statement corrected to Row 74 (the Row 0 / Rows 1–73 / Row 74 contract); the revision note’s “main 80×25 grid” now reads “main grid”.
  • Keyboard (ADR-0031, ADR-0044): “numpad” prose corrected to the digit pad / digit keys (the right-half T9 3×3; the 34-key Ferris Sweep has no numpad arithmetic column). EVAL’s stale physical description (“the 1.75U-wide confirm bar across the bottom”) corrected to the left inner thumb key (LT0, ADR-0031 §3.1). LAMBDA annotated as the keycap printed FN (ADR-0044 §5). Every key’s gameplay semantics are unchanged.
  • Cartridge interface (ADR-0019): “SPI card slot” corrected to the cartridge slot (full-size SD card via USB mass storage); seam added in §6.
  • Persistence (ADR-0011, ADR-0019): prose “SRAM” phase-chain persistence corrected to Universal Deck State (§5, §6). The DECK STATE SAVED TO SRAM line inside §12’s screen art is left as drawn (see the wireframe flag below).
  • CIPHER (ADR-0015): the 2026-04-24 revision note is kept and wins over the body: full-sentence Cipher lines are beat intent; real rendering is clipped fragments on the CIPHER-LINE OLED. Residual main-grid Cipher narration remains inside §9’s and §12’s screen art (the CIPHER VOICE: lines) and in the running OODA narration; read those as beat intent.
• Design-vs-ADR conflicts kept on the ADR reading and flagged (no redesign):
  • §11 claimed “all other cartridges depend on ICE BREAKER as foundation.” Under the capability model the fallback foundation is the System-tier :terminal baseline (ADR-0030) and no cart depends on another; seam added in §11.
  • §10 Sysop Mode’s physical/transport layer (3.5 mm TRRS link cable, OSC emulator bridging, runtime mode 0x10) has no governing ADR and conflicts with the canonical hardware table (the jack is a switched stereo TRS headphone output; no link port exists). Seam added in §10; linked play owes a transport decision before implementation.
  • §11’s cartridge-history bitfield encoding (16 bits, 4 bits per cart) is design intent pending the Universal Deck State layout (ADR-0011, ADR-0040); seam added.
  • The real-time tempo model (0.5 s OODA windows, per-agent cycle clocks, half-tempo swap windows) predates the event-driven runtime (20 fps animation cap, input-driven redraw). Kept as designed; feasibility of the tempo engine is an implementation question, tracked with the Impl gap above.
• Wireframe canvas: the screen mocks in §9 (boot, mission board, node views) and §12 (the run log) were authored under the retired 80×25 assumptions and owe a re-cut to 128×75 / Rows 1–73 with Row 0/74 firmware-owned (see black-ledger.md §8 for what a re-cut looks like). Left as drawn per the migration rules.
• §3 carried a drafting artifact: a degradation-counter design immediately retracted in the source text (“No. Wait. That’s wrong. Let me recalibrate.”). The retracted paragraphs are trimmed; the operative one-use rule is kept verbatim.
• Prose repairs riding along: em-dash clause connectors replaced with colons/semicolons/commas/parentheses (em dashes kept in headings, tables, screen art, quoted CIPHER lines, and term: definition bullets); “Cartridge learns player” and “The device teaches itself through play” rephrased mechanically; one rhetorical value-question in §6 restated directly. No meaning changed.

Inspirations

Assigned by Josh in the kn86-inspo workbench. Full map: cart-inspiration-map.md.

Source	Category
DEFLECT skeleton (Atari)	arcade
FIREWALL skeleton (Atari)	arcade
Geowar (1979)	artillery
nibbles (Go)	dos authoring
Mission: Mainframe (1987)	hacking sim
System 15000 (1984, ZX Spectrum & C64 / Craig Communications)	hacking sim
Pursuit AI (Atari, shipped as trace)	maze chase
Dunnet (1982; GNU Emacs port 1992)	text adventure
astroterm — terminal planetarium (braille star-density rendering)	visual effect