From 7b84e325b0c44e98f7cae87f4f43623edc560987 Mon Sep 17 00:00:00 2001
From: giles knap <giles.knap@diamond.ac.uk>
Date: Sat, 10 Oct 2026 20:48:17 +0000
Subject: [PATCH] orchestrate: lint the state file from the hooks, script the
 Now/Done edits and the updated= marker

Adds a state.md lint run from the hooks (#108), rewrites the skill's
state-file rules to one row per item with dated Done lines (#110), has
goal.sh write the updated= marker (#111) and adds goal.sh now/land
helpers (#112). Stacked on #114.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AJKFfYT7qdSfhkZGj6syCo
---
 docs/how-to/use-orchestrate-mode.md           |  27 +++
 .../orchestrate/.claude-plugin/plugin.json    |   2 +-
 plugins/orchestrate/README.md                 |   3 +-
 plugins/orchestrate/scripts/goal.sh           |  92 ++++++++++-
 plugins/orchestrate/scripts/lib.sh            |  27 ++-
 plugins/orchestrate/scripts/session-start.sh  |   3 +-
 plugins/orchestrate/scripts/state-lint.sh     | 144 ++++++++++++++++
 plugins/orchestrate/scripts/stop.sh           |  21 ++-
 .../orchestrate/skills/orchestrate/SKILL.md   |  39 ++++-
 .../orchestrate/references/state-file.md      |   8 +-
 tests/fixtures/orchestrate/log-drifted.md     |   6 +
 tests/fixtures/orchestrate/state-drifted.md   |  44 +++++
 tests/orchestrate_plugin.sh                   | 154 +++++++++++++++++-
 13 files changed, 546 insertions(+), 24 deletions(-)
 create mode 100755 plugins/orchestrate/scripts/state-lint.sh
 create mode 100644 tests/fixtures/orchestrate/log-drifted.md
 create mode 100644 tests/fixtures/orchestrate/state-drifted.md

diff --git a/docs/how-to/use-orchestrate-mode.md b/docs/how-to/use-orchestrate-mode.md
index a58c7c33..7665af78 100644
--- a/docs/how-to/use-orchestrate-mode.md
+++ b/docs/how-to/use-orchestrate-mode.md
@@ -83,6 +83,33 @@ new session) and an agent listed under `Now` has no report yet, the
 orchestrator is told, so an agent lost to a crash is noticed rather than
 assumed to be running.
 
+## The state file
+
+The goal's `state.md` is written by the orchestrator only, in one format:
+
+- `## Now` lists what is running, one line per agent, and holds
+  `- (nothing running)` when idle.
+- `## Done` is the last section: one line per finished item, `- YYYY-MM-DD HH:MMZ <text>`,
+  appended in time order. Agent returns and review rounds go to the log.
+- `## Decided` holds rulings only, each ending `(<who>, YYYY-MM-DD)`.
+
+The orchestrator makes the most common edits with `goal.sh` rather than by
+hand: `goal.sh now '<entry>'` records a launch, `goal.sh land <label>
+['<done line>']` records a return (and, with a done line, a finished item;
+`land` drops the entry naming `-> <label> ->` or starting with `<label>`),
+and `goal.sh touch` sets the `updated=` time in the first line after any
+other edit. Nobody types that time.
+
+The Stop and SessionStart hooks run `scripts/state-lint.sh` on the file. It
+reports drift as `lint: <code>: <text>` lines: blank or empty `Now`, a `Now`
+agent whose report already exists, items still pending after they merged or
+closed, events or unattributed lines in `Decided`, `Done` out of order or
+too long, a file over 10 KB or a head over the injected cap, a stale
+`updated=`, and pending sections left unchanged while `Done` grew. The Stop
+hook passes a set of findings on once; the SessionStart block always shows
+them. You can run it yourself:
+`bash <plugin>/scripts/state-lint.sh ~/.claude/orchestrate/<slug>/state.md`.
+
 ## Where things are
 
 | Path | Holds |
diff --git a/plugins/orchestrate/.claude-plugin/plugin.json b/plugins/orchestrate/.claude-plugin/plugin.json
index ca19ba1e..bf4e5aae 100644
--- a/plugins/orchestrate/.claude-plugin/plugin.json
+++ b/plugins/orchestrate/.claude-plugin/plugin.json
@@ -1,6 +1,6 @@
 {
   "name": "orchestrate",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Orchestrate mode: the main session holds the goal, a state file and a map of the work, and delegates detailed work to subagents. One goal folder per goal under ~/.claude/orchestrate/, spanning any number of repositories; hooks keep it current across /clear and do nothing until a goal is started.",
   "author": {
     "name": "Diamond Light Source"
diff --git a/plugins/orchestrate/README.md b/plugins/orchestrate/README.md
index a53f97b3..97353e7a 100644
--- a/plugins/orchestrate/README.md
+++ b/plugins/orchestrate/README.md
@@ -8,7 +8,8 @@ Install, usage and file layout:
 | Part | Path |
 |---|---|
 | Entry skill, its verbs and rules | `skills/orchestrate/SKILL.md`, `skills/orchestrate/references/state-file.md` |
-| Goal lifecycle (start, resume, pause, list, close) and the pointer | `scripts/goal.sh` |
+| Goal lifecycle (start, resume, pause, list, close), the pointer, and the scripted state edits (touch, now, land) | `scripts/goal.sh` |
+| State file lint, run by the Stop and SessionStart hooks | `scripts/state-lint.sh` |
 | Hooks (active only for the pointer's goal, in its launch directory, in the session that owns it) | `hooks/hooks.json`, `scripts/session-start.sh`, `scripts/stop.sh`, `scripts/session-end.sh` |
 | Shared helpers, log rotation, thresholds | `scripts/lib.sh` |
 | Transcript to text, for recovery queries | `scripts/transcript-text.sh` |
diff --git a/plugins/orchestrate/scripts/goal.sh b/plugins/orchestrate/scripts/goal.sh
index d2f4e99e..b89514e8 100755
--- a/plugins/orchestrate/scripts/goal.sh
+++ b/plugins/orchestrate/scripts/goal.sh
@@ -12,7 +12,16 @@
 #                                             pointer removed
 #     goal.sh list [--all]                    every goal with its status (* = active);
 #                                             --all lists stopped goals too
+#     goal.sh touch                           set the state marker's updated= to now
+#     goal.sh now '<entry>'                   a launch: add the entry to Now, in place
+#                                             of "(nothing running)"
+#     goal.sh land <label> ['<done line>']    a return: drop the Now entry "-> <label> ->",
+#                                             "(nothing running)" when Now empties; with
+#                                             a done line (the item is finished) append
+#                                             "- YYYY-MM-DD HH:MMZ <done line>" to the end of Done;
+#                                             label - when no agent ran
 #
+# touch, now and land act on the active goal's state file and set updated=.
 # The launch directory is the current directory.
 # start and resume pause the goal that is active, if it is another one.
 # Exit 0 done, 1 refused (the message says why), 2 usage, 3 the user must
@@ -22,7 +31,7 @@ set -uo pipefail
 # shellcheck source=lib.sh
 source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
 
-usage() { sed -n '5,19p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//' >&2; exit 2; }
+usage() { sed -n '5,28p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//' >&2; exit 2; }
 die() { printf 'goal.sh: %s\n' "$*" >&2; exit 1; }
 
 dir="$(pwd -P)"
@@ -94,7 +103,88 @@ pause_goal() {
     printf 'paused:   %s\n' "$ACTIVE_SLUG"
 }
 
+# Rewrite the active goal's Now section, and append to Done, in one pass.
+# From the environment: NOW_ADD an entry to add, NOW_DROP a label whose
+# entries go, DONE_ADD a line for the end of Done. Now keeps its entries in
+# order with no blank line among them, holds "- (nothing running)" when
+# empty, and ends with one blank line; Done gains its line after its last
+# entry. Then updated= is set and the new Now printed.
+state_edit() {
+    pointer_read || die "no active goal"
+    goal_paths "$ACTIVE_SLUG"
+    [ -f "$STATE_FILE" ] || die "goal '$SLUG' has no state file"
+    grep -qx '## Now' "$STATE_FILE" || die "$STATE_FILE has no '## Now' line"
+    # The copy keeps the file's mode; awk then replaces its content.
+    cp -p "$STATE_FILE" "$STATE_FILE.tmp" || die "cannot write $STATE_FILE.tmp"
+    awk -v end="$HEAD_END" '
+        function heading(l) { return l ~ /^## / || l == end }
+        # An entry names a label as "-> <label> ->" or by starting with it.
+        function named(l, lab,   p, c) {
+            if (index(l, " -> " lab " -> ")) return 1
+            p = "- " lab; c = substr(l, length(p) + 1, 1)
+            return substr(l, 1, length(p)) == p && (c == "" || c == " " || c == ":")
+        }
+        function close_now(   i) {
+            if (ENVIRON["NOW_ADD"] != "") e[++n] = ENVIRON["NOW_ADD"]
+            if (n == 0) e[++n] = "- (nothing running)"
+            for (i = 1; i <= n; i++) print e[i]
+            print ""; innow = 0
+        }
+        function close_done() {
+            if (ENVIRON["DONE_ADD"] != "") print ENVIRON["DONE_ADD"]
+            printf "%s", blanks; blanks = ""; indone = 0; done = 1
+        }
+        innow && heading($0) { close_now() }
+        indone && heading($0) { close_done() }
+        innow {
+            if ($0 ~ /^[[:space:]]*$/ || $0 == "- (nothing running)") next
+            if (ENVIRON["NOW_DROP"] != "" && named($0, ENVIRON["NOW_DROP"])) next
+            e[++n] = $0; next
+        }
+        indone && /^[[:space:]]*$/ { blanks = blanks $0 "\n"; next }
+        indone { printf "%s", blanks; blanks = ""; print; next }
+        { print }
+        $0 == "## Now" { innow = 1 }
+        $0 == "## Done" || index($0, "## Done ") == 1 { indone = 1 }
+        END {
+            if (innow) close_now()
+            if (indone) close_done()
+            else if (!done && ENVIRON["DONE_ADD"] != "") { print "## Done"; print ENVIRON["DONE_ADD"] }
+        }' "$STATE_FILE" > "$STATE_FILE.tmp" && mv -f "$STATE_FILE.tmp" "$STATE_FILE" \
+        || { rm -f "$STATE_FILE.tmp"; die "cannot rewrite $STATE_FILE"; }
+    state_set_field "$STATE_FILE" updated "$(now_iso)"
+    sed -n '/^## Now$/,/^$/p' "$STATE_FILE"
+}
+
+# Entries in the active goal's Now, not counting the placeholder.
+now_count() {
+    pointer_read && goal_paths "$ACTIVE_SLUG" || return 0
+    sed -n '/^## Now$/,/^## /p' "$STATE_FILE" 2>/dev/null | grep '^- ' | grep -vcx -- '- (nothing running)'
+}
+
 case "$cmd" in
+touch)
+    pointer_read || die "no active goal"
+    goal_paths "$ACTIVE_SLUG"
+    [ -f "$STATE_FILE" ] || die "goal '$SLUG' has no state file"
+    state_set_field "$STATE_FILE" updated "$(now_iso)"
+    head -n 1 "$STATE_FILE"
+    ;;
+now)
+    entry="$*"; entry="${entry//$'\n'/ }"; entry="${entry#- }"
+    [ -n "$entry" ] || usage
+    NOW_ADD="- $entry" state_edit
+    ;;
+land)
+    label="${1:-}"; shift || true
+    [ -n "$label" ] || usage
+    done_line="$*"; done_line="${done_line//$'\n'/ }"
+    [ -n "$done_line" ] && done_line="- $(date -u "+%Y-%m-%d %H:%MZ") ${done_line#- }"
+    n="$(now_count)"
+    NOW_DROP="$label" DONE_ADD="$done_line" state_edit
+    [ "$label" = - ] || [ "$(now_count)" != "$n" ] \
+        || printf 'note:     no Now entry names %s; Now is unchanged\n' "$label"
+    ;;
 start)
     slug="${1:-}"; shift || true
     goal="$*"
diff --git a/plugins/orchestrate/scripts/lib.sh b/plugins/orchestrate/scripts/lib.sh
index 7e9cb6c6..cf15c404 100755
--- a/plugins/orchestrate/scripts/lib.sh
+++ b/plugins/orchestrate/scripts/lib.sh
@@ -164,14 +164,36 @@ state_head() {
     fi
 }
 
+# ---- lint ----------------------------------------------------------------
+# The state file's lint findings (scripts/state-lint.sh), one per line. The
+# lint keeps its section hashes in the goal's .lint.
+state_lint() {
+    bash "$PLUGIN_ROOT/scripts/state-lint.sh" "$STATE_FILE" "$GOAL_LOG" "$GOAL_DIR/.lint" 2>/dev/null
+}
+
+# The findings when their set differs from the set last reported, else
+# nothing; the set is kept in the goal's .lint-last. A finding is keyed by
+# its code and subject (the label, section or #<n>), not its counts or
+# times, so one already reported does not nag as its count grows.
+state_lint_changed() {
+    local found key last="$GOAL_DIR/.lint-last"
+    found="$(state_lint)"
+    key="$(sed -E '/^lint: (now-finished|pending-but-done):/b
+                   s/^(lint: section-stale: ## .*) unchanged .*/\1/; t
+                   s/^(lint: [a-z-]+):.*/\1/' <<<"$found")"
+    [ "$key" = "$(cat "$last" 2>/dev/null)" ] && return 0
+    printf '%s\n' "$key" > "$last" 2>/dev/null
+    printf '%s' "$found"
+}
+
 # ---- the context block ---------------------------------------------------
 # What a session that takes the goal over is told: the goal's paths, a
 # crash check against the previous transcript, Now entries with no report,
-# the scratch report and (unless $3 is no) the state file's head. Printed
+# the state file's lint findings, the scratch report and (unless $3 is no) the state file's head. Printed
 # by SessionStart in the owner, and by Stop on the turn that claims the
 # goal. Needs the goal paths and the hook input.
 goal_context() { # WHO MODE_LINE [yes|no: include the head]
-    local scratch_mb total prev crash="" prev_m state_m lost="" line report rest brief label
+    local scratch_mb total prev crash="" prev_m state_m lost="" lint line report rest brief label
     scratch_mb="$(state_scratch_report)"
     total="$(wc -l < "$STATE_FILE")"
 
@@ -218,6 +240,7 @@ Never /resume it."
     printf '%s\n' "$2"
     [ -n "$crash" ] && printf '\n%s\n' "$crash"
     [ -n "$lost" ] && printf '\n%s' "$lost"
+    lint="$(state_lint)" && [ -n "$lint" ] && printf '\nState file lint (fix what is wrong; a finding you judged wrong may stay):\n%s\n' "$lint"
     [ -n "$scratch_mb" ] && printf '\nScratch in %s/*/scratch totals %s MB (report threshold %s MB). Offer the user a cleanup: list each scratch dir with its size and whether its goal is stopped; delete only what they name.\n' "$ROOT" "$scratch_mb" "$SCRATCH_REPORT_MB"
     if [ "${3:-yes}" = yes ]; then
         printf '\n--- head of %s ---\n' "$STATE_FILE"
diff --git a/plugins/orchestrate/scripts/session-start.sh b/plugins/orchestrate/scripts/session-start.sh
index 83ba9d46..9dcda360 100755
--- a/plugins/orchestrate/scripts/session-start.sh
+++ b/plugins/orchestrate/scripts/session-start.sh
@@ -4,7 +4,8 @@
 # Only in orchestrate mode (the pointer names a goal, this session runs in
 # its launch directory and owns the goal): re-seeds a cold context with a
 # small block - the goal's paths, a crash check against the previous
-# transcript, and the state file's HEAD only. The body is read on demand.
+# transcript, the state file's lint findings, and its HEAD only. The body
+# is read on demand.
 #
 # A /clear in the owning session starts a new session id; the owner's
 # SessionEnd left session=cleared:<old id>, and this hook claims it when
diff --git a/plugins/orchestrate/scripts/state-lint.sh b/plugins/orchestrate/scripts/state-lint.sh
new file mode 100755
index 00000000..814178b9
--- /dev/null
+++ b/plugins/orchestrate/scripts/state-lint.sh
@@ -0,0 +1,144 @@
+#!/usr/bin/env bash
+# Lint a goal's state file for the drift that edits made from memory leave
+# behind. Run by the Stop and SessionStart hooks; also usable by hand.
+#
+#     state-lint.sh <state.md> [<log.md>] [<sidecar>]
+#
+# Prints one line per finding, "lint: <code>: <text>", and nothing when the
+# file is clean. Always exits 0: a hook must never block. Reads only the
+# files given. <log.md> lets done-order place Done entries that carry no
+# YYYY-MM-DD HH:MMZ stamp. <sidecar> (the goal's .lint) keeps each pending section's
+# hash and the Done count when it last changed, for section-stale; it is the
+# only file written, so the orchestrator stays the state file's one writer.
+#
+# The format checked is the one SKILL.md describes and goal.sh now/land
+# write:
+#   ## Now    `- (nothing running)` or one entry per line, no blank lines
+#   ## Done   the last section; one line per finished item, `- YYYY-MM-DD HH:MMZ <text>`,
+#             appended in time order
+#   ## Decided  rulings only, each ending `(<who>, YYYY-MM-DD)`
+# Thresholds may come from the environment (the tests set them).
+
+set -uo pipefail
+# shellcheck source=lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
+
+f="${1:?usage: state-lint.sh <state.md> [<log.md>] [<sidecar>]}"; log="${2:-}"; side="${3:-}"
+[ -f "$f" ] || exit 0
+goal_dir="$(cd "$(dirname "$f")" && pwd)"
+MAX_BYTES="${STATE_LINT_MAX_BYTES:-10240}"      # the whole file, read on demand
+MAX_DONE="${STATE_LINT_MAX_DONE:-20}"           # Done entries: one per item
+STALE_DONE="${STATE_LINT_STALE_DONE:-5}"        # Done growth a pending section may ignore
+MARKER_SLACK="${STATE_LINT_MARKER_SLACK:-900}"  # seconds updated= may trail the file
+
+out() { printf 'lint: %s\n' "$*"; }
+
+# The lines of "## NAME" (a heading may carry a suffix) up to the next
+# heading or the end-of-head line.
+section() {
+    awk -v s="## $1" -v end="$HEAD_END" '
+        $0 == s || index($0, s " ") == 1 { on = 1; next }
+        on && (/^## / || $0 == end) { exit }
+        on' "$f"
+}
+
+# ---- Now ---------------------------------------------------------------------
+now="$(section Now)"
+# One blank line before the next heading is the separator; any other is drift.
+blank="$(section Now | awk '/^[[:space:]]*$/ { n++ } END { print (n > 1 ? n - 1 : 0) }')"
+[ "$blank" -gt 0 ] && out "now-blank: $blank blank line(s) inside ## Now; one entry per line, none blank"
+grep -q '^- ' <<<"$now" || out "now-empty: ## Now has no entry; when nothing runs it holds '- (nothing running)'"
+while IFS= read -r line; do
+    case "$line" in "- ["*" -> "*" -> "*" -> "*) ;; *) continue ;; esac
+    report="${line##* -> }"; report="${report%% (*}"; report="${report/#\~/$HOME}"
+    case "$report" in /*) ;; *) report="$goal_dir/$report" ;; esac
+    rest="${line% -> *}"; rest="${rest% -> *}"; label="${rest##* -> }"
+    [ -e "$report" ] && out "now-finished: $label has its report; it has returned: goal.sh land $label"
+done <<<"$now"
+
+# ---- finished numbers still pending ------------------------------------------
+# A #N is finished when a Done or Decided line says it merged or closed. Next,
+# Awaiting user or Queue still naming one is worth a look (a follow-up may
+# legitimately name it; the Stop hook reports a finding once).
+finished="$( { section Done; section Decided; } \
+    | grep -oiE '#[0-9]+[^#]{0,25}(merged|closed)|(merged|closed)[^#]{0,12}#[0-9]+' \
+    | grep -oE '#[0-9]+' | sort -u)"
+for s in Next "Awaiting user" Queue; do
+    for n in $(section "$s" | grep -oE '#[0-9]+' | sort -u); do
+        grep -qxF -- "$n" <<<"$finished" || continue
+        out "pending-but-done: ## $s names $n, which Done or Decided records as merged or closed"
+    done
+done
+
+# ---- Decided: rulings only ---------------------------------------------------
+dec="$(section Decided | grep '^- ')"
+ev="$(grep -cE 'MERGED|CLOSED|APPROVE|CHANGES|^- Opened |- done [0-9]|\((opus|sonnet|haiku|fable)\)[: ]' <<<"$dec")"
+[ "$ev" -gt 0 ] && out "decided-events: $ev ## Decided line(s) read as events (merges, reviews, agent returns); they belong in Done or the log"
+nowho="$(grep -cvE '\([^()]*, *(20[0-9][0-9]|<YYYY-MM-DD>)[^()]*\)' <<<"$dec")"
+[ -n "$dec" ] && [ "$nowho" -gt 0 ] && out "decided-unattributed: $nowho ## Decided line(s) lack '(<who>, YYYY-MM-DD)'; a ruling names who made it, anything else is not a ruling"
+
+# ---- Done: appended in time order --------------------------------------------
+# A stamped entry (- YYYY-MM-DD HH:MMZ) earlier than the one above it was
+# inserted, not appended. An unstamped entry is placed by its first word,
+# when the log timestamps that label.
+inv="$(section Done | awk -v lf="$log" '
+    BEGIN { if (lf != "") while ((getline l < lf) > 0)
+                if (l ~ /^- [0-9]{4}-[0-9][0-9]-[0-9][0-9]T[0-9:]+Z? [a-z0-9-]+:/) {
+                    split(l, a, " "); lab = a[3]; sub(/:$/, "", lab)
+                    if (!(lab in ts)) ts[lab] = a[2] } }
+    /^- [0-9]{4}-[0-9][0-9]-[0-9][0-9] [0-2][0-9]:[0-5][0-9]Z / {
+        m = $2 " " $3
+        if (pm != "" && m < pm) n++
+        pm = m; next }
+    /^- / { if ($2 in ts) { if (pl != "" && ts[$2] < pl) n++; pl = ts[$2] } }
+    END { print n + 0 }')"
+[ "$inv" -gt 0 ] && out "done-order: $inv ## Done entr(y/ies) sit above an older one; append each at the end of Done"
+
+# ---- size ----------------------------------------------------------------------
+bytes="$(wc -c < "$f")"
+[ "$bytes" -gt "$MAX_BYTES" ] && out "size: $bytes bytes (> $MAX_BYTES); collapse each finished item to one Done line and move the detail to the log"
+done_n="$(section Done | grep -c '^- ')"
+[ "$done_n" -gt "$MAX_DONE" ] && out "done-long: $done_n ## Done entries (> $MAX_DONE); one line per finished item, not per agent return"
+hn="$(grep -n -F -x "$HEAD_END" "$f" | head -1 | cut -d: -f1)"
+if [ -n "$hn" ]; then
+    hb="$(head -n "$((hn - 1))" "$f" | wc -c)"
+    { [ "$((hn - 1))" -gt "$STATE_HEAD_CAP_LINES" ] || [ "$hb" -gt "$STATE_HEAD_CAP_BYTES" ]; } \
+        && out "head-long: the head is $((hn - 1)) lines, $hb bytes (cap $STATE_HEAD_CAP_LINES lines, $STATE_HEAD_CAP_BYTES bytes); the injected copy is cut short"
+fi
+
+# ---- marker ------------------------------------------------------------------
+upd="$(state_field "$f" updated)"
+u="$(date -u -d "$upd" +%s 2>/dev/null || echo 0)"
+if [ -n "$upd" ] && [ "$u" -gt 0 ]; then
+    m="$(stat -c %Y "$f")"; t="$(date -u +%s)"
+    if [ "$((m - u))" -gt "$MARKER_SLACK" ] || [ "$((u - t))" -gt 300 ]; then
+        out "marker-stale: updated=$upd does not match the file's last change; run goal.sh touch, never type the time"
+    fi
+fi
+
+# ---- pending sections left alone while work moved ------------------------------
+if [ -n "$side" ]; then
+    touch "$side" 2>/dev/null || exit 0
+    for s in Next "Awaiting user" Queue Map; do
+        # An empty section, or one holding only a placeholder such as
+        # "- (none)", has nothing to go stale.
+        section "$s" | grep '^- ' | grep -qv '^- ([^()]*)$' || continue
+        h="$(section "$s" | md5sum | cut -c1-12)"; key="${s// /_}"
+        prev="$(grep "^$key " "$side" | tail -1)"
+        # A new hash, or a Done that shrank (items collapsed), resets the count.
+        if [ -z "$prev" ] || [ "$(cut -d' ' -f2 <<<"$prev")" != "$h" ] \
+            || [ "$(cut -d' ' -f3 <<<"$prev")" -gt "$done_n" ]; then
+            { grep -v "^$key " "$side"; printf '%s %s %s\n' "$key" "$h" "$done_n"; } > "$side.tmp" \
+                && mv -f "$side.tmp" "$side"
+            continue
+        fi
+        since="$(cut -d' ' -f3 <<<"$prev")"
+        [ "$((done_n - since))" -ge "$STALE_DONE" ] || continue
+        out "section-stale: ## $s unchanged while Done grew by $((done_n - since)); re-read it and fix each line it falsifies"
+        # Reported: count again from here, so a section confirmed as it is
+        # is named again only after another $STALE_DONE items.
+        { grep -v "^$key " "$side"; printf '%s %s %s\n' "$key" "$h" "$done_n"; } > "$side.tmp" \
+            && mv -f "$side.tmp" "$side"
+    done
+fi
+exit 0
diff --git a/plugins/orchestrate/scripts/stop.sh b/plugins/orchestrate/scripts/stop.sh
index 7611d75c..4046a881 100755
--- a/plugins/orchestrate/scripts/stop.sh
+++ b/plugins/orchestrate/scripts/stop.sh
@@ -10,10 +10,14 @@
 # is not a state update. A turn that only talked (a ruling given in chat)
 # is invisible to it; the skill's per-turn rule covers that case.
 #
+# It also runs the state file's lint (state-lint.sh) after any turn that
+# changed things or touched the goal folder, and passes on its findings when
+# they differ from the set it last passed on.
+#
 # Only the session that owns the goal is checked. A turn that ran
 # `goal.sh start` or `goal.sh resume` claims the goal for its session first
 # (lib.sh, Ownership) and is given the SessionStart checks it missed (crash,
-# lost agents, scratch); any other session is silent.
+# lost agents, lint, scratch); any other session is silent.
 #
 # Uses hookSpecificOutput.additionalContext: non-error feedback, the
 # conversation continues. Skipped while stop_hook_active is set, so it fires
@@ -102,10 +106,17 @@ touched="$(jq -r --arg s "$STATE_FILE" "$JQ_DEFS"'
     or any(.[]; .n == "Bash" and (segs | any(.[]; goal_sh("start|resume|touch|now|land"))))' \
     <<<"$calls" 2>/dev/null)"
 
-[ "$substantive" = "true" ] && [ "$touched" != "true" ] || exit 0
-
-msg="Orchestrate state check: this turn changed things (edits, agents or git/gh writes) without updating the state file.
-Update $STATE_FILE with a small Edit - Now/Next and anything decided - and set the marker's updated=$(now_iso).
+msg=""
+[ "$substantive" = "true" ] && [ "$touched" != "true" ] && msg="Orchestrate state check: this turn changed things (edits, agents or git/gh writes) without updating the state file.
+Record it in $STATE_FILE (goal.sh now or land for a launch or return, a small Edit for Next and anything decided), then run goal.sh touch. goal.sh is bash $PLUGIN_ROOT/scripts/goal.sh."
+lint=""
+[ "$substantive" = "true" ] || [ "$touched" = "true" ] && lint="$(state_lint_changed)"
+[ -n "$lint" ] && msg="${msg:+$msg
+}Orchestrate state lint:
+$lint
+Read the head and the sections named, fix what is wrong with small Edits, then run bash $PLUGIN_ROOT/scripts/goal.sh touch."
+[ -n "$msg" ] || exit 0
+msg="$msg
 Do not repeat your previous reply; end the turn with at most one line."
 
 jq -n --rawfile ctx /dev/stdin \
diff --git a/plugins/orchestrate/skills/orchestrate/SKILL.md b/plugins/orchestrate/skills/orchestrate/SKILL.md
index 5bce6efc..4ec44797 100644
--- a/plugins/orchestrate/skills/orchestrate/SKILL.md
+++ b/plugins/orchestrate/skills/orchestrate/SKILL.md
@@ -51,17 +51,39 @@ and say once that you hold the map and the agents hold the code.
 
 ## The state file: `<goal>/state.md`
 
+`goal.sh` below is `bash <plugin>/scripts/goal.sh`; it writes the marker
+line, never you.
+
 - Write it at the end of every turn that changed anything: a launch or
   return, a ruling or reaction from the user (chat is invisible to the
   hooks), an item moving, a commit. Small Edits, never a rewrite, never
-  `sed`; refresh the marker's `updated=`. There is no flush before a
-  clear: a `/clear` at any moment must lose nothing.
+  `sed`; after an Edit run `goal.sh touch`, which sets `updated=`. There is
+  no flush before a clear: a `/clear` at any moment must lose nothing.
 - Above `<!-- end head -->` (injected on every start, ~25 lines): Goal,
-  Now, Next, Invariants. The body is read on demand. Under 150 lines; move
-  superseded detail to the log.
-- `Now` is exactly what is running. A launch writes
-  `- [<model>] <item> -> <label> -> <brief> -> <report>` in the same turn
-  as the Agent call; a return moves it to `Done` with the report pointer.
+  Now, Next, Invariants. The body is read on demand. Size is bytes, not
+  lines: the file stays under 10 KB because finished items collapse to one
+  `Done` line each.
+- `Now` is exactly what is running, one line each, no blank lines; when
+  nothing is, `- (nothing running)`. A launch runs
+  `goal.sh now '[<model>] <item> -> <label> -> <brief> -> <report>'` in the
+  same turn as the Agent call; a return runs `goal.sh land <label>`, which drops the entry naming
+  `-> <label> ->` or starting with `<label>`. Never
+  edit `Now` by hand.
+- `Done` is the last section, one line per finished *item*, not per agent
+  return or review round (those are in the log; an item in flight lives in
+  `Now` and `Next`). When an item finishes, `goal.sh land <label> '<item,
+  outcome, report pointer>'` appends `- YYYY-MM-DD HH:MMZ <text>` at its end, and in
+  the same turn you collapse the item's `Decided` and `Map` lines into that
+  line or the log (`goal.sh land - '<text>'` when no agent ran). Never
+  insert above an existing line.
+- `Decided` holds rulings only, each ending `(<who>, YYYY-MM-DD)`. Events
+  (merged, closed, opened, reviewed) go to `Done` or the log; per-item
+  plans go to `Next` or `Queue`.
+- After every return or ruling, `Read` the file down to `## Decided` and
+  fix each line in the head, `Awaiting user`, `Queue` or `Map` that it
+  falsifies. The hooks run `state-lint.sh` and name what they can see
+  (`lint: <code>: ...`): fix it or, when a finding is wrong, leave it; it
+  is reported once.
 - Branches, PRs and worktrees go in `Map` as pointers
   (`<repo> branch:<name>`, `<repo>#<n>`); check them before relying on them.
 - No agent writes the state file; nobody summarises, rewrites or derives
@@ -206,7 +228,8 @@ Design happens here, the only session that sees the editor selection:
 5. Back to step 1 if the report needs iteration.
 
 While foreground: mark the item `foreground` in its status heading and in
-`Now`; write each ruling to `Decided` the turn it is made; you are the only
+`Now` (`goal.sh now 'foreground: <item>'`, cleared by `goal.sh land
+foreground`); write each ruling to `Decided` the turn it is made; you are the only
 main-checkout writer; launch only mechanical work; an agent return updates
 state and status only, with an empty reply (needs-user goes under `▶ you`).
 
diff --git a/plugins/orchestrate/skills/orchestrate/references/state-file.md b/plugins/orchestrate/skills/orchestrate/references/state-file.md
index 75628de9..7c3923da 100644
--- a/plugins/orchestrate/skills/orchestrate/references/state-file.md
+++ b/plugins/orchestrate/skills/orchestrate/references/state-file.md
@@ -1,7 +1,9 @@
 # State file template
 
 `goal.sh start` writes `<goal>/state.md` from the block below, filling the
-marker and the goal line. The rules for keeping it are in `SKILL.md`.
+marker and the goal line. The rules for keeping it are in `SKILL.md`;
+`scripts/state-lint.sh` checks them. `goal.sh now` and `goal.sh land` edit
+`Now` and append to `Done`, which stays the last section.
 
 ```markdown
 <!-- state: updated=<ISO UTC> status=active -->
@@ -21,12 +23,12 @@ marker and the goal line. The rules for keeping it are in `SKILL.md`.
 ## Queue
 ## Release gates
 ## Decided
-- <ruling> - <why> (<who>, <date>)
+- <ruling> - <why> (<who>, <YYYY-MM-DD>)
 ## Open
 - (user) <question>
 - (me) <question>
 ## Map
 - <repo or system>: <goal>/maps/<area>.md; branch:<name>, <repo>#<n>, worktree <path>
 ## Done
-- <one line each, with the report pointer>
+- <YYYY-MM-DD HH:MMZ> <one line per finished item, with the report pointer>
 ```
diff --git a/tests/fixtures/orchestrate/log-drifted.md b/tests/fixtures/orchestrate/log-drifted.md
new file mode 100644
index 00000000..675b4ba5
--- /dev/null
+++ b/tests/fixtures/orchestrate/log-drifted.md
@@ -0,0 +1,6 @@
+- 2026-01-05T10:00:00Z goal:widget started in /work/widget: Work through the open issues
+- 2026-01-05T10:10:00Z impl-12: part 1 done
+- 2026-01-05T10:20:00Z review-12-r1: APPROVE
+- 2026-01-05T10:30:00Z recon-9: mapped the auth code
+- 2026-01-05T10:40:00Z impl-9: tokens stored per name
+- 2026-01-05T10:50:00Z review-9-r1: CHANGES
diff --git a/tests/fixtures/orchestrate/state-drifted.md b/tests/fixtures/orchestrate/state-drifted.md
new file mode 100644
index 00000000..b7f3c2a7
--- /dev/null
+++ b/tests/fixtures/orchestrate/state-drifted.md
@@ -0,0 +1,44 @@
+<!-- state: updated=2026-01-05T10:20:00Z status=active -->
+# Goal: Work through the open issues on example/widget one at a time, each landed as a reviewed PR.
+
+## Now
+
+
+
+
+
+
+## Next
+- After #14 merges: rebase the parser branch onto main, then PR
+- Then the docs follow-up for #7
+
+## Invariants
+- No push without the user's word for that item.
+<!-- end head -->
+
+## Awaiting user
+- Which issues to take, in what order
+## Queue
+- #7 config overlay
+- #9 second token
+## Release gates
+## Decided
+- Sonnet implements, Opus reviews, max 3 rounds (user, 2026-01-05)
+- #12 split into two PRs; part 1 now (user, 2026-01-05)
+- #12 retitled on GitHub - done 2026-01-05
+- #7 CLOSED not-planned with a design comment (user)
+- review-12 (opus): APPROVE, 2 nits
+- Opened #14 for the parser fix (user, 2026-01-05)
+- #9 build it; design accepted (me, unconfirmed)
+## Open
+## Map
+- widget main at abc1234
+## Done
+- review-12-r1 (opus): APPROVE, 2 nits
+- PR widget#13 MERGED (def5678); #12 closed
+- impl-12 (sonnet): part 1 done -> reports/impl-12.md
+- impl-9 (sonnet): tokens stored per name -> reports/impl-9.md
+- recon-9 (sonnet): mapped the auth code -> maps/auth.md
+- review-9-r1 (opus): CHANGES, 1 should
+- 2026-01-05 11:40Z #14 merged; #7 closed with a comment
+- 2026-01-05 11:10Z #9 landed as PR #15
diff --git a/tests/orchestrate_plugin.sh b/tests/orchestrate_plugin.sh
index a27e3c7d..1765179f 100644
--- a/tests/orchestrate_plugin.sh
+++ b/tests/orchestrate_plugin.sh
@@ -4,8 +4,9 @@
 # pointer names a goal, the session runs in its launch directory and owns
 # the goal (claimed by goal.sh start/resume, handed on by /clear), the
 # right injection and nudges inside the mode, the lost-agent check, log
-# rotation and the scratch report. Hermetic: a temp HOME, throwaway git repos and synthetic
-# transcripts; no claude binary. Needs bash, git and jq.
+# rotation, the scratch report, the state lint and goal.sh touch/now/land.
+# Hermetic: a temp HOME, throwaway git repos and synthetic transcripts; no
+# claude binary. Needs bash, git and jq.
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=lib.sh
@@ -402,4 +403,153 @@ assert_eq "resume points at this directory" "dir=$PROJ" "$(sed -n 2p "$ROOT/acti
 rm "$ROOT/active"; goal start goal 'again'
 grep -q 'archived' <<<"$OUT" && pass || fail "an archived slug was reused: $OUT"
 
+# ---- state lint (state-lint.sh) ----------------------------------------------
+LINT="$S/state-lint.sh"
+FX="$HERE/fixtures/orchestrate"
+codes() { sed -n 's/^lint: \([a-z-]*\):.*/\1/p' | sort -u | tr '\n' ' '; }
+cp "$FX/state-drifted.md" "$TMP/drifted.md"
+touch -d '2026-01-05T11:45:00Z' "$TMP/drifted.md"
+OUT="$(STATE_LINT_MAX_BYTES=500 STATE_LINT_MAX_DONE=5 bash "$LINT" "$TMP/drifted.md" "$FX/log-drifted.md" "$TMP/side")"
+assert_eq "lint: the drifted fixture yields each code" \
+    "decided-events decided-unattributed done-long done-order marker-stale now-blank now-empty pending-but-done size " \
+    "$(codes <<<"$OUT")"
+grep -qF 'now-blank: 5 blank' <<<"$OUT" && pass || fail "lint: now-blank count: $OUT"
+grep -qF 'decided-events: 4 ' <<<"$OUT" && pass || fail "lint: decided-events count: $OUT"
+grep -qF 'decided-unattributed: 4 ' <<<"$OUT" && pass || fail "lint: decided-unattributed count: $OUT"
+grep -qF 'done-order: 3 ' <<<"$OUT" && pass || fail "lint: done-order (stamps and log labels): $OUT"
+assert_eq "lint: pending-but-done names each number" "#14 #7" \
+    "$(grep -o 'names #[0-9]*' <<<"$OUT" | cut -c7- | sort -u | tr '\n' ' ' | sed 's/ $//')"
+bash "$LINT" "$TMP/drifted.md" "" "$TMP/side" >/dev/null
+for i in 1 2 3 4 5; do printf -- '- 2026-01-05 12:0%sZ item %s\n' "$i" "$i" >> "$TMP/drifted.md"; done
+OUT="$(bash "$LINT" "$TMP/drifted.md" "" "$TMP/side")"
+grep -q '^lint: section-stale: ## Next unchanged while Done grew by 5' <<<"$OUT" && pass || fail "lint: section-stale: $OUT"
+grep -q 'section-stale: ## Queue' <<<"$OUT" && pass || fail "lint: section-stale misses Queue: $OUT"
+grep -q 'done-order: 1 ' <<<"$OUT" && pass || fail "lint: appended stamps counted as inversions: $OUT"
+printf '## Now\n- (nothing running)\n\n## Done\n- 2026-01-05 17:00Z friday\n- 2026-01-08 09:00Z monday\n- 2026-01-08 23:50Z late\n- 2026-01-09 00:10Z after midnight\n' > "$TMP/days.md"
+assert_eq "lint: Done across days and midnight is in order" "" "$(bash "$LINT" "$TMP/days.md")"
+printf -- '- 2026-01-08 20:00Z inserted\n' >> "$TMP/days.md"
+grep -q '^lint: done-order: 1 ' <<<"$(bash "$LINT" "$TMP/days.md")" && pass || fail "lint: an earlier time on a later line is not an inversion"
+OUT="$(bash "$LINT" "$TMP/drifted.md" "" "$TMP/side")"
+grep -q 'section-stale: ## Next' <<<"$OUT" && fail "lint: section-stale repeats right after it was reported: $OUT" || pass
+for i in 6 7 8 9; do printf -- '- 2026-01-05 12:%s0Z item %s\n' "$i" "$i" >> "$TMP/drifted.md"; done
+grep -q 'section-stale: ## Next' <<<"$(bash "$LINT" "$TMP/drifted.md" "" "$TMP/side")" \
+    && fail "lint: section-stale back before another 5 items" || pass
+printf -- '- 2026-01-05 13:00Z item 10\n' >> "$TMP/drifted.md"
+grep -q 'section-stale: ## Next unchanged while Done grew by 5' <<<"$(bash "$LINT" "$TMP/drifted.md" "" "$TMP/side")" \
+    && pass || fail "lint: section-stale not reported again after another 5 items"
+printf '## Now\n- (nothing running)\n\n## Awaiting user\n## Queue\n- (none)\n## Map\n## Done\n' > "$TMP/empty.md"
+bash "$LINT" "$TMP/empty.md" "" "$TMP/side-empty" >/dev/null
+for i in 1 2 3 4 5 6; do printf -- '- 2026-01-05 12:0%sZ item %s\n' "$i" "$i" >> "$TMP/empty.md"; done
+assert_eq "lint: empty and placeholder sections never go stale" "" "$(bash "$LINT" "$TMP/empty.md" "" "$TMP/side-empty")"
+awk '/^## Invariants$/ { print; for (i = 0; i < 40; i++) print "- rule " i; next } 1' "$FX/state-drifted.md" > "$TMP/longhead.md"
+OUT="$(bash "$LINT" "$TMP/longhead.md")"
+grep -q '^lint: head-long: the head is 5[0-9] lines' <<<"$OUT" && pass || fail "lint: head-long: $OUT"
+printf 'x\n' | bash "$LINT" /nonexistent; assert_eq "lint: a missing file exits 0" 0 "$?"
+
+goal start lint 'Keep the state file clean'
+L="$ROOT/lint"
+assert_eq "lint: the start template is clean" "" "$(bash "$LINT" "$L/state.md" "$L/log.md" "$L/.lint")"
+
+# goal.sh touch: the marker, to the minute, by script.
+sed -i '1s/updated=[^ ]*/updated=2020-01-01T00:00:00Z/' "$L/state.md"
+goal touch
+assert_eq "touch succeeds" 0 "$RC"
+assert_eq "touch sets updated= to the clock" "$(date -u +%Y-%m-%dT%H:%M)" "$(head -1 "$L/state.md" | sed -n 's/.*updated=\([^ ]*\).*/\1/p' | cut -c1-16)"
+
+# goal.sh now / land.
+goal now '[sonnet] item a -> la -> briefs/la.md -> reports/la.md'
+assert_eq "now replaces (nothing running)" "- [sonnet] item a -> la -> briefs/la.md -> reports/la.md" \
+    "$(sed -n '/^## Now$/,/^$/p' "$L/state.md" | sed -n '2,/^$/p' | sed '/^$/d')"
+goal now '- [opus] item b -> lb -> briefs/lb.md -> reports/lb.md'
+assert_eq "now appends under the last entry" "la lb" \
+    "$(sed -n '/^## Now$/,/^## /p' "$L/state.md" | grep -o ' -> l[ab] ->' | cut -c5-6 | tr '\n' ' ' | sed 's/ $//')"
+grep -q '^## Now$' <<<"$OUT" && pass || fail "now does not print the new Now: $OUT"
+sed -i 's/^## Next$/\n\n## Next/' "$L/state.md"
+assert_eq "lint sees blank lines added by hand" "now-blank " "$(bash "$LINT" "$L/state.md" | codes)"
+mkdir -p "$L/reports" && echo r > "$L/reports/lb.md"
+grep -q '^lint: now-finished: lb has its report' <<<"$(bash "$LINT" "$L/state.md")" && pass || fail "lint: now-finished"
+goal land lb
+assert_eq "land of a return" 0 "$RC"
+assert_eq "land drops the entry and the blank lines" "## Now|- [sonnet] item a -> la -> briefs/la.md -> reports/la.md||## Next" \
+    "$(sed -n '/^## Now$/,/^## Next$/p' "$L/state.md" | tr '\n' '|' | sed 's/|$//')"
+assert_eq "land without a done line leaves Done alone" 1 "$(sed -n '/^## Done$/,$p' "$L/state.md" | grep -c '^- ')"
+goal land la 'item a shipped as PR #3 -> reports/la.md'
+grep -qx -- '- (nothing running)' "$L/state.md" && pass || fail "land did not restore (nothing running)"
+tail -n 1 "$L/state.md" | grep -Eq '^- 20[0-9]{2}-[0-9]{2}-[0-9]{2} [0-2][0-9]:[0-5][0-9]Z item a shipped as PR #3 -> reports/la.md$' \
+    && pass || fail "land did not append a stamped Done line: $(tail -n 1 "$L/state.md")"
+goal land nosuch 'item c, no agent'
+assert_eq "land of an absent label still appends" 0 "$RC"
+grep -q '^note: .*nosuch' <<<"$OUT" && pass || fail "land of an absent label gives no note: $OUT"
+goal land - 'item d, no agent'
+grep -q '^note:' <<<"$OUT" && fail "land - gives a note" || pass
+assert_eq "Done entries in call order, at the end" "item a|item c|item d" \
+    "$(sed -n '/^## Done$/,$p' "$L/state.md" | sed -n 's/^- [0-9-]* [0-9:]*Z \(item [a-d]\).*/\1/p' | tr '\n' '|' | sed 's/|$//')"
+assert_eq "one (nothing running) after repeated lands" 1 "$(grep -c '(nothing running)' "$L/state.md")"
+assert_eq "state after now/land passes the lint" "" "$(bash "$LINT" "$L/state.md" "$L/log.md")"
+goal now
+assert_eq "now with no entry is a usage error" 2 "$RC"
+goal land
+assert_eq "land with no label is a usage error" 2 "$RC"
+
+# A foreground item is named by its first word; the file keeps its mode; a
+# newline cannot split an entry.
+chmod 600 "$L/state.md"
+goal now 'foreground: design the API'
+goal land foreground
+grep -q 'foreground' "$L/state.md" && fail "land foreground left the entry: $(grep foreground "$L/state.md")" || pass
+grep -q '^note:' <<<"$OUT" && fail "land foreground gave a note: $OUT" || pass
+assert_eq "now/land keep the file's mode" 600 "$(stat -c %a "$L/state.md")"
+[ -e "$L/state.md.tmp" ] && fail "now/land left state.md.tmp" || pass
+goal now $'[haiku] two\nlines -> nl -> b -> r'
+assert_eq "a newline in an entry is folded" 1 "$(grep -c '^- \[haiku\] two lines -> nl -> b -> r$' "$L/state.md")"
+goal land nl $'done\ntoo'
+tail -n 1 "$L/state.md" | grep -q 'Z done too$' && pass || fail "a newline in a done line is not folded: $(tail -n 2 "$L/state.md")"
+
+# The hooks: Stop reports a finding set once; SessionStart always shows it.
+# Session s1 claims the lint goal first (the hooks act only in its owner),
+# and the claiming turn is shown the lint as SessionStart would show it.
+sed -i 's/^## Decided$/## Decided\n- ship it on Friday/' "$L/state.md"
+transcript "$(bash_call "bash $S/goal.sh resume lint")"; hook stop
+assert_eq "the lint goal is claimed" "s1" "$(owner)"
+ctx | grep -q '^lint: decided-unattributed: 1 ' && pass || fail "claim: lint not shown: $(ctx)"
+rm -f "$L/.lint" "$L/.lint-last"
+STOUCH='{"name":"Edit","input":{"file_path":"'"$L"'/state.md"}}'
+transcript "$STOUCH"
+hook stop
+ctx | grep -q '^lint: decided-unattributed: 1 ' && pass || fail "stop: lint not reported: $OUT"
+ctx | grep -q 'without updating' && fail "stop: nudged although the state file was edited" || pass
+ctx | grep -qF "scripts/goal.sh touch." && pass || fail "stop: lint message does not name goal.sh touch"
+hook stop
+assert_eq "stop: an unchanged finding set is not repeated" "" "$OUT"
+sed -i 's/^- ship it on Friday$/- ship it on Friday\n- and on Monday/' "$L/state.md"
+hook stop
+assert_eq "stop: a changed count alone is not repeated" "" "$OUT"
+printf -- '- 2099-01-01 00:01Z late\n- 2099-01-01 00:00Z early\n' >> "$L/state.md"
+hook stop
+ctx | grep -q '^lint: done-order' && pass || fail "stop: a new finding is not reported: $OUT"
+hook stop ',"stop_hook_active":true'
+assert_eq "stop: the lint never loops" "" "$OUT"
+sed -i '/^- 2099-01-01 00:0[01]Z /d' "$L/state.md"
+mkdir -p "$L/reports" && echo r > "$L/reports/r1.md" && echo r > "$L/reports/r2.md"
+goal now '[opus] review -> rev-47-r1 -> briefs/r1.md -> reports/r1.md'
+hook stop
+ctx | grep -q '^lint: now-finished: rev-47-r1 ' && pass || fail "stop: now-finished r1 not reported: $OUT"
+goal land rev-47-r1; goal now '[opus] review -> rev-47-r2 -> briefs/r2.md -> reports/r2.md'
+hook stop
+ctx | grep -q '^lint: now-finished: rev-47-r2 ' && pass || fail "stop: a new label masked as an old finding: $OUT"
+goal land rev-47-r2
+transcript "$READ_SRC"
+sed -i '/^- 2099-01-01 00:0[01]Z /d' "$L/state.md"
+hook stop
+assert_eq "stop: no lint after a turn that changed nothing" "" "$OUT"
+transcript "$EDIT_SRC"
+hook stop
+ctx | grep -qF "then run goal.sh touch. goal.sh is bash " && pass || fail "stop: nudge does not name goal.sh touch: $(ctx)"
+ctx | grep -q 'updated=20' && fail "stop: nudge still hands the model a time" || pass
+hook session-start ',"source":"clear"'
+ctx | grep -q '^lint: decided-unattributed: 2 ' && pass || fail "session-start: lint not shown: $(ctx)"
+sed -i '/^- ship it on Friday$/d; /^- and on Monday$/d' "$L/state.md"
+hook session-start ',"source":"clear"'
+ctx | grep -q '^lint:' && fail "session-start: lint shown for a clean file: $(ctx)" || pass
+
 finish orchestrate_plugin