Compass CLI

A great player does not chase the ball. They read the play and target where they need to be to make the greatest possible impact on the outcome of the game.

What if every move started with both clocks read, the gut consulted, the options cleared, and ended with a receipt the next cycle could learn from?

Problem​

A problem well-stated is a problem 80% solved

Situation: The compass algorithm is specced — seven phases, fractal cadence, settlement layer mapping. Five threads (Aschenbrenner outer clock, situational wisdom inner clock, Damasio gut, futarchy clearing, tokenized settlement) synthesised into one cycle function. But the cycle runs in memory. Every session re-derives state. The gut is consulted ad-hoc and forgotten. Receipts are hand-written or skipped. Multi-move chaining sneaks in. Override of the gut is invisible. The algorithm exists. The instrument does not.

Intention: One CLI namespace — drmg compass — that runs the cycle end-to-end. Each command closes one phase. Each act produces a receipt matching the schema. Each receipt feeds the next cycle. The gut accumulates labelled training data. The weekly mirror prints alignment ratios and drift flags. The compass becomes operable, not theoretical.

Obstacle: Three compounding failures. (1) No cycle id — there is nothing to link a move back to its open state, so observation has nothing to label. (2) No SCARF gate — RECEIVE is the most-skipped phase because it is the most uncomfortable, and without an enforcement point it is silently bypassed. (3) No drift detection — three sessions in a row of overriding the gut feels like normal operation in the moment, only visible across cycles in the mirror.

Priorities​

1. Can the cycle run end-to-end via CLI without dropping a phase?
2. Where does the gut tag come from on day one — pure self-report, or default to "yield"?
3. What does an "open receiver" look like as a CLI gate that can refuse to proceed?
4. When does the gut get a classifier — after 30 receipts, or never?
5. How do we know the compass is pointing at the right values gauge and not a borrowed setpoint?

Features​

Phase 1: Foundation (1 sprint)​

The receipt schema and cycle id generator. Nothing else is buildable until these exist.

• CMP-001: Compass receipt schema (compass_cycle_id, phase_inputs, options_considered, move_taken, values_gauge_predicted, values_gauge_observed, gut_aligned, tokenization)
• CMP-002: Cycle id generator (UUID, persisted to receipt directory)

Phase 2: Open + Clear (2 sprints)​

The capture phases. Read both clocks, gate on SCARF, log the futarchy comparison.

• CMP-003: drmg compass open — Hermes web_search for outer clock + WM-NAV pack reader for inner clock + SCARF gate prompt
• CMP-004: drmg compass clear — log N options with predicted_delta + reversibility + cost + gut tag

Phase 3: Act + Observe (2 sprints)​

The execution and labelling phases. One move per cycle, write the receipt, force the lesson on miss.

• CMP-005: drmg compass act — link to drmg plan task + write receipt + refuse multi-move within same cycle id
• CMP-006: drmg compass observe — record observed gauge delta + force --lesson annotation when prediction missed

Phase 4: Mirror (1 sprint)​

The weekly review. Cycles, alignment ratios, drift flag.

• CMP-007: drmg compass week — print all cycles with gut_aligned ratio, gauge_moved ratio, override count, ordered by impact
• CMP-008: Drift detection (3+ override streak + gauge did not move → red flag in mirror)

Phase 5: Settlement (deferred)​

drmg compass tokenize — settle a verified cycle on-chain. Sui/Walrus bridge is out of scope. Future PRD.

Feature IDs​

0/8 features at L2+. 8 at L0. (Phase 5 deferred — Sui/Walrus bridge is its own PRD.)

Data Model​

CompassCycle (cycle_id)
  ├── opened_at
  ├── phase_inputs
  │     ├── outer_clock { oom_stage, trend_deltas[] }
  │     ├── inner_clock { tight_five_position, archetype, energy }
  │     └── gut { tag: stop|yield|go, vibe }
  ├── options_considered[]
  │     └── { move, predicted_delta, reversibility, cost, gut_tag }
  ├── move_taken
  ├── plan_task_id              ← link to drmg plan task
  ├── reversibility             ← door-1 | door-2
  ├── values_gauge_predicted    ← up | flat | down
  ├── values_gauge_observed     ← null until compass observe
  ├── gut_aligned               ← computed at observe
  ├── gut_override_reason       ← required if act with gut=stop
  ├── lesson                    ← required if observe ≠ predicted
  └── receipt_path              ← .invisible/context/receipts/...md

The cycle id is the spine. Every command reads or writes one cycle. Multi-move chaining is blocked because the second act call within the same cycle id refuses.

Acceptance Protocol​

Issues​

None yet — new PRD.

Progress​

Engineering spec, build contract, VV stories, and flow diagrams are held privately and loaded into the planning DB via drmg plan when this PRD graduates to Live. The seven-phase compass algorithm is the synthesis source.

Scorecard​

Priority Score: 1125 (Pain 5 x Demand 3 x Edge 5 x Trend 5 x Conversion 3)

Blocked by: nothing. All Phase 1 dependencies (drmg CLI, Hermes web_search, plan-cli, receipt schema v1.1) are live.

Kill signals:

• 90 days, zero observed cycles → kill, the algorithm did not match real session flow
• 30+ observed cycles but gauge_moved_ratio < 0.3 → kill, the compass is pointing at the wrong values gauge
• SCARF gate creates so much friction that Wik bypasses compass open more than 50% of sessions → simplify the gate or kill the SCARF check

Blocks: every cycle-bound improvement loop. Compass is the meta-loop that all other inner-loop PRDs run inside.

Context​

• CLI Platform — INSTRUMENT role, L4, the binary this PRD extends with a new namespace
• Decision Trace Logging CLI — GAUGE role, sibling instrument that already writes traces
• Agent receipt schema — the structured format every cycle writes to
• Recognize Signs — the reception layer the SCARF gate enforces
• Situational Wisdom — the two-clock orientation pattern
• VVFL — the loop scheduler that calls the compass
• AI research tool — outer clock data source for OOM stage and trend deltas

Questions​

If the gut never learns, the compass is just a journal.

• When does manual gut tagging become a trained classifier — after 30 receipts, or never (gut stays human)?
• If the SCARF gate creates more friction than the value of RECEIVE, which one wins — the gate or the cycle?
• When compass week flags drift, who is the audience — Wik, the agent, or both? What action does the flag trigger?
• Should the compass refuse to open if the previous cycle has no observation, or carry the leak forward into the next cycle's mirror?
• Is one move per cycle the right constraint, or does it need a --bundle flag for tightly-coupled moves?