Sitrep

---
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`

## Entity Reconciliation

After authorized material progress, reconcile touched and causally affected
artifacts before routing, handoff, or final response. Track entity ref,
island/provider locator (a path for file storage), basis/evidence, and the
reason/action due. Update through the verified owning CLI/adapter; use a
write-authorized skill fallback only when that operation is unavailable.
Record updated, no_change(reason), or blocked(reason), preserving unresolved
refs. Reading or mentioning a path alone creates no update obligation.
Read-only work reports pending changes only. Reminders grant no write authority;
task status stays with the bound tracker. Update only artifacts whose content
or evidence changed; do not rewrite every referenced document.

## 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/<emote>) 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/`