| name | sitrep |
| description | Read-only dashboard projecting lifecycle triggers into entities and next actions. Use mid-flow via /sitrep or /status. |
| triggers | ["sitrep","siterep","status"] |
| output_template | hud |
/sitrep — Freestyle Dashboard (Stream Projection)
/sitrep is a PROJECTION, not a writer. It reads the lifecycle trigger stream and renders current state. Never mutates. Never archaeology.
Source of truth: .lev/pm/workstreams/*/trace/*.yaml (lifecycle_trigger.v1)
Schema ref: .lev/pm/proposals/20260415-lifecycle-trigger-envelope.yaml
When to Use
- Mid-flow: "what's happening across my queue right now?"
- After a /capture or /close tick: "did everything land?"
- Before /work: "what should I pick up?"
- After long thinking: "what's in memory vs on disk?"
Distinct from /capture (which WRITES and sweeps) — /sitrep only READS.
Protocol
1. Read the stream (cheap, no archaeology)
Default scope: the active workstream's trace/ dir.
→ .lev/pm/workstreams/<active-ws>/trace/*.yaml
→ Read only the tail (last N triggers, default 20)
→ Parse cursor + outputs.items + outputs.gates + metrics
Wider scope (on request):
→ /sitrep --all reads all workstreams
→ /sitrep --ws <id> targets one ws
Do NOT read: handoffs/ (archaeology), workstream.yaml full file (archive policy), git log (not the source of truth for state). These are fallbacks only when no trigger stream exists yet.
2. Project the view
Render 5 sections from the parsed triggers:
A. Exec brief (current result — always present)
Mirrors /capture's "Exec Menu" shape so every verb ends the same way:
## /sitrep — {ws-id} — {timestamp}
### Current result
- Last verb: {cursor.last_verb} at {cursor.last_at} (commit {cursor.last_commit})
- Gates: {N_passed}/{N_total} passed · drift={value} · fidelity_avg={value}
- Sealed: {true|false} (true if cursor.next_verb == null)
B. Active entities (what's moving)
From outputs.items across recent triggers, grouped by state:
| Symbol | State | Source |
|---|
| ⚡ | executing | last trigger was /exec, cursor.next_verb was set |
| 📥 | capturing | last trigger was /capture |
| 🔍 | expanding | last trigger verb was expand emote |
| 🧹 | collapsing | last trigger verb was collapse emote |
| ⏸️ | blocked | cursor.blocker != null |
| ❓ | question | last trigger was question emote |
| ✅ | done this session | cursor.next_verb == null (sealed) |
Show max 5 items. Rest go to queue count.
C. Memory state (freestyle — the user's feedback)
What's in-memory vs on-disk. From the most recent /capture trigger's outputs.items (after /close absorbs /capture, this is just the latest trigger's items).
### Memory state
- In-memory: {count} items below fidelity gate (0.8)
- Captured: {count} items shipped to disk
- Blocked: {count} items awaiting decision
Fidelity comes from metrics.fidelity per trigger. If the value is missing OR the trigger has outputs.items != [] on a /close, flag as ⚠ theater — the Step 0 gate was bypassed.
D. Next actions (from cursor.next_input + recommend)
### Next (from tail trigger)
1. {cursor.next_verb} {cursor.next_input}
2+. {recommend[*]} where verdict != monitor
Matches /capture's Exec Menu pattern — max 5 items, rest queued.
E. Decisions Needed (if any blockers)
### Decisions Needed ({count})
1. {entity}: {blocker} — since {cursor.last_at}
When ALL items blocked: auto-suggest /interview or /expand://<entity> for the top one.
3. Inline emote dispatch (new — per user feedback)
Some actions are inline-only. /sitrep supports shortcuts on entities in the rendered view:
/sitrep then: expand 2 → fire expand://<item-2-ref> (no full verb ceremony)
/sitrep then: collapse 4,5,6 → fire collapse:// on items 4,5,6 in batch
/sitrep then: admit 3 → fire admission:// on item 3
Inline emotes run a flow (flow://lifecycle/) but DON'T require /close's full ceremony. They emit a trigger each. The stream still grows. The ceremony scales with stakes.
Heuristic: inline for emote verbs (expand, collapse, admit, question). Full ceremony for lifecycle verbs (close, propose, exec, handoff).
Rules
- Projection only. /sitrep never writes, never commits, never pushes.
- Cheap read. Tail the stream. Don't re-compute from git or handoffs.
- Bucketed. 5 active, 5 next actions, rest as counts.
- Theater check. Any /close trigger with items != [] gets a ⚠ flag. Non-negotiable.
- Fallback. If no trace/ dir exists yet, fall back to the old TaskList + workstream.yaml scan — but print a hint:
"no trigger stream — run /close to start the stream".
- Graph footer. Always end with HUD line from
~/.claude/skills/_shared/graph-footer.md.
Exec Menu (same pattern as /capture — this is the convergence)
Every read-only verb ends with a concrete exec menu:
### Exec Menu (N of M)
1. [item] → verb: /exec flow: ralph effort: S unblocks: #3,#7
2. [item] → verb: /propose effort: XS unblocks: #5
...
Queue: N more items (bucketed by priority)
Inline shortcuts:
expand <n> collapse <n> admit <n>
Relationship to /capture
| /capture | /sitrep |
|---|
| Writes triggers | Reads triggers |
| Mutates state | Projects state |
| Absorbs in-memory items to disk | Surfaces what's on disk |
| Ends with Exec Menu | Ends with Exec Menu (same shape) |
| Fidelity scoring (inline) | Fidelity surfacing (from stream) |
After /close absorbs /capture, /sitrep becomes the primary read interface to lifecycle state. /capture becomes the fast-write path.
Aliases
/sitrep = full dashboard (canonical)/siterep = legacy alias/status = same/sitrep --brief = exec brief + next 3 actions only (3 lines)/sitrep --all = all workstreams, not just active/sitrep --ws <id> = target one workstream
Related
/capture — mutation path (writes trigger with sweep)/close — sealing path (writes close trigger, absorbs capture)/work — router (may call /sitrep before routing)- Schema:
.lev/pm/proposals/20260415-lifecycle-trigger-envelope.yaml
- Stream dir:
.lev/pm/workstreams/*/triggers/
