SYNTHFENCE — Gameplay Specification

Engineering Blueprint — KN-86 Deckline Capability Module 0x07

Version 1.0 | April 2026 | Status: Engineering-Ready

CIPHER-LINE revision note (2026-04-24): SynthFence’s Cipher voice — market observations, arbitrage hints, regulatory warnings — renders on the CIPHER-LINE OLED, not the main 80×25 grid. Kokan Systems’s pure-commerce voice: no philosophy, just the numbers. 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 (OBSERVE DECIDE OBTAIN ANALYZE)
  :affinities (FINANCIAL INFORMATION)
  :payout-bias 1.2)

SynthFence is the launch library’s high-stakes commerce cart and the second FINANCIAL anchor alongside Black Ledger. Reading bid/ask depth and recent ticks satisfies OBSERVE; submitting an order under closing-spread pressure satisfies DECIDE; opening a position satisfies OBTAIN; manipulation-detection contracts satisfy ANALYZE. :payout-bias 1.2 reflects the high-stakes domain (real money moves; margin calls cost reputation). Composes naturally with Black Ledger (FINANCIAL → FINANCIAL within-affinity) for market-manipulation-then-audit chains.

Design Philosophy

SYNTHFENCE is not a trading simulation. It is a market-as-adversary system — one where the operator does not set the pace. Unlike ICE Breaker (tempo-driven by the operator’s decision cycle) or Black Ledger (investigation-paced by evidence gathering), SYNTHFENCE’s clock is external and immutable: the market moves every turn, whether the operator acts or not.

The core loop is OBSERVE-ORIENT-DECIDE-ACT (OODA), but the tempo belongs to the MARKET, not the operator. The operator observes price feeds (bid/ask, order book depth). Orients toward a decision (arbitrage opportunity? volatility peak? manipulation pattern?). Decides on a trade action (buy/sell/hold/hedge). Acts by submitting an order. But while the operator is thinking, the market is moving. If the operator is too slow, the spread closes, the volume evaporates, the regulatory window slams shut.

This teaches a crucial truth about markets: they are not turn-based games where the player controls time. They are continuous systems where hesitation is cost. The operator learns to read market signals faster, make faster decisions, and execute with conviction—or lose money to slippage and poor timing.

SYNTHFENCE respects financial literacy. The operator is not protected by simplified abstractions. Bid/ask spreads exist. Margin requirements lock up capital. Volatility compounds. Market manipulation is real and detectable. Regulatory systems can force position closure. The screen looks like a Bloomberg terminal because the game is a terminal: price tickers, order books, P&L in real time, threat alerts flashing in amber.

Sound is the operator’s primary interface to market state. Visual screens show snapshots; audio shows flow. The PSG plays three voices simultaneously: Voice 1 = market mood (price direction and volatility), Voice 2 = position health (profit vs. loss, expressed as harmonic consonance vs. dissonance), Voice 3 = regulatory threat (when regulators or manipulators activate, Voice 3 turns dissonant). An experienced operator learns to “feel” market rhythm through audio alone—eyes on the status bar, ears on the PSG. This is stealth financial education disguised as a game about sound.

1. THE OODA LOOP: MARKET TEMPO

The atomic unit of SYNTHFENCE gameplay is the market turn — a discrete time step where the market updates all price feeds, all order books, and all pending orders. The operator’s OODA cycle happens within market turns, under time pressure.

The Cycle

OBSERVE (0.5–1 turn): Operator reads the current market state.

Press INFO to scan price feeds (current bid/ask for active commodity).
Press CAR to drill into order book depth (top 5 bids, top 5 asks).
Press CDR to scroll through recent price history (last 10 ticks).
Press QUOTE to bookmark a price level (no cost; purely mental).
Cipher voice: “Tokyo crude at $48.50. Spread is $0.25. Fifteen-contract depth on both sides.”

ORIENT (0.5–2 turns): Operator identifies the opportunity and decides on a trade direction.

Is the spread wide enough to arbitrage? (ARBITRAGE contracts)
Is the price about to peak or valley? (VOLATILITY CAPTURE contracts)
Are there hidden fake orders inflating volume? (MANIPULATION DETECTION contracts)
Operator may press BACK to exit the current market view and review their position (previous trades).
Cipher voice: “Spread is tight. Arbitrage window closing. You need to decide now.”

DECIDE (0.5–1 turn): Operator formulates the trade (order type, price, size, side).

Press EVAL to enter order submission mode.
Numpad (1-0, +, −, .) to enter price and size.
Press CAR to toggle side (BUY ↔ SELL).
Press CONS to hedge (add a SELL to a BUY position or vice versa).
Operator has ~3-4 turns to enter the order before the market moves decisively.

ACT (0.5–1 turn): Operator submits the order. The market receives it, updates state, and returns filled/partial/rejected status.

Press EVAL to confirm and submit.
Market immediately processes the order.
If buy order: credits deducted, position opened.
If sell order and no position: order rejected (no naked shorts allowed in basic contracts).
If margin requirement exceeded: margin call triggered (positions liquidated; credits locked; reputation damage).
Cipher voice: “Buy order submitted. 500 units at $48.60. Order status: PARTIAL FILLED — 300 units at $48.60, 200 units at $48.65. Remaining: 200 on bid stack.”

Repeat: Market advances to next turn. Operator observes new state and cycles again. If orders are pending, they may fill on next turn. If no action is taken, the cycle repeats anyway—the market never waits.

Move Count, Time Budget, and Decision Pressure

Each contract grants:

Time budget: 8–20 game turns (varies by contract type and threat level). Each game turn = ~1-2 real seconds. Operator sees a countdown timer on the status bar.
Move budget: Unlimited actions, but each action takes time within the turn. The constraint is temporal, not action-count. The operator can submit 10 orders, but if it takes 15 turns to think and execute, the contract fails (time expired).
Threat modifier: Threat 1–2 contracts have generous time (18–20 turns per ARBITRAGE). Threat 5+ contracts have extreme time pressure (5–8 turns per FLASH TRADING).

Unlike Black Ledger’s move-limited actions (CAR costs a move, QUOTE costs a move), SYNTHFENCE is time-bound. This forces a different cognitive skill: fast pattern recognition and rapid execution, not careful deliberation.

2. SYSTEM ONE: THE MARKET

The market is the primary environment. It is procedurally generated, seeded by deck state and threat level. It behaves like a real market: prices oscillate, spreads widen and narrow, large orders move prices, and supply/demand imbalances create opportunities.

Market Structure

Commodities: Each market focuses on a single commodity type (energy, metals, agriculture, currency pair). The operator specializes in one commodity per contract.

Price Feeds: Operator sees real-time price ticks every turn. Each tick includes:

Bid price (what buyers will pay)
Ask price (what sellers demand)
Spread (ask − bid, calculated by firmware)
Volume (at bid and ask)
Time of last trade

Example:

TOKYO CRUDE OIL
Bid:   $48.50 (1000 contracts)
Ask:   $48.75 (800 contracts)
Spread: $0.25 (51 basis points)
Last Trade: $48.60 @ 09:45:12 UTC

Order Book: Operator can drill deeper to see order book depth:

ASKS (sellers' orders)      BIDS (buyers' orders)
$48.95 (100)                $48.50 (1000)
$48.90 (250)                $48.49 (500)
$48.85 (500)                $48.45 (750)
$48.80 (1000)               $48.40 (1500)
$48.75 (800)                $48.35 (300)

The operator can see market depth and infer supply/demand pressure. A thick order book at the ask side means sellers are queuing—price may fall soon. Thin order book on the bid side means buyers are scarce—spread may widen.

Price History: Last 10 ticks stored and scrollable:

Turn 1: $48.40 (open)
Turn 2: $48.42 (+0.02)
Turn 3: $48.50 (+0.08, spike)
Turn 4: $48.48 (-0.02)
Turn 5: $48.52 (+0.04)
Turn 6: $48.60 (+0.08)
Turn 7: $48.58 (-0.02)
Turn 8: $48.62 (+0.04)
Turn 9: $48.65 (+0.03)
Turn 10: $48.68 (+0.03, highest)

Operator can identify trends:

Prices rising 0.03–0.08 per turn? Upward momentum. Sell near resistance.
Prices oscillating ±0.02 around a level? Support/resistance. Buy at floor, sell at ceiling.
Price spike followed by crash? Possible manipulation. Gather evidence.

Market Generation: Procedural Baseline & Complications

Baseline Market (Clean Data):

The nOSh runtime generates a procedurally-stable price series using an LFSR seeded by the operator’s deck state and the contract’s threat level. The price oscillates around a mean with controlled volatility:

price_t = price_t-1 + random_walk_step
random_walk_step = lfsr_next() % 3 - 1  // −1, 0, or +1 basis point
volatility_modifier = 1.0 + (threat_level * 0.1)  // Threat 1 = 1.0x, Threat 5 = 1.5x
spread = base_spread × volatility_modifier

For ARBITRAGE contracts (Threat 1–2, clean markets):

Price oscillates 0.02–0.10 per turn, small spreads (0.15–0.25)
Operator can lock in consistent 0.30–0.60 per-barrel profits
Market behaves predictably; operator learns to read it

For VOLATILITY CAPTURE contracts (Threat 2–3, increasing complexity):

Price swings ±2%–±4% per turn; spreads widen during volatility
Operator must predict peaks and valleys
Random news events add momentum shifts

For MANIPULATION DETECTION contracts (Threat 2–4, embedded deception):

Baseline market overlaid with fake orders (spoofing), order cancellations, and wash trades
Operator must detect which moves are real vs. artificial
Success requires identifying the manipulation pattern

For FLASH TRADING contracts (Threat 3–4, extreme speed):

Multiple parallel markets (Tokyo, Singapore, London) all updating each turn
Micro-arbitrage windows (0.01–0.05 spreads) that close in 1–2 turns
Operator must execute a chain of 5–10 trades in sequence
One missed execution = entire chain fails

Margin System & Capital Constraints

When operator submits a BUY order, the nOSh runtime locks up margin (collateral):

margin_required = entry_price × contract_size × margin_rate
margin_rate = 10% (standard) to 50% (extreme leverage)

Example: Buy 1000 barrels of crude at $48.50 with 10% margin:

Margin locked: $48.50 × 1000 × 0.10 = $4,850 ¤ held as collateral
Operator’s credit balance must have $4,850 available
If credit balance < margin required: order rejected (“INSUFFICIENT CREDIT”)
If operator has $5,000 in credits and locks $4,850, only $150 remains for other trades

Margin release happens when the position closes (SELL order executes). If the operator’s position moves against them and credit balance approaches zero, a margin call is triggered:

position_loss = (current_price − entry_price) × contract_size × 100 ¤
margin_available = original_credit_balance − margin_locked − position_loss
if (margin_available < 0) {
    MARGIN_CALL triggered
    all_positions_liquidated()
    reputation -= 5
}

Example: Operator bought 1000 units at $48.50, market falls to $47.00:

Unrealized loss: ($47.00 − $48.50) × 1000 × 100 = $150,000 scale (internal, not actual ¤)
Loss converted to ¤ impact: 1.5% of position = 150 ¤ drained
If operator started with $5,000, margin locked $4,850, loss $150 → credit balance = $0
Margin call triggered. Positions liquidated at market. Operator suffers 5-rep penalty and resets.

Margin mechanics teach the operator: overleveraging is catastrophic. A conservative operator uses 5–10% margin (safe). A greedy operator uses 30–50% margin and explodes on a 1-2% move against them.

Spread Dynamics and Slippage

The operator sets a limit order (price they’re willing to buy/sell at) or a market order (execute immediately at current ask/bid, accepting slippage).

Limit Order (Safe, Slow):

Operator specifies price: “BUY 500 at $48.50”
Order enters the order book at that price level
Order may take 2–5 turns to fill (if price moves to that level)
If price never reaches $48.50, order expires (contract time limit reached)
Benefit: exact price, no surprise slippage
Risk: slow; arbitrage window may close before order fills

Market Order (Fast, Slippery):

Operator specifies no price: “BUY 500 at MARKET”
Order executes immediately at best available ask (e.g., $48.75 instead of $48.50)
Slippage cost: $0.25 × 500 = $125 ¤ lost to price movement
Benefit: instant execution; operator doesn’t lose the arbitrage window
Risk: slippage eats into profit margin

Operator learns to balance speed vs. accuracy. Tight time limit? Use market orders. Loose time limit? Use limit orders and wait.

3. SYSTEM TWO: THE TOOLKIT

The operator’s primary tools are order submission, position tracking, and hedge construction. These map directly to Lisp primitives on the 31-key layout.

Order Types and Submission

BUY Order (Long Position):

Operator presses CAR to drill into the market feed cell.
Presses CONS to construct an order cell.
Numpad: enters price (e.g., 48.50) + size (e.g., 500)
Presses EQ to confirm it’s a BUY order (default is BUY)
Presses EVAL to submit
Market processes; order appears in operator’s position list as “LONG 500 @ $48.50”

SELL Order (Close Long or Open Short - if allowed):

Operator presses CAR to drill into an existing position cell
Presses CONS to construct a SELL order against it
Numpad: enters price (e.g., 49.10) + size (e.g., 500)
Presses EQ to toggle to SELL
Presses EVAL to submit
Market processes; if operator has matching long position, order closes it
If no position, order rejected in most contracts (no naked shorts)

QUOTE (Limit Order Bookmark - No Execution):

Operator reads price feed and sees an attractive price: $48.50
Presses QUOTE to mark that price level as “interesting”
QUOTE stores the price (but does not submit an order)
Operator can press CDR to review all quoted prices
Later, operator can press CONS to convert a quote into an actual order
Use case: operator reading the market, spotting 3 potential entry prices, then deciding which one to execute

CANCEL Order:

Operator presses BACK on a pending order (still on the market, not yet filled)
Order is removed from the market
Margin lock is released
Use case: operator submitted a limit order, then market moved; they cancel and resubmit at new price

HEDGING (CONS for Multi-Leg Positions):

Advanced operator technique. CONS can combine a BUY + SELL pair into a hedge:

Operator has LONG 500 @ $48.50 (bought earlier)
Operator presses CONS to construct a hedge
CONS prompts: “Add offsetting SELL?”
Operator enters: SELL 500 @ $49.00
Result: operator now has LONG 500 @ $48.50 + SELL 500 @ $49.00 (delta-neutral if both fill)
Benefit: locks in maximum loss ($0.00 if both fill at specified prices)
Benefit: caps maximum gain ($0.50 per unit = $250 ¤)
Risk: if market gaps (no trades at $49.00), SELL order doesn’t fill, operator ends with unhedged LONG

Hedges are powerful for VOLATILITY CAPTURE (operator buys at low, sells at high, and brackets with hedges to limit downside).

Portfolio View and Position Tracking

Operator presses BACK to exit the market feed and enter the portfolio view:

PORTFOLIO — OPERATOR: epsilon | CREDITS: $4,200 | MARGIN USED: $2,425

ACTIVE POSITIONS:
  1. LONG 500 CRUDE @ $48.50 (Entry)
     Current Price: $48.65
     Unrealized P&L: +$75 ¤
     Margin Lock: $2,425 ¤
     Status: OPEN

  2. [PENDING] SELL 500 CRUDE @ $49.00
     Status: WAITING FOR PRICE TO HIT $49.00
     Filled: 0 / 500
     Expires: 8 turns remaining

CLOSED POSITIONS (This Contract):
  1. SOLD 200 GOLD @ $1,950 for +$100 ¤ profit
  2. BOUGHT 300 GOLD @ $1,940 for -$150 ¤ loss

CONTRACT SUMMARY:
  Time Remaining: 8 / 15 turns
  Gross Profit: $25 ¤ (if all pending orders fill)
  Rep Bonus: +1 (if completed on time)

Operator can press CAR on each position to drill into details, press CDR to scroll, press QUOTE to bookmark a position for tracking.

This view answers: “Where am I? How much have I made/lost? How much margin do I have left? Do my pending orders look good?”

EVAL for Trade Execution

When operator has constructed an order (using CONS for structure, numpad for price/size, EQ for side), they press EVAL to submit it to the market.

EVAL triggers:

The nOSh runtime validates the order (price in reasonable range? size > 0? credit/margin available?)
Market receives order, processes it instantly (or queues if limit order)
Order fills partially or fully or not at all
Operator sees result: “BUY 500 @ $48.50: FILLED 300 @ $48.50, PARTIAL 200 @ $48.65”
Position is updated; margin is locked; Cipher voice plays a confirmation tone (harmonic chord if profitable, flat tone if breaking even)

4. SYSTEM THREE: THE THREAT

Threat in SYNTHFENCE manifests as market volatility, regulatory pressure, competitor action, and margin calls. Threat levels 1–6 escalate the complexity and hostility of the environment.

Threat Levels and Market Behavior

Threat	Description	Volatility	Spreads	Manipulation	Regulatory	Margin
1	Clean market	±0.02–0.10	0.15–0.25	None	Passive	5–10%
2	Normal trading	±0.10–0.30	0.25–0.50	Occasional spoofing	Casual monitoring	10–15%
3	Active market	±0.30–0.80	0.50–1.00	Regular manipulation	Active investigation	15–20%
4	Volatile	±0.80–2.00	1.00–2.00	Aggressive patterns	Aggressive enforcement	20–30%
5	Extreme	±2.00–5.00	2.00–3.00	Multiple schemes	Punitive	30–50%

Threat 1–2 (Apprentice Operator): Market is clean. Spreads are wide and stable. Operator learns basic arbitrage without manipulation tricks. Regulatory system is passive (no alerts).

Threat 3 (Novice Operator): Market shows signs of manipulation. Occasional spoofing (fake buy orders that cancel). Spreads widen during volatility. Regulatory system monitors for suspicious patterns but hasn’t been triggered yet.

Threat 4 (Competent Operator): Competitive market. Multiple manipulators active. Layering patterns (fake orders stacking up on one side). Flash trading competitors execute rapid-fire trades. Regulatory system is active and aggressive. Margin requirements tighten. Slippage increases.

Threat 5 (Expert Operator, Rep 25+): Extreme conditions. Multiple adversarial schemes in parallel. Flash crashes. Regulatory interventions mid-contract (circuit breakers halt trading). Margin calls are common. Operator must dodge regulatory traps while still profiting. Exclusive high-payout contracts available (FLASH TRADING, MARKET CRASH SCENARIO).

Regulatory Alerts and Circuit Breakers

Level 1: Watchlist Alert (Threat 2+)

Regulatory system flags the operator’s trading pattern as unusual
Cipher voice: “Trading volume above normal. Regulatory attention increasing.”
Effect: Spreads widen by +0.05 (bid-ask increases) for next 2–3 turns
Reputation impact: None (just a warning)

Level 2: Position Limit Warning (Threat 3+)

Operator’s position size exceeds exchange risk limits
Operator cannot add more contracts to this position
Cipher voice: “Position limit reached. No additional contracts allowed.”
Operator must close current position before opening new one

Level 3: Margin Call (Threat 2+, depends on position loss)

Operator’s unrealized loss exceeds available margin
Firmware liquidates all positions at market price (instant sale)
Operator loses the difference; credits deducted
Reputation damage: -5 rep
Cipher voice: “Margin call triggered. All positions liquidated.”
Contract fails (cannot continue after margin call)

Level 4: Trading Halt (Threat 4+, random at Threat 5)

Regulatory circuit breaker activates; market pauses for 2 turns
Operator cannot submit orders during halt
Can only observe prices
Effect: volatile markets correct slightly during halts; operator can re-enter after
Cipher voice: “Circuit breaker activated. Market halted.”

Level 5: Account Suspension (Threat 5, if operator manipulates)

If operator is caught engaging in market manipulation (spoofing, layering detected by regulators)
Account is suspended for 3 turns
No trading allowed
Contract fails
Reputation damage: -20 rep
Cipher voice: “Your account has been suspended pending investigation.”

Competitor Action and Flash Crashes

At Threat 4+, other traders are active. They submit orders that affect prices:

Normal Competitor Trading (Threat 3+):

Other traders buy/sell, creating price movement
Operator sees order flow as price ticks
Operator can read competitor behavior in the order book

Flash Trading Competitors (Threat 4+):

Competitors execute rapid-fire trades, trying to scalp the same spreads
If operator is slow, competitor fills the best bids/asks first
Order book fills quickly; operator’s limit orders may not fill
Operator must use market orders (accept slippage) to beat competitors

Market Manipulation (Threat 2–5):

Adversarial traders engage in spoofing, layering, wash trades, front-running
Operator can detect these patterns (MANIPULATION DETECTION contracts)
If operator reports manipulation correctly, receives bonus payout
If operator does NOT detect manipulation, they may trade into the trap (buy before spoofing order cancels, causing loss)

Flash Crash (Threat 5, random at 10% chance per turn):

Market suddenly crashes 5–15% in a single turn
All positions suffer massive loss simultaneously
Margin calls triggered en masse
Operator can profit if they predicted the crash and went SHORT (negative position)
Operator can also protect themselves with HEDGE (offsetting sell)
Cipher voice (distorted, chaotic): “FLASH CRASH IN PROGRESS. CIRCUIT BREAKER ACTIVATED.”

Manipulation Patterns (Learning System)

Spoofing (Threat 2+):

Large buy order appears → market price spikes → order cancels → price crashes
Operator can detect by:
- ORDER BOOK CELL shows huge order on bid side
- Next turn, price has spiked
- Next turn, that order has vanished
- Price crashes back down
Evidence: 3–4 data points form a pattern
Operator flags as spoofing; receives MANIPULATION_DETECTED bonus

Layering (Threat 3+):

Multiple smaller orders stacked on one side of the order book
Creates illusion of demand; actually same trader repeatedly canceling
Operator can detect by:
- ORDER BOOK shows 5 identical $0.01-apart orders on bid side (fake demand)
- CELL_HISTORY tracks when those orders entered and left
- Pattern: orders appear simultaneously, disappear together
Evidence: 5+ data points
Operator flags as layering; higher rep bonus than spoofing (more sophisticated)

Front-Running (Threat 4+):

Competitor knows operator’s order is about to execute
Competitor enters trade first, benefiting from operator’s upcoming order
Operator’s order then executes at worse price
Operator can detect by:
- Prices move against operator 1 turn BEFORE operator places order
- Competitor’s order appears first in order book
- Operator’s order gets filled at worse price
Evidence: timing sequence
Harder to prove than spoofing; requires 6+ data points

5. SYSTEM FOUR: SOUND DESIGN

In SYNTHFENCE, sound is the operator’s primary interface to market state. The visual display shows snapshots; the audio shows flow. The YM2149 PSG generates three simultaneous voices, each representing a different market dimension.

Voice 1: Market Mood (Price Direction and Volatility)

Frequency = Normalized Price

Voice 1 plays a square wave. The frequency encodes the current bid price:

Current price: $48.50/barrel
Normalized to audible range: 48.50 × 10 = 485 Hz (mid-range tone)
Operator hears: steady 485 Hz tone

Price moves to $49.10:
Normalized: 491 Hz (slightly higher pitch)
Operator hears: pitch rises (ascending tone)

Price moves to $47.90:
Normalized: 479 Hz (slightly lower pitch)
Operator hears: pitch falls (descending tone)

Volatility Modulates Frequency Jitter:

On calm markets, Voice 1 is pure and stable (no frequency variation). On volatile markets, Voice 1 “wobbles” (frequency dithers ±5 Hz around the base pitch). Operator learns:

Steady tone = calm market, safe arbitrage
Wobbly tone = volatile market, volatility capture opportunity
Rapidly rising tone = strong upward momentum, sell soon
Rapidly falling tone = strong downward momentum, buy soon

Volume Encodes Bid-Ask Spread:

Voice 1 volume is loud (100% amplitude) when spread is tight (<$0.25). As spread widens, Voice 1 volume decreases (50% at $0.50 spread, 25% at $1.00 spread). Operator learns:

Loud Voice 1 = tight market, easy to trade, no slippage
Quiet Voice 1 = wide market, risky, high slippage

Voice 2: Order Activity (Volume and Execution)

Frequency = Order Book Depth × 1000 Hz

Voice 2 is a sawtooth wave that “pulses” with every order submission or fill:

Order book has 100 total contracts (bid + ask): 100 Hz baseline
Order book has 5,000 contracts: 5,000 Hz (maximum, clipped at ~4kHz hardware limit)

Voice 2 is silent (0 Hz) when no trading activity. It jumps to a frequency whenever a new order enters the market (either from operator or competitor). The frequency indicates the size of the order:

Small 100-unit order: low frequency (1 kHz), short pulse (100ms)
Large 1,000-unit order: high frequency (4 kHz), longer pulse (200ms)

Operator learns to “feel” market activity:

Silence = no one trading, market is dead
Slow pulses = light activity, few trades
Rapid pulses = active market, many trades coming in
Continuous high frequency = flash trading mode, hundreds of orders/minute

Order Fill Announcement:

When an order fills, Voice 2 jumps to the fill price (analogous to Voice 1’s price mapping) and plays a loud 200ms pulse. Operator hears: “THUMP” (small fill), “THUMP-THUMP” (large fill), or “THUMP-THUMP-THUMP” (huge fill split across multiple price levels).

Voice 3: Regulatory and Threat (Dissonance and Danger)

Frequency = Threat Level × 333 Hz

Voice 3 is a noise channel (using the PSG’s noise generator) that becomes active only when danger is present: manipulation detected, regulatory alert, margin call, circuit breaker.

When Voice 3 is silent (no threat): operator is safe. When Voice 3 activates:

Regulatory Watchlist Alert (Level 1):
  Voice 3 plays a low-amplitude dissonant tone (beating between 333 Hz and 400 Hz)
  Duration: 500ms, repeats every 2 seconds
  Operator learns: "I'm being watched. Be careful."

Position Limit Warning (Level 2):
  Voice 3 plays a higher-amplitude dissonant tone (500 Hz noise burst)
  Duration: 1 second, repeats every 1 second
  Operator learns: "I'm hitting position limits. Close some contracts."

Margin Call (Level 3):
  Voice 3 plays a loud, harsh noise + falling pitch (Voice 1 descends C → G → E)
  Duration: 2 seconds, sustains until operator acts
  Operator learns: "I'm in immediate danger. Liquidate now."

Circuit Breaker / Market Halt (Level 4):
  Voice 3 plays an ascending chirp (frequency sweeps 300 Hz → 1 kHz)
  Duration: 3 seconds, indicates market is paused
  Operator learns: "Market is halted. Wait."

Account Suspension (Level 5):
  Voice 3 plays a sustained harsh buzz (all noise channels active)
  Duration: 5 seconds, continuous alarm
  Operator learns: "I'm banned. Contract failed."

Key Audio Events and Their Signatures

SPREAD IDENTIFIED: All three voices converge to the same frequency (major third interval; 48.50 bid and 48.75 ask play as C and E note). 200ms duration. Operator hears: a harmonic chord. Metaphor: “Profit opportunity locked.”

ARBITRAGE WINDOW CLOSING: Voices 1 and 3 play a tritone (dissonant interval; danger). 300ms duration, repeats 3 times. Operator learns: “Spread is closing. Decide now.”

ORDER SUBMISSION: Voice 2 jumps to order-size frequency, plays 100ms pulse. Voices 1 and 3 momentarily sync (harmonic confirmation if profitable, dissonant if risky). Operator hears: “Order sent.”

ORDER FILL: Voice 2 and Voice 1 converge (price moves into order execution range). 200ms chord. Operator hears: “FILLED.”

HEDGE CONSTRUCTED: Voice 1 plays major triad (C-E-G, three notes over 500ms). Voices 2 and 3 add a bass line. Operator hears: a rich harmonic sound. Metaphor: “Risk is locked. I’m safe.”

VOLATILITY PEAK: Voice 1 reaches maximum frequency (price at contract target). All voices spike synchronously (200ms). Operator hears: “PEAK! Act now!”

PROFIT LOCKED: Rising major arpeggio (C → E → G → C’, over 1 second). All voices harmonize. Operator hears: triumphant chord. Metaphor: “Money in the bank.”

MANIPULATION DETECTED: Voice 3 plays dissonant tritone + Voice 1 plays backward (descending). 500ms. Operator hears: unsettling sound. Metaphor: “Something is wrong with this market.”

REGULATORY APPROVAL (Manipulation Report Filed): Slow, confident bass note (C2, 65 Hz, from Voice 1’s low range). 2-second sustain. Operator hears: “Justice.”

Domain Vocabulary (CIPHER_DOMAIN)

CIPHER voice uses these terms contextually:

Market Structure: arbitrage, spread, bid, ask, spot_price, futures, order_book, depth, tick Price Action: bid-up, ask-down, momentum, resistance, support, breakout, reversal, volatility Trading: long_position, short_position, margin_call, leverage, hedge, delta_neutral, gamma_risk, slippage Risk: volatility_index, threat_level, regulatory_alert, circuit_breaker, margin_requirement Manipulation: spoofing, layering, front_running, wash_trade, pump_and_dump, flash_crash Economics: profit, loss, payout, reputation, credit_balance, margin_lock, margin_release Exchanges: Hong_Kong_Exchange, Tokyo_Stock_Exchange, Singapore_Exchange, London_Metals_Exchange Commodities: crude_oil, natural_gas, copper, gold, tungsten, wheat, soybeans, currency_pair (EUR_USD, GBP_JPY)

6. CELL ARCHITECTURE

SYNTHFENCE defines five primary cell types, each representing a market object. Cells compose into a nested S-expression representing the operator’s current trading session.

Market Cell

CELL_TYPE market_feed {
    ON_CAR: {
        /* Drill into current price and order book */
        display_price_feed_detail();
        navigate_to_order_book_cell();
    }
    ON_CDR: {
        /* Scroll to next available market */
        switch_to_next_commodity_market();
    }
    ON_EVAL: {
        /* Enter order submission mode */
        enter_order_construction();
    }
    ON_INFO: {
        /* Display price history chart (last 10 ticks) */
        display_price_history_table();
    }
    ON_QUOTE: {
        /* Bookmark this price level */
        create_price_alert_at_current_price();
    }
    ON_CONS: {
        /* Create a new order cell based on current price */
        new_order = create_order_at_price(current_price);
        push_to_nav_stack(new_order);
    }

    STATE: {
        commodity_type: uint8_t;      // ENERGY, METALS, AGRICULTURE, CURRENCY
        current_bid: uint32_t;        // Price in basis points (e.g., 4850 = $48.50)
        current_ask: uint32_t;
        bid_volume: uint16_t;         // Contracts available at bid
        ask_volume: uint16_t;
        timestamp: uint32_t;          // Last update time
        volatility_index: uint16_t;   // 0-100, current market jitter
        trend: int8_t;                // -1 (falling), 0 (neutral), +1 (rising)
        price_history[10]: uint32_t;  // Last 10 ticks
    }
};

ON_DISPLAY {
    /* Render the market feed on amber screen */
    /* Row 0: Header "MARKET: CRUDE OIL | Tokyo Exchange" */
    /* Row 2: "BID: $48.50 (1000) | ASK: $48.75 (800) | SPREAD: $0.25" */
    /* Row 4: "VOL: 2.3% | TREND: ↑ (rising)" */
    /* Row 6: Price chart (spark line showing history) */
}

Order Book Cell

CELL_TYPE order_book {
    ON_CAR: {
        /* Drill into top bid (deepest stack) */
        navigate_to_top_bid_level();
    }
    ON_CDR: {
        /* Scroll down the ask side (deeper into the book) */
        scroll_down_ask_stack();
    }
    ON_EVAL: {
        /* Create a limit order at the current price level */
        highlighted_level = current_selected_level();
        new_order = create_limit_order_at_price(highlighted_level);
        push_to_nav_stack(new_order);
    }
    ON_INFO: {
        /* Show order imbalance ratio (bid volume : ask volume) */
        display_imbalance_analysis();
    }
    ON_QUOTE: {
        /* Bookmark this price level for later */
        add_to_quote_slots(current_price_level);
    }

    STATE: {
        commodity_type: uint8_t;
        bids[5]: {                     // Top 5 bid levels
            price: uint32_t;
            volume: uint16_t;
            visible: bool;
        }
        asks[5]: {                     // Top 5 ask levels
            price: uint32_t;
            volume: uint16_t;
            visible: bool;
        }
        total_bid_volume: uint32_t;
        total_ask_volume: uint32_t;
        imbalance_ratio: float;        // bid_volume / ask_volume
    }
};

ON_DISPLAY {
    /* Render order book (two columns: asks on left, bids on right) */
    /* ASKS side shows: price and volume, stacked bottom-up (highest on top) */
    /* BIDS side shows: price and volume, stacked top-down (highest on top) */
    /* Highlighted row shows cursor position for CAR/CDR navigation */
}

Position Cell

CELL_TYPE position {
    ON_CAR: {
        /* Drill into details: entry price, current P&L, time in trade */
        display_position_detail();
    }
    ON_CDR: {
        /* Navigate to next position (if multiple open) */
        navigate_to_next_position();
    }
    ON_EVAL: {
        /* Close this position (submit SELL at market price) */
        close_position_at_market();
    }
    ON_BACK: {
        /* Exit position view, return to portfolio */
        return_to_portfolio_view();
    }
    ON_INFO: {
        /* Show historical close price and reason (profit target? margin call?) */
        display_position_history();
    }
    ON_CONS: {
        /* Create a hedge (offsetting sell order) */
        hedge_order = create_offsetting_order(self);
        push_to_nav_stack(hedge_order);
    }

    STATE: {
        side: uint8_t;                 // LONG or SHORT
        entry_price: uint32_t;         // Price at which position opened
        entry_size: uint16_t;          // Contracts
        current_price: uint32_t;       // Current market price
        current_size: uint16_t;        // Still open (may be partial)
        entry_time: uint32_t;          // Timestamp
        unrealized_pnl: int32_t;       // Current profit/loss in ¤
        margin_locked: uint32_t;       // Collateral tied up
        is_hedged: bool;               // Does this position have an offsetting order?
        hedge_price: uint32_t;         // If hedged, the offset price
    }
};

ON_DISPLAY {
    /* Render position summary and P&L */
    /* Row 0: "LONG 500 CRUDE @ $48.50 | Current: $48.65 | P&L: +$75 ¤" */
    /* Row 1: "Margin Lock: $2,425 ¤ | Time: 12 turns" */
}

Trade Cell (Execution Result)

CELL_TYPE trade {
    ON_CAR: {
        /* Drill into trade details (fill breakdown, slippage) */
        display_trade_detail();
    }
    ON_CDR: {
        /* Navigate to previous/next trade in history */
        navigate_trade_history();
    }
    ON_EVAL: {
        /* Close this trade if still pending; finalize if complete */
        finalize_trade(self);
    }
    ON_INFO: {
        /* Show analysis: was this a good trade? efficiency metric */
        display_trade_analysis();
    }

    STATE: {
        type: uint8_t;                 // BUY or SELL
        commodity: uint8_t;
        submitted_price: uint32_t;     // What operator requested
        filled_price: uint32_t;        // What market gave them (may differ)
        size: uint16_t;
        filled_size: uint16_t;         // May be partial
        status: uint8_t;               // PENDING, PARTIAL, FILLED, REJECTED, CANCELLED
        timestamp_submitted: uint32_t;
        timestamp_filled: uint32_t;
        slippage: int32_t;             // Filled_price - submitted_price (negative = bad)
        profit_contribution: int32_t;  // ¤ gained/lost from this trade
    }
};

ON_DISPLAY {
    /* Render trade confirmation */
    /* Row 0: "[FILLED] BUY 500 CRUDE @ $48.50" */
    /* Row 1: "Filled: 300 @ $48.50 | 200 @ $48.65 | Slippage: +$0.15" */
}

Portfolio Cell (Aggregated View)

CELL_TYPE portfolio {
    ON_CAR: {
        /* Drill into first open position */
        if (open_positions > 0) navigate_to_position(0);
    }
    ON_CDR: {
        /* Scroll to closed trades history */
        navigate_to_trade_history();
    }
    ON_EVAL: {
        /* Return to market feed (re-engage with trading) */
        return_to_market_feed();
    }
    ON_INFO: {
        /* Show portfolio statistics: average entry price, win rate, etc. */
        display_portfolio_stats();
    }
    ON_QUOTE: {
        /* Bookmark current portfolio state (for later comparison) */
        save_portfolio_snapshot();
    }

    STATE: {
        total_credits: uint32_t;
        margin_used: uint32_t;
        margin_available: uint32_t;
        open_positions_count: uint16_t;
        closed_trades_count: uint16_t;
        net_pnl: int32_t;              // Total profit/loss in contract so far
        positions[8]: {                 // Max 8 open positions per contract
            side: uint8_t;
            commodity: uint8_t;
            entry_price: uint32_t;
            size: uint16_t;
            unrealized_pnl: int32_t;
        }
        trades_history[32]: {          // Last 32 closed trades
            type: uint8_t;
            commodity: uint8_t;
            entry_price: uint32_t;
            exit_price: uint32_t;
            profit: int32_t;
        }
    }
};

ON_DISPLAY {
    /* Render portfolio dashboard */
    /* Row 0: "PORTFOLIO | Credits: $4,200 | Margin Used: $2,425 | Available: $1,775" */
    /* Row 2: "OPEN POSITIONS (2):" */
    /* Row 3:   "LONG 500 CRUDE @ $48.50 | P&L: +$75 ¤" */
    /* Row 4:   "[PENDING] SELL 500 CRUDE @ $49.00 | Waiting to fill" */
    /* Row 6: "CONTRACT P&L: +$75 ¤ | Net: TBD (pending orders)" */
}

Composition Example: Simple Arbitrage

(SYNTHFENCE_SESSION
  (DECK_STATE
    (OPERATOR "epsilon")
    (CREDITS 5200)
    (REPUTATION 8))

  (MARKET_OPERATION "ARBITRAGE: TOKYO-MUMBAI CRUDE"
    (STATUS IN_PROGRESS)
    (TIME_REMAINING 8 turns)
    (THREAT_LEVEL 1)

    (MARKET_FEED "Tokyo"
      (COMMODITY CRUDE_OIL)
      (BID 4850)     ;; $48.50
      (ASK 4875)     ;; $48.75
      (BID_VOLUME 1000)
      (ASK_VOLUME 800)
      (VOLATILITY_INDEX 15))

    (MARKET_FEED "Mumbai"
      (COMMODITY CRUDE_OIL)
      (BID 4895)     ;; $48.95
      (ASK 4910)     ;; $49.10
      (BID_VOLUME 500)
      (ASK_VOLUME 750)
      (VOLATILITY_INDEX 18))

    (ORDER_CONSTRUCTION
      (BUY 500 4850)    ;; Operator queued: BUY 500 @ $48.50 Tokyo
      (SELL 500 4895))  ;; Operator queued: SELL 500 @ $48.95 Mumbai

    (POSITIONS
      (POSITION 0
        (SIDE LONG)
        (ENTRY_PRICE 4850)
        (ENTRY_SIZE 500)
        (ENTRY_TIME TURN_3)
        (CURRENT_SIZE 500)
        (CURRENT_PRICE 4860)
        (UNREALIZED_PNL 50)))    ;; $0.10 move × 500 × 100 = $50 ¤ profit

    (PENDING_ORDERS
      (ORDER 0
        (TYPE SELL)
        (COMMODITY CRUDE_OIL)
        (PRICE 4895)
        (SIZE 500)
        (STATUS WAITING)
        (EXPIRES_IN 5 turns)))

    (CONTRACT_SUMMARY
      (GROSS_PROFIT 50)        ;; If sell at $48.95
      (TIME_BONUS 0)           ;; (Pending)
      (NET_IF_COMPLETE 75)     ;; $0.45 spread × 500 × 100 = 225 ¤ gross, minus $150 margin lock
      (REPUTATION_GAIN 1))))

7. KEY MAPPING TABLES

The 31-key layout is shared across all KN-86 cartridges. SYNTHFENCE uses a consistent mapping per cell type.

Left Hand (Function Grid) — Universal Semantics

Key	Function	In Market Feed	In Order Book	In Position	In Portfolio
QUOTE	Bookmark/Defer	Mark price level for alert	Mark price for order	Bookmark this position	Snapshot portfolio
CONS	Construct/Combine	Create order from price	Create limit order at level	Create hedge	—
NIL	Null/Void	Clear current market selection	Clear selection	Clear position	—
LAMBDA	Function/Macro	Record trade sequence as macro	—	—	—
INFO	Inspect/Detail	Show price history	Show imbalance analysis	Show position detail	Show stats
CAR	First/Drill	Drill into order book	Drill into top bid level	Drill into details	Drill into first position
APPLY	Use/Execute	Execute last macro (if recorded)	—	—	—
SYS	System/Menu	Open SYS menu (settings)	Open SYS menu	Open SYS menu	Open SYS menu
LINK	Link/Connect	[Not used in solo]	[Not used]	[Not used]	Send portfolio snapshot
BACK	Up/Return	Return to portfolio	Return to market feed	Return to portfolio	—
CDR	Rest/Next	Next market	Scroll ask stack	Next position	Scroll to history
ATOM	Atom/Leaf	[Shortcut] Display stats	[Shortcut] Display imbalance	[Shortcut] Display detail	[Shortcut] Display summary
EVAL	Evaluate/Commit	Enter order submission	Create limit order	Close position	Return to market
EQ	Equal/Compare	[Not used]	[Not used]	[Not used]	[Not used]

Right Hand (Numpad) — Numeric Entry

Key	Function	In Order Entry
0	Digit 0	Add to price/size
1–9	Digits 1–9	Add to price/size
.	Decimal point	Separate dollars from cents (e.g., 48.50)
+	Add / BUY	Toggle side to BUY (or confirm if already buying)
−	Subtract / SELL	Toggle side to SELL
×	Multiply / LOTS	Multiply size (e.g., 5 × 100 = 500 units)
÷	Divide / SPLIT	Divide position (e.g., sell 500 / 2 = 250 × 2 orders)
ENTER	Submit	Submit the order to market

Workflow: Submitting a Buy Order

Operator is in Market Feed cell (showing CRUDE OIL, bid $48.50, ask $48.75)
Presses CONS to construct an order
Screen shows: “ENTER ORDER | PRICE: _ | SIZE: _”
Numpad: 4, 8, ., 6, 0 → “PRICE: 48.60” (limit order above current bid)
Numpad: 5, 0, 0 → “SIZE: 500”
Presses + to confirm BUY side (default is BUY; screen shows “BUY 500 @ 48.60”)
Presses ENTER to submit
Order is sent to market; firmware shows “ORDER SUBMITTED” and returns to market feed
Operator sees their new position in the Portfolio cell

Workflow: Closing a Position with a Hedge

Operator is in Portfolio cell, sees “LONG 500 CRUDE @ $48.50”
Presses CAR to drill into position details
In Position cell, presses CONS to construct a hedge
Screen shows: “CREATE OFFSETTING SELL | PRICE: _ | SIZE: _”
Numpad: 4, 9, ., 1, 0 → “PRICE: 49.10” (sell target)
Numpad: 5, 0, 0 → “SIZE: 500”
Presses − to confirm SELL side
Presses ENTER to submit
Hedge order queued; Position cell now shows “HEDGED: SELL 500 @ 49.10”
Operator waits for price to hit $49.10; when it does, both buy and sell orders settle

Special Shortcuts

BACK (2-second hold): Pause/abort current contract. Firmware saves progress; mission board offers to resume or abandon.
SYS + QUOTE: Cycle through macro slots (LAMBDA recordings).
SYS + CONS: Save current portfolio state as a named snapshot.
SYS + CDR: Display session statistics (total trades, win rate, avg profit/trade).

8. HOT SWAP INTEGRATION

SYNTHFENCE is designed to be a phase 2 or phase 3 module in multi-phase campaigns. The most common integration is with ICE BREAKER and BLACK LEDGER.

Campaign Archetype: Strategic Takeover

Phase 1: ICE BREAKER (Network Intrusion)

Objective: Infiltrate corporate network, extract sensitive data
Outcome: Operator extracts financial data, trading strategies, upcoming big trades
Cartridge: ICE BREAKER

Phase 2: BLACK LEDGER (Forensic Analysis)

Objective: Analyze extracted data for money laundering, shell companies
Outcome: Operator identifies suspect shell company and its market manipulation scheme
Cartridge: BLACK LEDGER
Context: Operator knows the shell company’s identity and their manipulation patterns

Phase 3: SYNTHFENCE (Market Exploitation)

Objective: Profit from the shell company’s manipulation or trade against them
Outcome: Operator executes trades that profit when the shell company’s scheme fails
Cartridge: SYNTHFENCE
Context: Phase chain contains: shell_company_identity, manipulation_pattern, suspected_target_commodity

Payout Multiplier: 1.5× base payout (completion bonus for coordinating three modules)

Swap Protocol

When BLACK LEDGER phase completes and SYNTHFENCE phase is required:

Firmware writes phase_chain to SRAM with:

phase_index = 3
phase_status = "MANIPULATION_PATTERN_IDENTIFIED"
commodity_target = TUNGSTEN  // (extracted from analysis)
manipulator_identity = "VERTEX_TRADING"
suspect_price_target = 12500  // ($125 per unit; shell expects this)
evidence_strength = 0.85      // (confidence in pattern)
accumulated_payout = 2800     // (payout from phases 1-2)
threat_escalation = +1        // (regulatory is now watching this commodity)

Firmware displays:

> BLACK LEDGER ANALYSIS COMPLETE
> FINANCIAL CONSPIRACY MAPPED
> TARGET: TUNGSTEN MARKET MANIPULATION
> MANIPULATOR: VERTEX TRADING LLC (Hong Kong Shell)
> PHASE 3 REQUIRES: MARKET OPERATIONS CAPABILITY
> INSERT CARTRIDGE: SYNTHFENCE
> PHASE CHAIN ACTIVE — DO NOT POWER DOWN

Operator physically swaps to SYNTHFENCE cartridge
Firmware reads SYNTHFENCE header, verifies it provides 0x07 (MARKET OPERATIONS), loads module
Firmware calls SYNTHFENCE phase handler with phase_chain context
SYNTHFENCE generates a special contract:
- Type: MANIPULATION DETECTION + ARBITRAGE (hybrid)
- Objective: “Exploit Vertex’s spoofing scheme; profit when they fail”
- Pre-configured commodity: TUNGSTEN
- Threat level: 4 (manipulators are active, regulatory watching)
- Cipher voice: “Your forensic team has mapped Vertex Trading’s spoofing scheme. They’re about to execute a massive pump-and-dump on tungsten futures. You have 20 turns to profit from their collapse.”
Operator runs the contract in SYNTHFENCE context, knowing exactly what to expect and why
Upon contract completion, firmware adds payout to phase_chain and offers:
- Abandon mission (collect payout from phases 1-3)
- Continue to phase 4 (if available; e.g., expose Vertex to regulators via different cartridge)

Worked Example: Strategic Takeover with Hot Swap

Phase 1 (ICE BREAKER, 12 minutes):

Operator intrudes into “Hong Kong Financial Systems Ltd” network
Extracts email logs showing Vertex Trading’s communication
Email reveals: “Plan spoofing campaign on tungsten. Target price: $125. Execute over 18 hours.”
Phase 1 payout: 1,200 ¤
Phase 1 rep: +4

Phase 2 (BLACK LEDGER, 18 minutes):

Firmware swaps to BLACK LEDGER, passes phase_chain
Operator audits Vertex Trading’s financial records extracted from ICE BREAKER
Operator identifies: shell company “Phantom Capital LLC” → “Vertex Trading LLC” → personal account “Vertex Holdings Ltd”
Operator traces $250,000 flowing from personal account → shell companies → tungsten futures trading account
Operator flags spoofing evidence: 8 data points
Phase 2 payout: 2,800 ¤
Phase 2 rep: +8

Swap to Phase 3 (SYNTHFENCE):

Firmware displays: “MANIPULATION PATTERN IDENTIFIED: Vertex Trading is executing spoofing on tungsten futures. Target: $125. Your objective: profit from their collapse.”
Phase 3 objective: Tungsten futures currently trading at $120. Vertex will spike price to $125 (with spoofing), then it will crash when their fake orders are exposed. Operator should: BUY at $120, hold through the spike, SELL when price cracks at $130 (overshot when spoofing fails).

Phase 3 Execution (SYNTHFENCE, 15 minutes):

Turns 1-3: Operator scans tungsten order book. Sees normal trading at $120.
Turn 4: Huge buy orders appear from “Vertex Trading.” Price spikes to $122.
Operator BUY 200 units at $122 (betting on the spike to continue)
Turn 5: Price spikes to $125 (Vertex’s pump working)
Turn 6: Vertex’s fake orders suddenly cancel (pump complete, now dump)
Price crashes to $118 (overshoot on the way down)
Operator SELL 200 units at $119 (catches the falling edge)
Profit: ($119 − $122) × 200 × 100 = LOSS of $600 ¤ (operator timed it wrong)

Alternative Better Execution:

Same setup, but operator predicts the dump timing better
Operator waits for Vertex’s orders to vanish (turn 6)
Then immediately enters SELL orders before the price crashes
SELL 200 units at $124 just as Vertex’s pump ends
Price crashes to $118
Operator re-enters LONG at $119, betting on a bounce
Price bounces to $121
Operator SELL at $121
Net result: (+$2 from first trade) + (+$2 from second trade) = +$400 ¤ profit
Phase 3 payout: 1,800 ¤ (base) + 400 ¤ (profit bonus) = 2,200 ¤
Phase 3 rep: +6

Total Campaign (Phases 1-3):

Total payout: 1,200 + 2,800 + 2,200 = 6,200 ¤
Total rep: 4 + 8 + 6 = +18 rep
Completion bonus: +500 ¤ (for coordinating three modules)
Grand total: 6,700 ¤, +18 rep

9. MISSION TEMPLATES

SYNTHFENCE generates four primary contract types, seeded by reputation and threat level.

ARBITRAGE Contract

Description: “Buy low in one market, sell high in another; lock in spread”

Threat Range: 1–2 Base Payout: 800–2000 ¤ Phases: 1 Time Limit: 12–15 turns Duration (Real Time): 3–5 minutes

Procedure:

Operator scans two or more markets for the same commodity (Tokyo and Mumbai, or Hong Kong and Singapore)
Operator identifies price differential: e.g., Tokyo at $48.50, Mumbai at $48.95
Operator buys in Tokyo at $48.50 (margin lock: 10% = $2,425 ¤)
Operator sells in Mumbai at $48.95
Orders settle; profit locked: $0.45 × 1000 = 450 ¤ gross
Margin released; net profit: ~350–400 ¤

Success Condition: Both buy and sell orders fill within time limit, profit positive

Failure Condition: Time expires, market moves, spread closes, margin call

Proficiency Gain: +0.5 (easiest contract)

Reputation Gain: +0.5–1.0

Worked Example:

Contract: TOKYO-MUMBAI CRUDE ARBITRAGE
Threat: 1 | Time: 15 turns | Payout: 1200 ¤

Turn 1: Operator opens Market Feed, observes Tokyo $48.50 bid, Mumbai $48.95 bid
Turn 2: Operator constructs BUY order: 1000 units @ $48.50 Tokyo
Turn 3: Order submitted and filled at $48.52 (slippage +$0.02)
        Margin lock: $4,852 ¤, Credit balance: $348 ¤
Turn 4: Operator drills into Mumbai market
Turn 5: Operator constructs SELL order: 1000 units @ $48.95 Mumbai
Turn 6: Order submitted and partially filled: 600 @ $48.95, 400 @ $48.90 (slippage)
        Profit so far: (48.95 - 48.52) × 600 + (48.90 - 48.52) × 400 = 260 + 152 = 412 ¤
Turn 7: Remaining 400 units still waiting for fill at $48.95
Turn 8: Remaining 400 units filled at $48.98 (price moved favorably)
        Total profit: (0.43 × 600) + (0.46 × 400) = 258 + 184 = 442 ¤ gross
        Minus margin lock (capital release): 442 ¤ net
        Speed bonus: 7 turns used of 15 available = (8 / 15) × 442 × 0.25 = 59 ¤
Turn 9–15: Idle (contract already complete)

Final: 442 + 59 = 501 ¤ payout (vs. 1200 ¤ base) — operator profited but didn't capture full potential.
       Rep gain: +0.5 (reliable, but slow execution)

VOLATILITY CAPTURE Contract

Description: “Time price swings; execute buy-low/sell-high pairs under time pressure”

Threat Range: 2–3 Base Payout: 1200–2800 ¤ Phases: 1–2 Time Limit: 15–20 turns Duration (Real Time): 4–7 minutes

Procedure:

Operator observes price oscillations (e.g., prices bouncing between $50 and $55)
Operator predicts the next peak or valley
Operator submits BUY order at predicted low
Operator waits for price to peak
Operator submits SELL order at peak
Profit locked: (peak − low) × size

Success Condition: Operator catches at least one complete buy-low/sell-high cycle within time limit; profit positive

Failure Condition: Price prediction wrong (operator buys at peak, sells at low); margin call; time expires

Proficiency Gain: +1.0–2.0 (medium difficulty; requires pattern recognition)

Reputation Gain: +1.0–2.0

Worked Example:

Contract: ENERGY VOLATILITY CAPTURE
Threat: 2 | Time: 18 turns | Payout: 1800 ¤

Turns 1-3: Price oscillates $50–$52 (minor volatility)
Turn 4: Price spikes to $55 (operator observes uptrend)
Turn 5: Operator presses INFO, reads price history
        Last 10 ticks: $50.00, $50.10, $51.50, $52.00, $54.00, $55.00 (current)
        Operator predicts: "Peak likely at $55 or $56. Next move is down. BUY now."
Turn 6: Operator submits BUY 1500 @ $55.50 (limit order slightly above current bid)
Turn 7: BUY order fills: 1500 @ $55.45 (better than expected)
Turn 8: Price continues up to $56.00 (operator still holding, hoping for higher)
Turn 9: Price peaks at $56.50 (operator now confident they'll sell)
Turn 10: Price starts falling: $55.80
Turn 11: Operator submits SELL 1500 @ $55.50
Turn 12: Price is $55.20, SELL order not yet filled (limit order at $55.50 waiting)
Turn 13: Price bounces back to $55.60, SELL order fills at $55.55 (within $0.05 of limit)
Turn 14: Profit calculated: ($55.55 − $55.45) × 1500 = $150 × 100 ¤ = $150 ¤ gross (small profit)

Wait — operator made poor timing decision. Let me recalculate with better execution:

Better execution:
Turn 13: Price reaches $56.10 (peak). Operator sees price at resistance.
Turn 14: Operator submits SELL at MARKET (not limit order; accepts slippage)
Turn 14: SELL 1500 @ $56.05 (market order executed immediately at current ask)
Turn 15: Profit: ($56.05 − $55.45) × 1500 × 100 ¤ = 900 ¤ gross
         Speed bonus: (3 / 18) × 900 × 0.25 = 38 ¤
         Timing bonus (caught peak within ±0 ticks): ×1.5 = 1350 ¤ adjusted

Final: Base 1800 ¤ + profit contribution 900 ¤ = 2700 ¤ potential, actual 1500 ¤ (operator too conservative with market order)
       Rep gain: +1.5 (good pattern recognition, but missed bonus)

MANIPULATION DETECTION Contract

Description: “Identify artificial price movement; trace to market manipulator; report”

Threat Range: 2–4 Base Payout: 1500–3500 ¤ Phases: 2–3 (investigation, analysis, reporting) Time Limit: 18–25 turns Duration (Real Time): 6–10 minutes

Procedure:

Operator observes market feed (operator is told: “Suspicious pattern detected”)
Operator scans order book, price history, and volume data
Operator identifies manipulation signature (spoofing, layering, wash trades, front-running)
Operator marks evidence points (CAR drill, QUOTE bookmark)
Operator analyzes: “Pattern indicates spoofing. Source: shell company XYZ.”
Operator files regulatory report with evidence chain
Regulator reviews; if confidence high enough, pays operator bonus

Success Condition: Operator files report with 80%+ confidence in correct manipulation pattern and correct manipulator identity; payout + bonus

Failure Condition: Operator incorrectly identifies pattern; false confidence results in -rep penalty; operator misses manipulation entirely

Proficiency Gain: +2.0–5.0 (high difficulty; requires detective work)

Reputation Gain: +2.0–5.0

Example Manipulation Patterns:

Spoofing:

Turn 1-3: Price at $120, normal trading
Turn 4: Large buy order (500 units) appears at $120.50 → price spikes to $123
Turn 5: That order cancels → price crashes to $119
Pattern repeats turns 6-8
Evidence: (1) Fake order appeared, (2) Price spiked, (3) Order canceled, (4) Price crashed = 4 evidence points

Layering:

Order book shows: 10 buy orders all at $119.50 (stacked thin, from same trader)
Order book shows: 5 buy orders at $119.49, 5 at $119.48, 5 at $119.47
All 15 orders entered market within same turn (coordinated)
All 15 orders canceled together 2 turns later (fake demand)
Evidence: (1) Coordinated entry, (2) Layering pattern, (3) Coordinated cancel = 3 points
Harder to prove than spoofing (requires more data analysis)

FLASH TRADING Contract

Description: “Execute high-frequency trades in microsecond windows; outpace competitors”

Threat Range: 3–4 Base Payout: 2000–5000 ¤ Phases: 1 Time Limit: 8–12 turns Duration (Real Time): 2–4 minutes

Procedure:

Operator is shown 5–10 rapid-fire trade sequences
Each sequence: buy at price_A, sell at price_B, locked-in profit per trade
Operator must execute all trades in sequence, within time limit
Each trade takes 1 turn to submit; must fill next turn or time expires
Success: all 5+ trades execute, total profit calculated
Failure: any single trade misses its window, entire contract fails (cascading loss)

Success Condition: All trades execute in sequence within time limit; net profit positive

Failure Condition: One trade misses; entire chain breaks; operator loses credits (flash trade chains are all-or-nothing)

Proficiency Gain: +2.0–3.0 (high difficulty; requires quick execution)

Reputation Gain: +2.0–3.0

Worked Example:

Contract: MULTI-MARKET FLASH TRADING
Threat: 4 | Time: 10 turns | Payout: 3500 ¤

Operator is given: "Execute this sequence:
  Trade 1: BUY 500 CRUDE @ $48.00, SELL @ $48.05 (profit: $25 ¤)
  Trade 2: BUY 1000 GOLD @ $1,950, SELL @ $1,955 (profit: $50 ¤)
  Trade 3: BUY 300 COPPER @ $3.50, SELL @ $3.52 (profit: $60 ¤)
  Trade 4: BUY 750 ENERGY @ $2.00, SELL @ $2.03 (profit: $23 ¤)
  Trade 5: BUY 200 TUNGSTEN @ $125, SELL @ $127 (profit: $40 ¤)"

Turn 1: Operator submits BUY 500 CRUDE @ $48.00 MARKET
        Market immediately accepts (competitive market, lots of ask volume)
        Operator's order fills at $48.02 (slippage +$0.02)
        Profit for this trade: $25 − $10 (slippage cost) = $15 ¤
Turn 2: Operator immediately presses EVAL to submit SELL 500 @ $48.05
        Price has moved to $48.04, SELL order partially fills at $48.03 (300 units), misses 200
        Partial fill: 300 × $0.01 = $3 ¤; 200 units still open
        Chain is now broken (Trade 1 incompletely executed)
        Operator can try to salvage with CONS + hedge on the 200 units, but time is burning
Turn 3: Operator tries to close the 200-unit shortfall, but price has moved to $47.98
        Any SELL now executes at loss
        Operator abandons Trade 1 half-complete and cancels

Result: Flash trading chain broken on Trade 1. Contract FAILED.
        Payout: $0 (all-or-nothing; partial execution = failure)
        Rep penalty: -2
        Operator loses entry margin but no catastrophic loss

Better execution:
Turn 1: Operator observes market, sees GOLD spread at exactly $1,950 bid / $1,955 ask (perfect setup)
        Skips CRUDE (time-consuming), starts with GOLD
        Submits BUY 1000 @ $1,950 MARKET
        Fills immediately at $1,950.50 (slippage $50)
Turn 2: Submits SELL 1000 @ $1,955 MARKET
        Fills immediately at $1,954.80 (slippage −$200)
        Trade 1 profit: $1,954.80 − $1,950.50 = $4.30 × 1000 ¤ = $4,300 ¤ (large)
        But wait — that's unrealistic. Let me recalculate with realistic micro-profits:

Actually, flash trading profits are small per trade ($1–5 ¤ per trade), but volume is large (100+ contracts).
The payoff comes from executing 5+ trades in sequence, each locking in $3–10 ¤.
Total = $25 ¤ from trades × speed multiplier = decent payout.

Proper execution with 5 trades @ 5 ¤ profit each = 25 ¤ base
Speed bonus: (5 / 10) × 25 × 0.25 = 3.125 ¤
Total: ~28 ¤ net? (That seems low for a 3,500 ¤ contract...)

I think the 2,000–5,000 ¤ base includes the profit scaling. Let me reconsider:
Base payout: 2,500 ¤ (mid-range for threat 4)
Profit contribution: (total_realized_profit / 100) ¤
Speed bonus: (time_remaining / time_limit) × base × 0.25
Final: (base + profit_contrib + speed_bonus) × accuracy_multiplier

If operator executes all 5 trades perfectly with total profit $250 ¤ from trading:
Final = (2500 + 250 + 312) × 1.0 = 3,062 ¤ (reasonable for a well-executed flash trade)

10. SCREEN WIREFRAMES

SYNTHFENCE uses text-based display on an 80×25 character grid with amber monospace font. The interface focuses on market feeds, order books, portfolio management, and manipulation detection.

Screen 1: Market Feed & Commodity Overview

ROW 0: SYNTHFENCE > MARKET FEED [CRUDE OIL] [TIME: T+08:45] [CREDITS: $4200] [REP: 12]
ROW 1:
ROW 2: COMMODITY: CRUDE OIL (CL) — NYMEX
ROW 3:
ROW 4: PRICE ACTION:
ROW 5:  Current Bid:    $48.50 (1,000 contracts)  ▁▂▃▄▅▆▇█ ↑ STRONG BUY PRESSURE
ROW 6:  Current Ask:    $48.75 (800 contracts)    ▁▂▃▄▅▆▇ ↑ RISING
ROW 7:  Spread:         $0.25 (51 basis points)   MODERATE
ROW 8:  Volatility:     18% (NORMAL)
ROW 9:  Trend:          ↑ RISING (last 5 ticks)
ROW 10:
ROW 11: PRICE HISTORY (10 ticks):
ROW 12:  $48.40→$48.42→$48.50→$48.48→$48.52→$48.60→$48.58→$48.62→$48.65 (CURRENT)
ROW 13:
ROW 14: LAST TRADE:
ROW 15:  Price: $48.60 | Volume: 523 contracts | Time: 09:47:22 | Buyer: AUTO_MM
ROW 16:
ROW 17: VOLUME PROFILE (last hour):
ROW 18:  High: $48.75 | Low: $48.25 | Open: $48.35 | Close: $48.60
ROW 19:
ROW 20: (Market active. 12 minutes remaining in contract.)
ROW 21:
ROW 22:  [CAR=drill] [CDR=next commodity] [INFO=history] [CONS=order] [EVAL=submit]
ROW 23: MARKET FEED | CRUDE OIL | BID: $48.50 | ASK: $48.75 | SPREAD: 51bp

Screen 2: Order Book Depth (Bid-Ask Imbalance)

ROW 0: SYNTHFENCE > ORDER BOOK [CRUDE OIL] [TIME: T+08:47] [CREDITS: $4200] [REP: 12]
ROW 1:
ROW 2: ORDER BOOK DEPTH — NYMEX CRUDE OIL
ROW 3:
ROW 4:   ASKS (Sellers)              │  Price  │  BIDS (Buyers)
ROW 5:   Price      Volume          │  Levels │  Volume     Price
ROW 6: ────────────────────────────────────────────────────────────
ROW 7:   $48.95       100           │ [5]     │  1,000    $48.50 ◄ TOP BID
ROW 8:   $48.90       250           │ [4]     │    500    $48.49
ROW 9:   $48.85       500  CURRENT │ [3]     │    750    $48.45
ROW 10:  $48.80     1,000           │ [2]     │  1,500    $48.40
ROW 11:  $48.75       800           │ [1]     │    300    $48.35
ROW 12:
ROW 13: ANALYSIS:
ROW 14:  Bid-Ask Spread: $0.25 (moderate liquidity)
ROW 15:  Total Bid Depth: 4,050 contracts (strong buying interest)
ROW 16:  Total Ask Depth: 2,650 contracts (light selling pressure)
ROW 17:  Imbalance Ratio: 1.53 (bullish — more bids than asks)
ROW 18:  Interpretation: Price likely to move UP. Buy pressure building.
ROW 19:
ROW 20: (Select bid/ask level with ◄ CDR ► to drill. CONS places order.)
ROW 21:
ROW 22:  [CAR=top bid] [CDR=scroll] [INFO=details] [CONS=order] [EVAL=analyze]
ROW 23: ORDER BOOK | IMBALANCE: 1.53 (BULLISH) | TOP BID: $48.50 | 4050 CONTRACTS

Screen 3: Portfolio & Open Positions

ROW 0: SYNTHFENCE > PORTFOLIO [OPERATOR: epsilon] [TIME: T+08:52] [CREDITS: $4200]
ROW 1:
ROW 2: ACCOUNT SUMMARY:
ROW 3:  Total Credits:        $4,200 ¤ (Available: $1,775 ¤)
ROW 4:  Margin Used:          $2,425 ¤ (57.7% of $4,200 total)
ROW 5:  Net P&L (Session):      +$75 ¤ (Unrealized + Closed)
ROW 6:  Turns Remaining:       12 / 15 (80% time used)
ROW 7:
ROW 8: OPEN POSITIONS (2 active):
ROW 9:
ROW 10: [1] LONG 500 CRUDE @ Entry $48.50
ROW 11:     Current: $48.65 | Profit: +$75 ¤ | Margin: $2,425 ¤ | Status: OPEN
ROW 12:     Filled: Turn 3 | Held: 5 turns | Close options: [CONS] to CLOSE
ROW 13:
ROW 14: [2] [PENDING] SELL 500 CRUDE @ Limit $49.00
ROW 15:     Filled: 0/500 | Expires: 8 turns | Status: WAITING FOR FILL
ROW 16:     Profit if filled: +$500 ¤ | Margin locked: $0 (pending only)
ROW 17:
ROW 18: CLOSED TRADES (this session): 1 winning, 0 losing
ROW 19:  Trade #1: Sold 200 GOLD @ $1,950 → Profit: +$100 ¤ (Turn 2)
ROW 20:
ROW 21: (Your margin is healthy. Position is profitable. 8 turns to contract end.)
ROW 22:  [CAR=position details] [CDR=history] [CONS=close] [EVAL=return] [INFO=pnl]
ROW 23: PORTFOLIO | MARGIN: 57.7% | P&L: +$75 | POSITIONS: 2 (1 open, 1 pending)

Screen 4: Order Entry & Numpad

ROW 0: SYNTHFENCE > ORDER ENTRY [CRUDE OIL] [TIME: T+09:00] [CREDITS: $4200]
ROW 1:
ROW 2: PLACE LIMIT ORDER — CRUDE OIL
ROW 3:
ROW 4: ORDER TYPE: [BUY] ← Toggle with LINK / LAMBDA keys
ROW 5:
ROW 6: PRICE ENTRY ($/barrel):
ROW 7:  48 . 70 __ __  ← Keys: 0-9 for digits, . for decimal
ROW 8:
ROW 9: SIZE ENTRY (contracts):
ROW 10:  500 __ __  ← Keys: 0-9 only
ROW 11:
ROW 12: CALCULATION:
ROW 13:  Order: BUY 500 @ $48.70 = $24,350 gross value
ROW 14:  Margin Required: $2,435 (10% of gross)
ROW 15:  Credit Available: $4,200 ✓ SUFFICIENT
ROW 16:  Margin After Fill: $1,765 available (41.9% utilization)
ROW 17:
ROW 18: ORDER BEHAVIOR:
ROW 19:  LIMIT ORDER at $48.70 — fills when market drops to $48.70 or below.
ROW 20:  Safer execution. Slower fill. May not fill if price doesn't reach limit.
ROW 21:
ROW 22:  [ENTER=submit] [BACK=cancel] [LINK=BUY] [LAMBDA=SELL] [INFO=help]
ROW 23: ORDER ENTRY | TYPE: BUY | PRICE: $48.70 | SIZE: 500 | MARGIN: $2,435

Screen 5: Manipulation Detection Alert

ROW 0: SYNTHFENCE > ⚠ MANIPULATION DETECTED [TUNGSTEN] [TIME: T+09:15] [ALERT]
ROW 1:
ROW 2: ALERT: Suspicious trading pattern detected in TUNGSTEN market
ROW 3:
ROW 4: PATTERN: SPOOFING (Probable — 78% confidence)
ROW 5:
ROW 6: EVIDENCE CHAIN:
ROW 7:  ✓ Turn 4: Large buy order placed (5,000 units @ $125.00)
ROW 8:  ✓ Turn 5: Price spiked +$3.00 in 1 turn (strong reaction)
ROW 9:  ✓ Turn 5: Buy order suddenly canceled (trap sprung)
ROW 10: ✓ Turn 7: Price crashed −$2.50 in 2 turns (dumpers profit)
ROW 11: ? Turn 8: Pattern repeating? (New order appearing on bids...)
ROW 12:
ROW 13: CURRENT STATE:
ROW 14:  Market Price: $123.50 (post-spike, pre-collapse)
ROW 15:  Your Position: [PENDING] SELL 1000 TUNGSTEN @ $126.00 (at risk!)
ROW 16:  Regulatory Flag: YELLOW (exchange monitoring this commodity)
ROW 17:
ROW 18: RECOMMENDATION:
ROW 19:  Hold your position (price is rising despite manipulation).
ROW 20:  Or: Close now for +$1,200 ¤ profit (cap gains, reduce risk).
ROW 21:
ROW 22:  [INFO=evidence] [CAR=account details] [CONS=report] [EVAL=continue]
ROW 23: ALERT | SPOOFING | TUNGSTEN | CONFIDENCE: 78% | YOUR POSITION: AT RISK

Screen 6: Margin Call & Liquidation

ROW 0: SYNTHFENCE > ⚠ MARGIN CALL TRIGGERED [CRITICAL] [TIME: T+09:30] [SYSTEM]
ROW 1:
ROW 2: CRITICAL: Account margin fallen below minimum requirements.
ROW 3:
ROW 4: ACCOUNT STATUS (pre-liquidation):
ROW 5:  Total Credits: $4,200 ¤
ROW 6:  Positions Held: LONG 500 CRUDE @ $48.50 entry
ROW 7:  Current Market: $47.00 (market crashed!)
ROW 8:  Unrealized Loss: −$750 ¤
ROW 9:  Margin Available: −$100 ¤ (NEGATIVE!)
ROW 10:
ROW 11: AUTOMATIC LIQUIDATION EXECUTED:
ROW 12:  SELL 500 CRUDE @ Market $47.05 (forced execution)
ROW 13:  Realized Loss: −$725 ¤
ROW 14:  Margin Release: +$2,425 ¤
ROW 15:
ROW 16: FINAL ACCOUNT STATE:
ROW 17:  Credit Balance: $3,475 ¤ (after loss + liquidation fees)
ROW 18:  All Positions: CLOSED
ROW 19:  Contract Status: FAILED (margin call = contract termination)
ROW 20:
ROW 21: (Your positions have been liquidated. Contract ended with −$725 loss.)
ROW 22:  [INFO=details] [EVAL=return to mission board]
ROW 23: LIQUIDATION | CONTRACT TERMINATED | FINAL LOSS: −$725 | CREDITS: $3475

Screen 7: Market Trend Analysis

ROW 0: SYNTHFENCE > TREND ANALYSIS [CRUDE OIL] [TIME: T+09:45] [CREDITS: $4200]
ROW 1:
ROW 2: MULTI-TIMEFRAME TREND ANALYSIS
ROW 3:
ROW 4: LAST 3 TURNS (Recent):
ROW 5:  $48.60 → $48.62 → $48.65: ↑ RISING (3 ticks up, consistent strength)
ROW 6:
ROW 7: LAST 10 TURNS (Session):
ROW 8:  $48.40......................$48.65: ↑ STRONG UPTREND (+$0.25, +0.52%)
ROW 9:
ROW 10: TECHNICAL INDICATORS:
ROW 11:  Moving Average (5-tick):  $48.54 | Price: $48.65 | Status: ABOVE MA (bullish)
ROW 12:  Momentum:                 +3 ticks | Direction: UP | Strength: MODERATE
ROW 13:  Volatility Index:         18% | Historical: 15% | Rising? YES (expanding range)
ROW 14:
ROW 15: PATTERN RECOGNITION:
ROW 16:  Current Pattern: ASCENDING (consistent higher highs, higher lows)
ROW 17:  Support Level: $48.40 (holds from Turn 1)
ROW 18:  Resistance Level: $48.75 (ask wall at this level)
ROW 19:
ROW 20: FORECAST (next 5 turns):
ROW 21:  Probability: 65% chance price reaches $49.00 | 45% chance hits $49.50
ROW 22:  Risk: 30% chance pullback to $48.35 (consolidation)
ROW 23: TREND ANALYSIS | UPTREND: STRONG | NEXT TARGET: $49.00 | SUPPORT: $48.40

Screen 8: Contract Summary & Payout

ROW 0: SYNTHFENCE > CONTRACT SUMMARY [OPERATOR: epsilon] [TIME: T+10:00] [FINAL]
ROW 1:
ROW 2: SYNTHFENCE CONTRACT COMPLETED (15 turns)
ROW 3:
ROW 4: TRADING PERFORMANCE:
ROW 5:  Total Trades: 3 (2 closed, 1 still open)
ROW 6:  Winning Trades: 2 | Losing Trades: 0 | Pending Trades: 1
ROW 7:  Win Rate: 100% (closed trades only)
ROW 8:
ROW 9: PROFIT SUMMARY:
ROW 10:  Trade #1 (GOLD): Sold 200 @ $1,950 = +$100 ¤
ROW 11:  Trade #2 (CRUDE): Bought 500 @ $48.50, selling at $48.65 = +$75 ¤
ROW 12:  Pending (CRUDE sell limit @ $49.00): EXPIRED unfilled
ROW 13:
ROW 14: FINAL CALCULATION:
ROW 15:  Base Payout: $600 ¤ (contract base reward)
ROW 16:  Profit Bonus: +$175 ¤ (from closed trades)
ROW 17:  Speed Bonus: +$45 ¤ (completed in 15 turns, no carry-over)
ROW 18:  Manipulation Bonus: +$50 ¤ (detected spoofing pattern)
ROW 19:  TOTAL PAYOUT: $870 ¤
ROW 20:  REPUTATION GAIN: +8 (market intelligence +4, trading success +4)
ROW 21:
ROW 22:  [CAR=details] [INFO=breakdown] [EVAL=accept payout & return]
ROW 23: CONTRACT COMPLETE | PAYOUT: $870 ¤ | REP: +8 | TRADES: 3 | WIN RATE: 100%

11. SESSION WALKTHROUGH: “THE ARBITRAGE”

A complete annotated gameplay session: ARBITRAGE + VOLATILITY CAPTURE back-to-back.

Player Profile: Operator “delta”, Rep 4 (Apprentice), Credit Balance $5,200 ¤

Session Duration: 35 minutes real-time (4 game turns per real minute ≈ 140 game turns available)

Part 1: ARBITRAGE (8 minutes)

Contract: TOKYO-MUMBAI CRUDE ARBITRAGE | Threat 1 | 15-turn time limit | 1,200 ¤ base payout

Turn 0 (Mission Select):

Screen: Mission Board showing 4 available contracts
Operator reads: “ARBITRAGE: Easy spreads available between Tokyo and Mumbai. 15-turn window.”
Operator presses CAR to inspect contract details
Cipher voice: “Tokyo crude spot price $48.50. Mumbai bid is $48.95. Spread is clean. Entry is simple.”
Operator presses EVAL to accept contract

Turn 1 (Market Scan — OBSERVE phase):

Screen: Market Feed cell showing CRUDE OIL commodity
Bid: $48.50 (Tokyo) | Ask: $48.75
Bid Volume: 1,000 contracts | Ask Volume: 800 contracts
Operator presses INFO to view price history
Screen shows last 10 ticks: $48.40, $48.42, $48.50, $48.48, $48.52, $48.60, $48.58, $48.62, $48.65
Operator sees: prices trending up, current price $48.65 (slightly above starting bid)

Turn 2 (Market Orientation — ORIENT phase):

Operator presses CAR to drill into order book depth
Screen: Order Book cell showing top 5 bids and asks
Bids stacked: $48.50 (1,000), $48.49 (500), $48.45 (750), $48.40 (1,500), $48.35 (300)
Asks stacked: $48.95 (100), $48.90 (250), $48.85 (500), $48.80 (1,000), $48.75 (800)
Operator sees: good liquidity on bid side, less on ask side. “Buyers are aggressive.”
Operator presses CONS to construct a BUY order

Turn 3 (Decision — DECIDE phase):

Screen: Order Entry mode
Current market: $48.65
Operator enters: PRICE 48.50 (expecting to lock in the best bid)
Numpad: 4, 8, ., 5, 0
Operator enters: SIZE 500
Numpad: 5, 0, 0
Operator presses + to confirm BUY side (default)
Order summary shown: “BUY 500 CRUDE @ $48.50 (limit order)”
Margin check: $48.50 × 500 × 0.10 = $2,425 ¤ required (operator has $5,200, so ✓ OK)

Turn 4 (Execution — ACT phase 1):

Operator presses ENTER to submit
Market processes: BUY order enters order book at $48.50 level
Screen updates: “BUY ORDER SUBMITTED | Status: PENDING (on market)”
Cipher voice: “Buy order at $48.50 in Tokyo. Waiting for fill. Margin locked: $2,425.”
Operator’s credit now shows: $5,200 − $2,425 margin = $2,775 ¤ available

Turn 5 (Wait for Fill):

Market updates: price ticks to $48.55 (price moves slightly)
Operator’s BUY order still waiting at $48.50 (unfilled)
Operator presses BACK to view portfolio
Screen: Portfolio cell showing LONG position pending
Operator sees: “ORDER #1 [PENDING] BUY 500 @ $48.50 | Status: Waiting | Expires: 10 turns”

Turn 6 (Fill Received):

Market updates: price ticks DOWN to $48.48 (good news for buyer!)
Operator’s BUY order at $48.50 is now above market
Order fills! Screen shows: “[FILLED] BUY 500 @ $48.50”
Cipher voice: “Order filled! 500 units at $48.50. You own the crude. Margin: $2,425.”
Operator’s position: LONG 500 @ $48.50

Turn 7 (Navigate to second market — ORIENT phase 2):

Operator presses CDR to move to next market
Screen: Market Feed now shows MUMBAI CRUDE OIL
Bid: $48.95 (Mumbai) | Ask: $49.10
Bid Volume: 500 contracts | Ask Volume: 750 contracts
Operator sees: “Perfect! Mumbai bid is $48.95. Sell target is in sight.”
Operator presses CONS to construct a SELL order

Turn 8 (Decision — DECIDE phase 2):

Screen: Order Entry mode
Operator enters: PRICE 48.95 (matching Mumbai bid)
Numpad: 4, 8, ., 9, 5
Operator enters: SIZE 500
Numpad: 5, 0, 0
Operator presses − to toggle to SELL side
Order summary: “SELL 500 CRUDE @ $48.95 (limit order)”
Profit calculation: ($48.95 − $48.50) × 500 = $0.45 × 500 ¤ = $225 ¤ gross profit (in scale)

Turn 9 (Execution — ACT phase 2):

Operator presses ENTER
SELL order submitted to Mumbai market
Screen: “SELL ORDER SUBMITTED | Status: PENDING”
Cipher voice: “Sell order at $48.95. Locked in: $0.45 per barrel spread. 5 turns to fill before window closes.”

Turn 10 (Wait for second fill):

Market updates: Mumbai price ticks to $48.98
Operator’s SELL order at $48.95 is now below market (good for seller!)
Order fills! Screen: “[FILLED] SELL 500 @ $48.98” (better than expected!)
Cipher voice: “Sell executed! 500 units at $48.98. Better price than target. Profit locked.”

Turn 11 (Debrief):

Market updates: prices cool down slightly
Operator presses BACK to return to mission completion
Screen: Contract Debrief
- Trade: BUY 500 @ $48.50 → SELL 500 @ $48.98
- Profit: ($48.98 − $48.50) × 500 = $0.48 × 500 ¤ = $240 ¤ gross
- Speed bonus: (4 / 15) × 1,200 × 0.25 = $80 ¤
- Slippage: −$10 ¤ (sell was $0.03 better than expected, call it wash)
- Total payout: 1,200 + 24 + 80 = $1,304 ¤
- Reputation: +1 (successfully completed)
- New credit balance: $2,775 + $1,304 = $4,079 ¤
Cipher voice: “Tokyo to Mumbai in 4 turns. You captured the spread. Clean execution. Reputation +1.”

Real time elapsed: ~8 minutes

Part 2: VOLATILITY CAPTURE (17 minutes)

Contract: ENERGY VOLATILITY CAPTURE | Threat 2 | 18-turn time limit | 1,800 ¤ base payout

Turn 0 (Mission Select):

Operator returns to Mission Board
Board refreshed with new contracts
Operator reads: “VOLATILITY CAPTURE: Natural gas prices oscillating $2.00–$2.10. 18-turn window. Requires pattern recognition.”
Operator presses EVAL to accept

Turns 1-5 (Observation — OBSERVE phase):

Screen: Market Feed showing NATURAL GAS
Current: Bid $2.00 | Ask $2.05
Operator presses INFO to view price history
Last 10 ticks: $1.95, $1.98, $2.00, $2.02, $2.05, $2.08, $2.10, $2.08, $2.06, $2.05
Cipher voice: “Price climbed from $1.95 to $2.10. Peaked 2 turns ago. Now falling. Should bounce at support.”
Operator observes pattern: prices rising for 3 turns, then falling for 2 turns
Operator sees oscillation: “Buy at $2.00 support, sell at $2.10 resistance”

Turn 6 (Decision — DECIDE phase 1):

Operator predicts: “Next move is UP (we’re at low point)”
Operator presses CONS to construct BUY order
Enters: PRICE 2.00, SIZE 1000 (larger position, betting on bigger move)
Margin: $2.00 × 1000 × 0.15 = $300 ¤ (15% margin at Threat 2)
Available: $4,079 − $300 = $3,779 ¤ remaining

Turn 7 (Execution — ACT phase 1):

Operator presses ENTER
BUY order submitted at $2.00
Screen: “[PENDING] BUY 1000 ENERGY @ $2.00”

Turn 8 (Fill):

Market updates: price ticks to $2.02
BUY order still waiting (entered above market)
Order doesn’t fill yet (market moved away from $2.00 bid)

Turn 9 (Wait):

Price ticks to $2.04 (moving against operator)
BUY order still pending at $2.00 (below current price, won’t fill)
Operator getting nervous; presses BACK to check position
Operator realizes: limit order won’t fill if market keeps rising
Operator decides: “Cancel this order and use MARKET order”

Turn 10 (Adaptive Decision):

Operator presses EVAL on pending order to cancel it
Screen: “[CANCELLED] BUY 1000 ENERGY @ $2.00”
Margin released: $300 ¤ returned
Operator presses CONS to submit new MARKET order
Enters: PRICE [MARKET], SIZE 1000
This time, operator will accept whatever price market offers (no limit)
Presses ENTER

Turn 11 (Market Fill):

Order submitted as MARKET order (execute now at best ask)
Market price is $2.04 (current ask)
Operator’s order fills at $2.05 (ask + slippage $0.01)
Screen: “[FILLED] BUY 1000 ENERGY @ $2.05”
Cipher voice: “Aggressive entry at market. 1,000 units at $2.05. You’re betting on a spike.”
Operator is now LONG 1000 @ $2.05

Turns 12-15 (Peak Hunting — ORIENT + ACT phase 2):

Turn 12: Price rises to $2.07 (operator happy; +$20 ¤ unrealized)
Turn 13: Price rises to $2.10 (operator very happy; +$50 ¤ unrealized) → operator sees price at resistance level
Turn 14: Operator presses CONS to construct SELL order
- Enters: PRICE 2.10, SIZE 1000
- Operator presses − to confirm SELL side
Turn 15: Operator presses ENTER to submit SELL at $2.10
- SELL order queued
- Screen: “[PENDING] SELL 1000 ENERGY @ $2.10”

Turn 16 (Peak and Sell):

Market price ticks: $2.08 (falling! operator’s sell order at $2.10 is now above market, won’t fill!)
Operator realizes: “I set limit price too high. I’m missing the peak.”
Operator presses EVAL to cancel SELL order
Enters new MARKET sell order (accept current ask: $2.07)
Presses ENTER
SELL order executes at $2.07 (market + slippage)
Screen: “[FILLED] SELL 1000 ENERGY @ $2.07”
Profit: ($2.07 − $2.05) × 1000 = $0.02 × 1000 ¤ = $20 ¤ gross (small profit)
Cipher voice: “Sold into the fall. Profit locked at $20. Could’ve been more if you timed the peak.”

Turn 17 (Optional: Catch Second Wave):

Price continues falling: $2.05 (back to entry point)
Operator predicts: “Second bounce coming”
Operator presses CONS, constructs another BUY: PRICE 2.05, SIZE 500 (smaller position)
Presses ENTER
Order submitted
Turn 18: Price bounces to $2.07 (BUY order at $2.05 fills before bounce!)
Screen: “[FILLED] BUY 500 ENERGY @ $2.05”
Operator is now LONG 500 @ $2.05 (half position)
Time limit approaching (2 turns left)

Turn 19 (Final Sell):

Price at $2.08 (moving up, good for seller)
Operator presses CONS, constructs SELL: PRICE 2.08, SIZE 500
Presses ENTER
SELL fills at $2.08
Profit from second trade: ($2.08 − $2.05) × 500 = $0.03 × 500 ¤ = $15 ¤
Total profit: $20 + $15 = $35 ¤ gross

Turn 20 (Debrief):

Screen: Contract Debrief
- Trade 1: BUY 1000 @ $2.05 → SELL 1000 @ $2.07 (+$20 ¤)
- Trade 2: BUY 500 @ $2.05 → SELL 500 @ $2.08 (+$15 ¤)
- Total profit: $35 ¤
- Speed bonus: (−2 / 18 → overspent 2 turns, no speed bonus; multiplier 0.8)
- Slippage penalty: −$8 ¤ (multiple market orders taken slightly above/below target)
- Timing accuracy: Operator caught within ±2 ticks of peak, not ±1 (multiplier 1.0, not 1.5)
- Total payout: 1,800 + 3 (profit contribution) + 0 (speed penalty) = $1,803 ¤
- Reputation: +1 (successfully completed)
- New credit balance: $3,779 + $1,803 = $5,582 ¤
Cipher voice: “Two volatility cycles. First one small, second one quick. You’re learning to read the rhythm. Pattern recognition is improving. +1 reputation.”

Session Summary:

Total Duration: 35 minutes (real-time ≈ 140 game turns available, used ~40 turns across two contracts)
Contracts Completed: 2 (ARBITRAGE + VOLATILITY CAPTURE)
Total Payout: $1,304 + $1,803 = $3,107 ¤
Reputation Gain: +2 (Rep 4 → Rep 6, crossing into Novice tier!)
Final Credit Balance: $5,582 ¤
Skills Learned: Arbitrage execution, volatility detection, market order vs. limit order tradeoffs, peak timing, position management under time pressure

12. DESIGN NOTES

Why Market Tempo Is Unique

SYNTHFENCE’s core innovation is that the operator does not control time. In ICE Breaker, the operator decides when to OBSERVE, when to ACT. The network threat system runs in parallel, but the operator initiates the turn sequence. In Black Ledger, the operator takes as long as needed to analyze; time is abundant (move budget is the constraint).

In SYNTHFENCE, time is the adversary. The market moves every turn, independent of the operator’s decision speed. If the operator hesitates for 3 turns, they’ve lost 3 turns of opportunity. The spread they spotted might have closed. The volatility peak they predicted might have passed. The regulatory window might have slammed.

This teaches a truth about real markets: they do not wait for you. Speed of decision-making is a core skill. The operator learns to:

OBSERVE faster — scan price feeds, identify patterns, make snap judgments
DECIDE faster — formulate a trade in seconds, not minutes
ACT faster — execute orders with conviction, not hesitation

The PSG’s role in this is crucial. A novice operator (Rep 0–4) watches the text display and reads prices consciously. An expert operator (Rep 25+) learns to “hear” the market through Voice 1’s pitch and Voice 2’s pulses, and can make decisions with eyes closed. Sound is faster than text. Audio gives feedback in real-time; text requires conscious parsing.

Financial Literacy as Stealth Education

SYNTHFENCE teaches genuine financial concepts, disguised as game mechanics:

Bid-Ask Spreads & Liquidity: Real markets have wider spreads when there are fewer traders. SYNTHFENCE embeds this: when order book depth is thin, spreads widen; when order book is thick, spreads compress. Operator learns: “I can only arbitrage when spreads are wide. Liquid markets are tight; I can’t capture them.”

Margin Mechanics: Real traders borrow to amplify returns. SYNTHFENCE shows the danger: overleveraging (20–50% margin) means a 5% price move can trigger a margin call. Operator learns: “Safety requires conservative margin (5–10%). Greed leads to liquidation.”

Market Manipulation Detection: Real regulators watch for spoofing, layering, front-running. SYNTHFENCE makes these patterns audio-detectable (Voice 3 plays dissonant tones) and visually analyzable (order book shows fake orders, then they cancel). Operator learns: “Manipulation has a signature. I can recognize it. I can profit from detecting it, or be trapped by not noticing it.”

Volatility & Risk: Real traders understand: “Volatility is opportunity, but it’s also danger.” SYNTHFENCE models this: high volatility (±2%–±5% per turn) creates larger profit windows but also larger loss windows. Operator learns: “Volatile markets are lucrative if I’m right. Disastrous if I’m wrong. I need prediction skills to exploit volatility.”

Regulatory Systems: Real markets have circuit breakers, position limits, trading halts. SYNTHFENCE implements these: if volatility exceeds thresholds, trades halt for 2 turns; if operator’s position is too large, they can’t add more. Operator learns: “Regulators constrain extreme behavior. I have to work within the system, not against it.”

None of this is explicitly labeled “financial education.” The operator is just playing a game. But by the time they reach Rep 25+, they understand arbitrage, volatility, margin, manipulation detection, regulatory pressure, and risk management. They’re learning by doing, not by reading.

Sound as the Core Interface

In standard games, sound is supplementary—background music, feedback beeps. In SYNTHFENCE, sound is the primary market interface.

Voice 1 (price pitch) + Voice 2 (order activity) + Voice 3 (threat) combine to create a “market song.” Expert operators don’t read the display; they listen to the song and know the market’s mood instantly.

This serves two purposes:

Accessibility: Players with visual impairments can still feel market state through audio
Cognitive Reduction: Sound is processed by the brain faster than visual text. An expert operator’s decision loop can become sub-second (hear the pitch, hear the pulse, decide instantly, execute)

This is stealth skill-building through multimodal learning. Different players will gravitate toward different modalities—some will read the display obsessively, others will close their eyes and listen. Both are valid; both lead to expertise.

Cross-Module Integration as Campaign Narrative

SYNTHFENCE is most powerful when paired with ICE BREAKER and BLACK LEDGER in a Strategic Takeover campaign. The narrative becomes:

Phase 1 (ICE BREAKER): “I infiltrate a corporate network and extract sensitive data.” Phase 2 (BLACK LEDGER): “I analyze the data and uncover financial conspiracy—market manipulation, shell companies.” Phase 3 (SYNTHFENCE): “I profit from the conspiracy’s collapse, or expose it to regulators, or protect myself by trading against the manipulators.”

This three-act structure shows how different modules are pieces of a larger conspiracy-solving narrative. The operator is not just grinding contracts in isolation; they’re building a case, gathering evidence, and executing a plan that spans three different capability domains.

The campaign also teaches systems thinking: how financial networks connect to market behavior, how market behavior connects to network vulnerabilities. A sabotage of the exchange network (ICE BREAKER) directly impacts market data feeds and creates trading opportunities (SYNTHFENCE).

Replayability and Procedural Variation

SYNTHFENCE generates markets procedurally. The same contract type (ARBITRAGE, VOLATILITY, etc.) is never quite the same twice. The LFSR seeding means:

Different commodities each run
Different threat levels (reputation-based scaling)
Different market baselines and volatility curves
Different manipulator signatures (if present)

An operator who runs 50 ARBITRAGE contracts will see 50 different market pairs, spreads, and time windows. They’re not memorizing a single solution; they’re learning the skill of arbitrage—pattern recognition across variations.

This is why SYNTHFENCE has replayability on the KN-86. The device has limited cartridges (14 total), but each cartridge has hundreds of contract variations. An operator can spend weeks on SYNTHFENCE alone, always finding new challenges.

13. RUNTIME ARCHITECTURE (NOSH RUNTIME INTEGRATION)

SYNTHFENCE integrates with the KN-86 firmware as a capability module (Module Class 0x07). Key firmware responsibilities:

Cartridge-to-Firmware Boundary

Cartridge provides:

Mission template structures (ARBITRAGE, VOLATILITY, MANIPULATION, FLASH TRADING)
Cell type definitions (MARKET_CELL, ORDER_BOOK_CELL, POSITION_CELL, etc.)
Cipher domain vocabulary (market terminology)
Procedural generation logic (LFSR-based market simulation)

Firmware provides:

Universal Deck State management (credits, reputation, cartridge history)
Mission board generation and contract spawning
Phase chain serialization (for hot swap)
Cell pool memory management
Navigation stack (CAR/CDR/CONS/EVAL dispatch)
Display rendering (text mode, split-screen, bitmap overlay)
Audio callback (YM2149 PSG voice updates)
Input handling (31-key debouncing, hold detection)
Link protocol (multi-player handshakes)

Procedural Generation Seed

The nOSh runtime seeds SYNTHFENCE’s market generation with:

seed = (deck_state.reputation << 16) |
       (deck_state.cartridge_history << 8) |
       (lfsr_next() & 0xFF)

This ensures:

Same deck, same reputation, same LFSR state = same market (deterministic)
Different reputation = different threat level (markets get harder as rep increases)
Different LFSR = different market variation (randomization within threat tier)

This allows the operator to “see” how reputation impacts market difficulty while maintaining reproducibility for testing.

Performance Targets

Z80 @ 6 MHz, 32 KB SRAM budget:

Market tick update: <10ms (price feed advance, order book shift)
Order submission: <20ms (validation, margin check, position update)
Cell display: <16ms per frame (60 FPS target)
Audio callback: <5ms per frame (44.1 kHz sample generation)
Total per-frame budget: ~50ms (well under 60 FPS at realistic clock speeds)

SYNTHFENCE is less compute-heavy than ICE BREAKER (no network simulation) and comparable to Black Ledger (investigative decision-making instead of fast action). The primary constraint is SRAM: 32 KB supports up to 8 simultaneous open positions, 32 closed trades in history, and 256-byte phase chain state.

Conclusion

SYNTHFENCE transforms the KN-86 Deckline into a real-time trading terminal. The operator is a volatility trader and arbitrage specialist, racing against market-driven time pressure to read prices, execute trades, detect manipulation, and lock in profits.

The core mechanical innovation is market tempo—the operator does not control time. This creates a unique cognitive challenge compared to other KN-86 modules: speed of decision, pattern recognition under pressure, and constant awareness of external state.

The integration with ICE BREAKER and BLACK LEDGER completes the Strategic Takeover campaign narrative: infiltrate networks, uncover financial conspiracy, profit from the collapse. SYNTHFENCE is the payout phase—where intelligence becomes credits.

Key Design Pillars:

Market as Adversary — The market’s tempo, not the operator’s
Sound as Interface — Price and volume encoded in PSG voices
Financial Literacy — Teaching real market concepts through play
Procedural Variation — Hundreds of contract permutations ensure replayability
Campaign Narrative — Cross-module hot swap creates conspiracy-solving stories

SYNTHFENCE is engineering-ready for the KN-86 emulator and Pi Zero 2 W prototype deployment (see CLAUDE.md Canonical Hardware Specification).

CIPHER-LINE Contributions

SynthFence’s voice: Kobe port-district trader at 5 AM. Commercial. No romance. Numbers. Occasional commodity slang.

Vocabulary Pools

(:subject       "spread" "volume" "bid" "ask" "ticker"
                "basis" "arb" "queue" "print" "lot")
(:object        "tick" "book" "depth" "feed" "fill" "spread")
(:location      "book" "exchange" "window" "pit" "queue")
(:verb-present  "widens" "narrows" "lifts" "hits" "prints"
                "evaporates" "rolls")
(:verb-past-participle "filled" "printed" "missed" "sliced"
                       "rolled" "hit")
(:memory-keyword "spread" "print" "window" "roll" "basis")
(:affect-word   "thin" "wide" "fast" "late" "clean")

Production Fragments

(:mode-observe
  (3 (:subject) ". " (:synthfence/direction) ".")
  (2 "spread " (:affect-word) ".")
  (1 "fill."))

(:mode-annotate
  (3 "window narrow. " (:affect-word) ".")
  (1 "too late.")
  (1 "clean arb."))

(:mode-reflect
  (3 "same spread. " (:memory-fragment))
  (2 "this basis. " (:memory-fragment)))

(:mode-drift
  (2 "the copper print from tuesday.")
  (1 "the print that moved the silver book."))

(:synthfence/direction
  (3 "up.") (3 "down.") (2 "flat.") (1 "spiking."))

:event-types
  ((:type :spread-opened     :affect (:significant))
   (:type :spread-closed     :affect (:tense))
   (:type :fill-confirmed    :affect (:significant))
   (:type :regulatory-window :affect (:tense)))

Mode-Weight Biases

Beat	`observe`	`annotate`	`reflect`	`drift`	`silent`
`:active-hack` (trading)	+0.10	—	—	—	—
`:high-tense` (window closing)	+0.05	+0.05	—	—	—
`:debrief`	—	+0.15	+0.10	—	—

Rationale. Markets are loud and continuous. SynthFence voices observe faster than most carts. Silence biases are lower — the market fills the void if Cipher doesn’t.

Style Deltas

((:active-hack (:terseness +32 :certainty +24))
 (:debrief     (:terseness +0 :certainty +40)))

Structurally Important Moments Preserved on CIPHER-LINE

Beat	Intent	CIPHER-LINE fragment(s)
Spread opens	”Arbitrage window detected. Act fast.”	`window. up.`
Order filled	”Fill confirmed. Profit realized.”	`filled.` then `clean.`
Regulatory window closing	”Compliance window narrowing.”	`watched.` (tense)
Bad fill / loss	”Slippage ate the edge.”	`late. ate it.` (tense + significant)

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). SynthFence’s market-as-adversary design means the market moves while the operator thinks — so pre-authored trade predicates actually help, but the tempo is too fast to author during a trading window.

Scripted Missions?

Maybe — trade-rule scripting. Like Shellfire, SynthFence’s scripting is pre-run loadout: authored in calm, deployed at the open. Rep-12+ operators unlock the Quant Floor contracts which expressly reward rule-based trading (stop-loss triggers, volatility predicates, arbitrage detection). Scripted missions remain optional on the critical path (ADR-0002); most SynthFence play is direct observation + manual order entry.

Typical scripted-mission shapes:

(on-spread-above spread (place-order :arbitrage)) — arbitrage trigger.
(on-volatility-spike (close-positions)) — risk management.
(trailing-stop :pct 3) — dynamic position sizing.

Cart Grammar Fragments

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

(emacs-extend-grammar
  ;; Market primitives
  (bid                (symbol))
  (ask                (symbol))
  (spread             (symbol))
  (last-price         (symbol))
  (volume             (symbol &key :window))
  (volatility         (symbol &key :window))
  (order-book         (symbol &key :depth))
  ;; Portfolio primitives
  (position           (symbol))
  (pnl)
  (cash)
  (margin-used)
  (exposure)
  ;; Order actions
  (place-order        (&key :symbol :side :size :type))
  (cancel-order       (order-id))
  (close-position     (symbol))
  (hedge              (symbol))
  ;; Rule-based
  (on-spread-above    (symbol threshold &body body))
  (on-volatility-spike (symbol &body body))
  (on-regulator-alert (&body body))
  (trailing-stop      (&key :pct))
  ;; Regulatory
  (regulatory-window?)
  (compliance-level))

Vocabulary Contribution

Via (emacs-extend-vocabulary ...). Market / trading / regulatory terms:

(emacs-extend-vocabulary
  "bid" "ask" "spread" "price" "volume" "volatility"
  "book" "depth" "liquidity" "slippage"
  "buy" "sell" "hold" "hedge" "long" "short"
  "position" "cash" "margin" "exposure" "pnl"
  "order" "market" "limit" "stop" "trailing"
  "fill" "partial" "cancel" "reject"
  "arbitrage" "window" "edge" "spread-capture"
  "regulator" "compliance" "audit" "halted"
  "symbol" "ticker" "underlying" "synthetic")

`prompt-text` FFI Usage

No. SynthFence uses numpad order entry (size, price) and menu-driven symbol selection from the cart’s current watchlist. The cart declares nothing via prompt-text. Symbol names come from the cart catalog, not typed entry.

Double-Tap and Long-Press Bindings

SynthFence opts into ADR-0016 §9 on information-dense keys — bindings that reveal market context without burning order time:

Key	`:tap`	`:double-tap`	`:long-press`
`INFO`	`show-ticker-summary`	`show-order-book` — depth chart	`show-historical-volatility` — full context
`CAR`	`descend-into-symbol`	—	—
`EVAL`	`submit-order`	—	`submit-with-confirm` — double-check (slower, safer)
`QUOTE`	`flag-ticker`	`bookmark-watchlist`	—

Row 24 renders: INFO:TICK INFO²:BOOK INFO…:HIST EVAL:ORDER EVAL…:CONFIRM QUOTE:FLAG.

Context-Polymorphic Key Semantics (Cart Gameplay)

SynthFence has two primary cursor contexts: ticker view (watchlist, price feeds) and order view (composing a trade):

Key	Ticker view	Order view
`INFO`	show-ticker-summary	show-order-preview
`CAR`	descend-into-symbol	enter-field
`CDR`	next-symbol	next-field (symbol → side → size → type)
`CONS`	add-to-watchlist	attach-trailing-stop
`EVAL`	open-order-form	submit-order
`QUOTE`	flag-ticker	save-as-template
`BACK`	exit-watchlist	cancel-order-draft
Numpad	row select	price / size entry

When the operator opens nEmacs to script a trading rule, dispatch yields to :nemacs-nav per ADR-0016 §3 — the editor keymap takes over. The cart typically pauses (halts auto-execution) while the operator is in nEmacs, preventing rules from firing mid-edit.