tickmarkr 2.1.1 → 2.1.3

package/skills/tickmarkr-overseer/SKILL.md

@@ -35,6 +35,16 @@ through brief lineage. **An executor choice nobody made is still an executor cho
    status, and either ADOPT the
    existing orchestrator (updated brief, re-armed watchers) or, if the old hierarchy is dead, archive the
    stale brief and build fresh.
+   ⚠ **VERIFY EVERY INHERITED WATCHER FROM THE PROCESS TABLE BEFORE YOU TRUST IT — re-arming your own
+   watchers is NOT enough, and a seat told only to re-arm its own is told the wrong thing.** An inherited
+   *"watcher armed"* line is a claim, not a watcher: it is a report by a seat that no longer exists, which
+   is strictly WEAKER than the live seat's report rule 11 already forbids trusting — and it reads as
+   settled fact. So at every adopt, walk the predecessor's watchers by class — **journal watchers,
+   artifact watchers, dialog watchers and beat loops, which is the closed set a session owns** — probe
+   each from the process table yourself (`pgrep -f <token>`, discriminated per rule 11), and re-arm every
+   one the table does not show. Earned 2026-08-25 (OBS-622): a handoff recorded *"artifact watcher armed"*
+   over two live consult verdicts; at adopt the only `watch-artifacts.sh` on the machine belonged to a
+   different repository, and nothing had been watching either file.
    **An adopted seat ANNOUNCES itself, in the same act as re-arming:** tell the adopted orchestrator the
    fresh seat is live (verified send: probe token + read-back). Through the gap its view of your tier read
    STALE, and a tier that believes it is unsupervised escalates into a file nobody is reading. Earned
@@ -93,7 +103,7 @@ through brief lineage. **An executor choice nobody made is still an executor cho
    fraction (`ORCH · v1.19 4/5`, updated on every task-done); tickmarkr opens ONE TAB PER TASK, labelled
    with the task id and holding that task's worker plus its judge/review/consult panes (tickmarkr
    updates it). Never long context strings or ✓-chains.
-2. **Orchestrator**: Launch the orchestrator with your agent host. Spawning on current herdr is two-step — the one-shot `agent start --cwd` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138): first create the pane with `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` and parse `result.root_pane.pane_id` from its JSON, then start the agent in it. For Claude Code, use `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions` (append `--model <m>` after the `--` if the operator has a policy). For Codex, use `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions`, and a read-only codex consultant may use `--sandbox read-only`.
+2. **Orchestrator**: Launch the orchestrator with your agent host. Spawning on current herdr is two-step — the one-shot `agent start --cwd` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138): first create the pane with `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` and parse `result.root_pane.pane_id` from its JSON, then start the agent in it. For Claude Code, use `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions` (append `--model <m>` after the `--` if the operator has a policy). For Codex, use `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions --settings '{"promptSuggestionEnabled":false}'`, and a read-only codex consultant may use `--sandbox read-only`. **That `--settings` pair is not cosmetic and it is not optional:** claude-code's AUTOSUGGEST renders context-plausible ghost text into an idle seat's prompt line that is BYTE-IDENTICAL to a typed draft in text-format reads (OBS-482), so a supervising tier cannot tell a seat's own unsent work from a rendering artifact without `agent read --format ansi`. Turning the suggester off at spawn removes the ambiguity at its source instead of paying for the discrimination at every read. Verified against the shipped binary: `claude --settings '{"promptSuggestionEnabled":false}' -p …` exits 0 with a real response, and the key appears in the binary's own settings schema. **For kimi, pass `-y`** (`herdr agent start <name> --kind kimi --pane <id> -- -y`) — the adapter already launches its own workers that way (`src/adapters/kimi.ts:204`), and a kimi seat spawned without it sits on an approval prompt having done nothing. **Herdr cannot see that state**: it reports a kimi pane as `agent_status: working` with `screen_detection_skipped: true` while the prompt is up, so the BLOCKED-STATE watcher below is blind on this vendor and the spawn flag is the ONLY control. Every vendor you spawn needs its auto-approve form named here; a vendor absent from this list is a seat that will hang.
 3. **Standing instructions travel as a brief FILE, never as pane text** — PTY input truncates at ~1024B and a
    truncated brief silently drops policy. Write the full brief to `<repo>/.tickmarkr/overseer/ORCH-BRIEF.md`
    (inside the tickmarkr state dir — already self-gitignored, no exclude step needed), then send one line:
@@ -245,6 +255,17 @@ is a lossy summary nobody trusts while a clean session re-oriented from disk-ver
 **Do the same for yourself before you are forced to**: write the handoff while your judgment is still
 good, not after. If your own context cannot be read by the watcher, say so to the operator and ask for the
 number — an unmeasured budget is not a small budget.
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-context.sh orchestrator <orchestrator-agent-or-pane> 60 75 <handoff-file>
+.claude/skills/tickmarkr-overseer/scripts/watch-context.sh overseer <overseer-agent-or-pane> 60 75 <handoff-file>
+```
+
+The first argument chooses the closed per-seat tier (`orchestrator-context` or `overseer-context`),
+and every beat names the second argument as that tier's seat. The watcher beats only after reading a
+rendered percentage, keeps beating on the supervision cadence even when its requested poll is slower,
+continues past WARN to ACT, and records a stand-down on each controlled exit. A killed watcher alone
+leaves its last beat to age into `STALE`.
 **Every handoff's re-arm list ends with the announce step from Setup 0** — inform the surviving
 orchestrator the fresh seat is live — or the next seat re-arms silently beside a tier that still
 believes it is alone.
@@ -396,7 +417,7 @@ they are left implicit:
   authors** — the seat's own draft, an operator, another agent's `agent send` (writes WITHOUT Enter),
   and claude-code's AUTOSUGGEST, which renders context-plausible ghost text BYTE-IDENTICAL to a typed
   draft in text-format reads (OBS-482). The check is mechanical and only works at observation time:
-  `agent read --format ansi` — dim/grey SGR around the text = autosuggest ghost, NOT input. Measured
+  `agent read --format ansi --source visible` — dim/grey SGR (`ESC[2m`) around the text = autosuggest ghost, NOT input. ⚠ **`--source` is load-bearing and its natural choice is the wrong one.** `--source detection` is the plain-text buffer used for agent detection: it strips ANSI *entirely*, so `--format ansi --source detection` returns ZERO escape sequences and every string reads as un-styled — i.e. as real typed input. Measured 2026-08-26 on a live orchestrator: `detection` returned 0 escapes and the ghost read as a genuine unsubmitted draft; `visible` returned 100 escapes and the same line came back `ESC[0mESC[2m…`, dim, ghost. **A probe that cannot render the evidence cannot fail**, so check the capture contains escapes at all before believing its answer — that is rule 11 aimed at your own instrument. Measured
   2026-08-17 (D-206): an unattributed instruction was found in an orchestrator's box, superseded
   defensively, and its origin stayed UNRESOLVED — the one probe that discriminates was not taken while
   the text still sat there. An origin question you can close in ten seconds at the pane becomes
@@ -414,17 +435,24 @@ The beat is one shipped command and the loop is yours, run from the repo root as
 `run_in_background` Bash call:
 
 ```bash
-cd <repo> && while :; do tickmarkr beat overseer; sleep 10; done   # 10s = SUPERVISION_BEAT_MS
-tickmarkr beat overseer --stand-down                               # at stand-down, in the same act
+cd <repo> && while :; do tickmarkr beat overseer --seat <overseer-agent-or-pane>; sleep 10; done
+tickmarkr beat overseer --seat <overseer-agent-or-pane> --stand-down  # after stopping that loop
 ```
 
+The pre-2.1.3 forms `while :; do tickmarkr beat overseer; sleep 10; done` and
+`tickmarkr beat overseer --stand-down` are preserved here only as migration warnings: both are now
+rejected because neither declares which seat the tier speaks for. Do not copy or run them.
+
 One beat per invocation, deliberately: the loop is what proves the seat is alive, so a command that
 kept beating on its own would keep reporting a dead seat as healthy. Stop the loop — or die — and the
 tier ages to `STALE` (never `ABSENT`) within six beats, which is the state that says *armed, then lost*.
 Stand down explicitly when you hand off, or a deliberate exit reads as a death. Same rule as rule 29
 below, now with a conventional path the other tier already reads: `tickmarkr status` shows it.
 
-⚠ **THE LOOP ABOVE BINDS TO A PROCESS, NOT TO A SEAT — and that is a defect this skill shipped.**
+⚠ **THE LOOP ABOVE NAMES A SEAT BUT STILL BINDS ITS LIFETIME TO A PROCESS — and that distinction is
+load-bearing.** The command refuses an anonymous beat, and `status` renders the declared seat beside
+the tier state; a legacy tier+pid+instant record cannot be attributed and reads `UNREADABLE`, never
+`ARMED`. Naming the seat does not make the shell loop stop when that seat leaves.
 The beat keeps running while its *session* lives, so a loop started by a seat that has since been
 cleared, re-briefed, or replaced keeps beating that tier's file forever. Measured 2026-08-24
 (OBS-583): a **2d20h** orphan loop from a predecessor seat held `orchestrator ARMED` through a
@@ -434,13 +462,13 @@ one owned by an unrelated session. So:
 - **At every adopt, clear, or re-brief, sweep for pre-existing loops on YOUR tier before arming one**
   (`pgrep -f "tickmarkr beat <tier>"`), trace each to its parent session, and kill the **loop only**
   — never the parent — then verify the parent survived.
-- **`ARMED` is a claim about a process, not about a seat.** Before trusting any tier's `ARMED`, ask
-  whose session owns the beater; a tier can be armed and seatless, which is *worse* than ABSENT
-  because it reads as coverage (rule 11's outliving-its-trigger failure, in beat form).
+- **`ARMED (<seat>)` is an attributable claim, not proof that the named seat is still alive.** Before
+  trusting it, ask whose session owns the beater; an orphan loop can keep naming a departed seat
+  (rule 11's outliving-its-trigger failure, in beat form).
 - Stand-down must kill the loop **and** run `--stand-down`; the second without the first is undone
   by the next tick.
-The product fix (a seat-bound or sentinel-terminated beat, armed and stood down in one act) is
-queued; until it ships, this sweep is the guard.
+The remaining product fix (a sentinel-terminated beat, armed and stood down in one act) is queued;
+until it ships, this sweep is the guard.
 
 Arm the bundled watcher as its OWN Bash call with `run_in_background` — chaining it after other commands
 with `&` orphans it from the wake chain. It prints one wake reason and exits; re-arm after every wake.
@@ -489,10 +517,15 @@ Two keys that do not lie, in order of strength:
 will keep producing this stall, and a sweeper that has been running since 04:40 is evidence the gap was
 visible and got swept instead of fixed.
 
-**Every seat you spawn gets THREE watchers armed in the SAME call that spawns it — ARTIFACT,
-BLOCKED-STATE, and PENDING-INPUT.** Each is blind to what the others catch: the artifact watcher cannot see
-a stall, the blocked watcher cannot see a finish, and neither can see a seat sitting **idle with
-unsubmitted text in its own prompt**.
+**Every seat you spawn gets FOUR watchers armed in the SAME call that spawns it — ARTIFACT,
+BLOCKED-STATE, PENDING-INPUT, and CONTEXT.** Each is blind to what the others catch: the artifact watcher cannot
+see a stall, the blocked watcher cannot see a finish, neither can see a seat sitting **idle with
+unsubmitted text in its own prompt**, and none of them can see a seat running out of context.
+**CONTEXT was mandated in prose above and omitted from this list, so it shipped in 2.1.2 and was never armed
+once** — an overseer ran nine hours at 86% unable to read its own number. Arm
+`scripts/watch-context.sh` here, by name, like the other three. Note also that BLOCKED-STATE relies on
+Herdr's `agent_status`, which is unreliable for vendors whose screen detection is skipped (kimi) — for
+those, the spawn-time auto-approve flag is the control, not this watcher.
 
 ```bash
 .claude/skills/tickmarkr-overseer/scripts/watch-pending-input.sh <agent|pane> [poll-s] [cap-s] [confirm-polls]
@@ -550,6 +583,15 @@ that hang is byte-identical to a seat still working. The script prints each unfi
 last line on every timeout heartbeat — read it there, and when in doubt `tail -1` the artifact, never
 the transcript's claim about it.
 
+**An ABSENT artifact ALONE cannot discriminate a working producer from a dead watcher.** A producer still
+working and a watcher that died with its seat write byte-identical evidence — nothing — so a missing file
+is one signal carrying at least three meanings (still working, watcher dead, producer dead), and it is
+**never** evidence that the watcher is still waiting. Reading it that way infers an instrument's liveness
+from the silence it was built to sit through. Settle it with two probes that do not share a failure:
+the watcher from the process table, the producer from its pane or seat status. Measured 2026-08-25
+(OBS-622): both consultants were live and had written nothing, so the artifact side could not see that
+nothing was watching them.
+
 **Arm it in the same call as the spawn, not the next one.** A watcher armed "after I finish this step"
 leaves a gap exactly as wide as however long you stay busy, and you will be busy — you just spawned work.
 **Measured 2026-08-06 (OBS-369): two consult verdicts, 30KB and 12.8KB, sat COMPLETE with their markers
@@ -677,6 +719,50 @@ orchestrator turn boundary.
    fix helps ONE operator and leaves every other user with the defect. If an overlay is the interim, it
    says so in writing and names its removal condition.
 
+8. **A SHIPPED VERSION IS NOT DONE UNTIL THE STATE IT LEAVES BEHIND IS CLEAN.** Publishing is the loud
+   half; the quiet half is that the NEXT seat inherits either the truth or a confident lie. Run this
+   before you stand down from any release — **operator instruction, 2026-08-25: *"overseer should always
+   leave clean state after a version is shipped"***. Every line below is a defect that actually happened
+   on the release that produced this rule.
+
+   - **REWRITE THE MEMORY INDEX FIRST, and read it back.** Minutes after `2.1.1` hit npm, the index line
+     a fresh session loads still read *"⛔ 2.1.1 CANNOT ship from run …2011"* — true when written, and by
+     then the exact opposite of the truth. **The index is what everyone loads and the body is what nobody
+     opens** (Evidence rule 25), so a stale index is not a cosmetic lag; it is the most-read wrong
+     sentence in the project. State what shipped, what did NOT, and the first three things the next seat
+     should do.
+   - **VERIFY EVERY ID THE CODE NOW CITES ACTUALLY EXISTS.** A release lands source comments citing
+     ledger ids. One of that release's entries was written by a heredoc in a command that then timed out
+     — the entry survived, but nothing had checked. `grep -c '^## OBS-<id>'` for each id the diff
+     introduced. A citation pointing at nothing is the defect the ledger itself files (OBS-604), shipped
+     into `src/`.
+   - **KILL THE BEAT LOOP *AND* RUN `--stand-down`.** Either alone is worse than neither: the loop
+     without the stand-down re-arms a tier you retired within 10s, and the stand-down without the loop
+     is undone by the next tick. Verify `status` reads `DISARMED` — which means *handed off*, distinct
+     from `STALE` (armed then died) and `ABSENT` (never armed).
+   - **RECORD YOUR WATCHERS AS DYING WITH THIS SESSION — never as "armed".** A written stand-down or
+     handoff may NOT carry the bare wording *"watcher armed"* for anything this seat owns: that form
+     states an act and lets the successor read a fact, and it survived into a handoff exactly once before
+     costing two unwatched consult verdicts (OBS-622). The admissible form names the lifetime and the
+     work it leaves the successor — *"watchers armed by this session (journal, artifact, dialog, beat);
+     they die with it — re-arm on adopt"* — and, per rule 11, says which tier's watchers were NOT armed.
+     A detached watcher is the one exception and must be labelled as such, with its heartbeat file, since
+     it outlives the seat instead.
+   - **SWEEP THE PANES THE RUN LEFT.** A daemon killed by a signal flushes its journal and releases its
+     lock but **does not clean up its worker panes or its board**. Two orphaned worker panes and a dead
+     board pane sat in the operator's tab bar until he screenshotted them. Verify each is inert first
+     (no agent, nothing running in its worktree) and confirm the WORK is on its branch — then close.
+     Emptied tabs disappear on their own.
+   - **CORRECT EVERY TAB LABEL.** `ORCH · 2.1.1 T1 regate` was still on screen hours after that regate
+     ended. Tab labels are how the operator reads fleet state; a stale one is a false status report.
+   - **LEAVE THE TREE CLEAN AND SAY WHAT IS UNMERGED.** Name the branches that hold real but ungated
+     work, so the next seat neither discards nor trusts them. *"Zero merges, T1/T3 branches ungated, T5
+     never dispatched"* is a handoff; *"the run ended"* is not.
+
+   ⚠ **The half of this that is NOT operator discipline must be QUEUED, not absorbed:** a daemon that
+   orphans its panes on SIGTERM is a PRODUCT defect and belongs in `src/**`. Sweeping by hand every time
+   is the local remedy, and per rule 7 it says so in writing and names its removal condition.
+
 ---
 
 ## Briefing a seat to audit a security-shaped check — phrasing matters
@@ -787,6 +873,14 @@ twice.** They are mission-independent on purpose: nothing here names a task, a l
     owns it** — "watchers alive" is the one claim a seat cannot verify about itself. Measured 2026-08-06:
     an orchestrator sat `idle` through three merges and two dispatches with no journal watcher in the
     process table, while its own last report read *"daemon, board, sweeper, watcher all alive"* (OBS-366).
+    **STATE THE LIFETIME, because an unstated one is read as the mission's: a session-scoped watcher DIES
+    WITH THE SEAT THAT ARMED IT.** Every watcher a seat arms — journal, artifact, dialog, beat loop — is
+    session-scoped unless it was deliberately detached (`ppid 1`, the heartbeat form below), so `/clear`,
+    a crash, an adopt or a stand-down ends it, and **a handoff is the one moment the arming seat stops
+    existing** — which is exactly when its watchers are most likely to be believed. The inverse failure is
+    the same root read the other way: a DETACHED loop outlives its seat and holds a tier `ARMED` with
+    nobody home (OBS-583). Neither direction may be assumed; the lifetime is a property of how the watcher
+    was launched, and it belongs in writing next to every claim that one is armed.
     **And the process-table probe has a standard idiom that DEFEATS it, so the rule above needs one more
     line to be usable.** Never probe for a watcher with `ps … | grep <token> | grep -v grep`: a poll-grep
     watcher carries the word `grep` in its own argv, so the filter whose job is removing the *probing* grep

package/skills/tickmarkr-overseer/scripts/watch-context.sh

@@ -14,26 +14,66 @@
 # handoff is stale, the seat is holding state that a clear would destroy, and the correct move is to wake
 # a supervisor — never to clear and hope.
 #
-# usage: watch-context.sh <agent|pane> <warn-pct> <act-pct> [handoff-file] [poll-s] [cap-s]
+# THIS WATCHER IS SUPERVISED, and the tier is PER SEAT: `<role>-context`, one per supervising seat, so a
+# live overseer watcher can never make a dead orchestrator one read as covered. Every beat declares the
+# seat it watches (`--seat`), because a tier that is armed and seatless reads as coverage, which is worse
+# than absent. Four rules the shipped version broke, each of which made the tier lie:
+#   1. BEAT ON THE SUPERVISION CADENCE, NOT ON THE POLL. Beats gap by TICK (below), never by POLL, so a
+#      poll interval above the supervision beat interval cannot leave the tier stale half of every cycle.
+#   2. BEAT ONLY AFTER A SUCCESSFUL READ. A watcher that cannot see its seat's percentage is not
+#      watching it; beating anyway reports coverage it is not providing, and the tier must age out.
+#   3. WARN DOES NOT EXIT. Warn precedes act, so exiting at warn meant the act was never reached and the
+#      last beat aged into a permanent stale — gradual growth never reached the auto-clear path at all.
+#   4. EVERY TERMINAL EXIT STANDS THE TIER DOWN, so a watcher that finished reads DISARMED, not dead.
+#      Only a killed watcher reads STALE, which is exactly what STALE means.
+#
+# usage: watch-context.sh <orchestrator|overseer> <agent|pane> <warn-pct> <act-pct> [handoff-file] [poll-s] [cap-s]
 #   TKR_AUTO_CLEAR=1   at act-pct WITH a fresh handoff, send /clear and re-brief instead of waking.
 #   TKR_REBRIEF=<path> the file the re-briefed seat is told to read (defaults to the handoff).
 #   TKR_HANDOFF_MAX_AGE_S  how fresh "fresh" is (default 900).
+#   TKR_CLEAR_SETTLE_S     seconds to let a cleared seat settle before the re-brief (default 6).
 
 set -u
-TARGET="${1:?agent name or pane id required}"
-WARN="${2:-60}"
-ACT="${3:-75}"
-HANDOFF="${4:-}"
-POLL="${5:-120}"
-CAP="${6:-28800}"
+ROLE="${1:?supervising seat role required: orchestrator|overseer}"
+TARGET="${2:?agent name or pane id required}"
+WARN="${3:-60}"
+ACT="${4:-75}"
+HANDOFF="${5:-}"
+POLL="${6:-120}"
+CAP="${7:-28800}"
 MAXAGE="${TKR_HANDOFF_MAX_AGE_S:-900}"
 REBRIEF="${TKR_REBRIEF:-$HANDOFF}"
+SETTLE="${TKR_CLEAR_SETTLE_S:-6}"
+
+case "$ROLE" in
+  orchestrator|overseer) TIER="${ROLE}-context" ;;
+  *) echo "watch-context.sh: unknown seat role '$ROLE' — expected orchestrator or overseer" >&2; exit 64 ;;
+esac
+
+# The supervision beat interval (SUPERVISION_BEAT_MS = 10s). The loop ticks at the beat cadence or the
+# caller's poll, whichever is SHORTER: a beat may only follow a successful read (rule 2), so the read
+# cadence is the floor on the beat cadence, and the tier's freshness is never the caller's to widen.
+BEAT_EVERY=5
+TICK=$(( POLL < BEAT_EVERY ? POLL : BEAT_EVERY ))
+[ "$TICK" -ge 1 ] 2>/dev/null || TICK=1   # a zero or junk poll would spin, not watch
+SEAT="$TARGET"
+
+beat()      { tickmarkr beat "$TIER" --seat "$SEAT" >/dev/null 2>&1; }
+stand_down() { tickmarkr beat "$TIER" --stand-down --seat "$SEAT" >/dev/null 2>&1; }
+# EVERY terminal exit — act, unsafe-act, cap — leaves through here, so none of them can forget to
+# record the hand-off. A killed watcher never runs it, which is the one case that must read STALE.
+trap stand_down EXIT
 
-# The seat's own rendered truth. Anchor on the model marker so a percentage elsewhere on screen — a
-# progress figure, a coverage number — cannot be mistaken for the context gauge.
+# The seat's own rendered truth. Prefer a line carrying a context marker so a percentage elsewhere on
+# screen cannot be mistaken for the gauge — but NEVER require one: the ✳ marker the shipped version
+# anchored on is rendered by a single vendor, so every other seat read empty, beat anyway and slept to
+# its cap while its tier claimed coverage. The last percentage in the statusline window is the fallback.
 context_pct() {
-  herdr agent read "$TARGET" --source visible --lines 8 2>/dev/null \
-    | grep '✳' | tail -1 | grep -oE '[0-9]+%' | tail -1 | tr -d '%'
+  local screen marked
+  screen=$(herdr agent read "$TARGET" --source visible --lines 8 2>/dev/null) || return 1
+  marked=$(printf '%s\n' "$screen" | grep -iE '✳|context' | grep -oE '[0-9]+%' | tail -1 | tr -d '%')
+  [ -n "$marked" ] && { printf '%s\n' "$marked"; return 0; }
+  printf '%s\n' "$screen" | grep -oE '[0-9]+%' | tail -1 | tr -d '%'
 }
 
 handoff_fresh() {
@@ -46,41 +86,50 @@ handoff_fresh() {
   [ "$age" -le "$MAXAGE" ]
 }
 
+act_on() {
+  local P="$1"
+  if handoff_fresh; then
+    if [ "${TKR_AUTO_CLEAR:-0}" = "1" ]; then
+      herdr agent prompt "$TARGET" "/clear" >/dev/null 2>&1
+      sleep "$SETTLE"
+      herdr agent prompt "$TARGET" "Read ${REBRIEF} and continue exactly where it says. Your context was cleared at ${P}% against that handoff; it is current as of $(date '+%H:%M'). Do not reconstruct from memory — everything you need is on disk." >/dev/null 2>&1
+      echo "CONTEXT_CLEARED $TARGET at ${P}% — handoff fresh, re-briefed from ${REBRIEF}"
+      exit 0
+    fi
+    echo "CONTEXT_ACT $TARGET ${P}% (>= ${ACT}) — handoff is FRESH, a clear is SAFE now"
+    echo "  herdr agent prompt $TARGET \"/clear\"  then re-brief from ${REBRIEF}"
+    exit 0
+  fi
+  echo "CONTEXT_ACT_UNSAFE $TARGET ${P}% (>= ${ACT}) — NO FRESH HANDOFF (${HANDOFF:-none})"
+  echo "  the seat is holding state that exists only in its head; a clear would destroy it"
+  echo "  make it write the handoff FIRST, then clear"
+  exit 0
+}
+
 warned=0
 elapsed=0
 while [ "$elapsed" -lt "$CAP" ]; do
   P=$(context_pct)
   if [ -z "$P" ]; then
-    sleep "$POLL"; elapsed=$((elapsed + POLL)); continue
+    # Rule 2: no reading, no beat. The tier ages to STALE and a supervisor comes looking, which is the
+    # truth about a watcher that cannot see the seat it was armed on.
+    sleep "$TICK"; elapsed=$((elapsed + TICK)); continue
   fi
+  beat
 
   if [ "$P" -ge "$ACT" ] 2>/dev/null; then
-    if handoff_fresh; then
-      if [ "${TKR_AUTO_CLEAR:-0}" = "1" ]; then
-        herdr agent prompt "$TARGET" "/clear" >/dev/null 2>&1
-        sleep 6
-        herdr agent prompt "$TARGET" "Read ${REBRIEF} and continue exactly where it says. Your context was cleared at ${P}% against that handoff; it is current as of $(date '+%H:%M'). Do not reconstruct from memory — everything you need is on disk." >/dev/null 2>&1
-        echo "CONTEXT_CLEARED $TARGET at ${P}% — handoff fresh, re-briefed from ${REBRIEF}"
-        exit 0
-      fi
-      echo "CONTEXT_ACT $TARGET ${P}% (>= ${ACT}) — handoff is FRESH, a clear is SAFE now"
-      echo "  herdr agent prompt $TARGET \"/clear\"  then re-brief from ${REBRIEF}"
-      exit 0
-    fi
-    echo "CONTEXT_ACT_UNSAFE $TARGET ${P}% (>= ${ACT}) — NO FRESH HANDOFF (${HANDOFF:-none})"
-    echo "  the seat is holding state that exists only in its head; a clear would destroy it"
-    echo "  make it write the handoff FIRST, then clear"
-    exit 0
+    act_on "$P"
   fi
 
   if [ "$P" -ge "$WARN" ] 2>/dev/null && [ "$warned" -eq 0 ]; then
+    # Rule 3: warn is a LINE, not an exit — the act is on the far side of it.
     warned=1
     echo "CONTEXT_WARN $TARGET ${P}% (>= ${WARN}) — write the handoff NOW, while judgement is still good"
+    echo "  re-brief target when it acts: ${REBRIEF:-none}"
     echo "  a handoff written at ${ACT}% is written by a seat already degraded; that is the wrong time"
-    exit 0
   fi
 
-  sleep "$POLL"; elapsed=$((elapsed + POLL))
+  sleep "$TICK"; elapsed=$((elapsed + TICK))
 done
 
 echo "WATCH_CAP_REACHED $TARGET context=$(context_pct)% — no threshold crossed in ${CAP}s"