# Watcher View (/docs/views/watcher)





The **Watcher** manages the leaf between the Strategist's re-frames. It is the pod's fast reflex:
low-latency perception feeding armed-plan control and escalation, working in seconds at pennies a
call. It does not author theses. It runs the plans it was handed, and when it reaches the edge of
its own certainty it does **not** guess — it escalates.

## The seat [#the-seat]

**Task.** Watch the inventory it holds; act within the plans it was given; and, at the edge of
its certainty, escalate via a Wake — "call the Strategist" — rather than improvise. Escalation
costs a frontier call; an unbounded action costs the book. The Watcher is built to prefer the
former.

**Timescale.** Seconds, at pennies a call. Where the Strategist reads a wide framing screen a few
times a day, the Watcher reads a narrow, cheap screen many times — so its View is tuned to answer
one question fast, not to re-derive the whole session.

**When it fires.** On a **wake** — a level cross, a plan trigger, a Trigger's summons, a
deadline. The Watcher's View is a wake View; it is the seat the runtime hands the frame to when
something moves between framings.

## The View [#the-view]

```kestrel
VIEW watcher-wake
  delta
  tape
  levels
  chain
  acting
```

The `delta` pane leads, and that lead is the whole point. The cheapest possible wake states
*what moved* since the last look — spot, high-of-day, VWAP, each with its prior value and its
change — because that is the Watcher's core question. Only then does the screen widen: `tape` for
the shape of the move, `levels` for where it sits in the day's geometry, `chain` for what the
held options are now worth, and `acting` for the kernel's ground truth — the position, the
resting order, the fill since last, the plan being managed.

A phase-default wake never shows `delta`; a View has to name it. That is deliberate: the delta
lead is a property of the Watcher's task, so it lives in the Watcher's View rather than in the
default every seat would inherit. With `seatViews: "founder"` set, the Watcher on a wake resolves
to this View; an authored View still wins over it, and with no seat the wake falls back to the
phase default.

## The screen [#the-screen]

<PerceptScreen title="watcher-wake · wake 3" caption="renderWakeDelta · kestrel-renderer/8 · byte-real" text="watcherWake" />

## Open vs wake [#open-vs-wake]

This is a **wake** screen, and it reads as one. It opens with the safety kernel — here showing a
held position, a live resting sell floored at intrinsic, and the remaining budget — then leads its
market panes with the `delta` block, because on a wake the first thing worth knowing is what
changed. Contrast the [Strategist View](/docs/views/strategist), which orients from scratch at the
open and has no delta to lead with. Same book, different question, different screen.

A pane's usefulness is **role-dependent**: a read that would be noise for the Strategist — whose
authored exit already prices a given move — can be exactly what the Watcher needs to manage a
position it is holding through that move. This is why the engine keys perception on the seat and
never pools one screen's lessons onto another. The panes here are the **equity-index options**
variant; the same reflex manages other markets through the same View grammar as those variants
ship (see [the variant axis](/docs/views#the-variant-axis)).