From 513dcd39a6ff04f246c5f0a1444d5108d53341a5 Mon Sep 17 00:00:00 2001 From: t Date: Sat, 14 Nov 2026 19:19:50 -0400 Subject: [PATCH 1/4] scripts: one window runner, so a lane does not have to remember the housekeeping Six lane-local copies of this existed in ~/lb by 11-14 (dsv41-window, hl-74-window, i572-when-window, i679-window10/11, i1536-long-next), each with its own version of "stop coder-llm, run, restart it, confirm :8090", and the failure mode is always the same one: a window that ends with coder-llm still stopped, which fails the PR-agent check on every open PR for as long as it lasts. This is that, once, reviewable. What it enforces, and why each rule is in the script rather than in a lane's memory: -m 1..15 coder-llm stays down at most 15 minutes (the message says why) the 45-min gap between one window's END and the next one's START, read from the END lines of ~/briefs/WINDOWS.log only gpu-hold the job runs inside a ticket and QUEUES behind other lanes; --now refuses instead of waiting, for when waiting is the wrong answer coder-llm stopped only once the ticket is ours, restarted by a trap on ANY exit, and :8090 is polled until it answers -- verified, not asserted WINDOWS.log one start line and one end line with lane, issue, label, minutes, the exact command and the rc; the command is what makes a window auditable afterwards the child gets its own ticket pid in GPU_HOLD_TICKET, so a measurement script can prove ownership instead of guessing it from the global token --dry-run validates everything and prints the plan, touching no ticket and no service. It exists because of what the first two versions of the self-test did: an arm that passes validation and then reaches gpu-hold QUEUES A REAL TICKET, so a broken guard showed up as a hang rather than as a red check. Every arm now carries --dry-run, and the two mutants below fail cleanly instead. Self-test: 9 arms, no device, no service change. Turning the gap guard into a tautology or the 15-minute cap into 99 each turn it red (rc 1); restoring, green. Measured otherwise: one end-to-end window on this box -- start line, ticket, coder-llm stopped and restarted, :8090=200 verified, end line with rc=0 -- and refusals for no -l / no -c, -m 0, -m 16, and a window inside the gap (which writes nothing to the log, so a refusal is never mistaken for a window). It is a young script with one end-to-end run behind it: said here rather than left to be found. --- scripts/window-run.sh | 130 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100755 scripts/window-run.sh diff --git a/scripts/window-run.sh b/scripts/window-run.sh new file mode 100755 index 000000000..d453246da --- /dev/null +++ b/scripts/window-run.sh @@ -0,0 +1,130 @@ +#!/usr/bin/env bash +# Copyright 2026 bong-water-water-bong +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# window-run.sh -- run one GPU job as a fleet memory window, with the housekeeping the rules ask for, +# so a lane does not have to remember it. Every lane wrote its own version of this (six of them in +# ~/lb by 11-14), and the failure mode is always the same one: a window that ends with coder-llm still +# stopped, which fails the PR-agent check on every open PR for as long as it lasts. +# +# scripts/window-run.sh -l LABEL [-i ISSUE] [-m MINUTES] -c 'command ...' +# scripts/window-run.sh --self-test +# +# What it enforces, and why each one is here rather than in a lane's memory: +# +# -m 1..15 coder-llm stays down at most 15 minutes, so the window cannot starve the fleet LLM +# the 45-min gap at least 45 minutes between one window's END and the next one's start +# gpu-hold the job runs INSIDE a ticket, and queues behind other lanes rather than racing them +# --now refuses instead of queueing, for the cases where waiting is the wrong answer +# coder-llm stopped only after the ticket is ours, restarted by a trap on ANY exit, and :8090 +# is polled until it answers (the restart is verified, not asserted) +# WINDOWS.log one start line and one end line, carrying lane, issue, label, minutes, the exact +# command and the rc -- the command is what makes a window auditable afterwards +# the child gets its own ticket pid in GPU_HOLD_TICKET, so a measurement script can prove +# ownership instead of guessing it from the global token file +set -uo pipefail + +SELF=${0##*/} +LOG=${WINDOWS_LOG:-$HOME/briefs/WINDOWS.log} +die() { printf '%s: %s\n' "$SELF" "$*" >&2; exit 2; } + +self_test() { + local fail=0 + chk() { local label=$1 got=$2 want=$3; if [ "$got" = "$want" ]; then echo "ok $label"; else echo "FAIL $label (got $got, want $want)"; fail=$((fail+1)); fi; } + tmp=$(mktemp -d); trap 'rm -rf "$tmp"' RETURN + # 1. a duration outside 1..15 is refused, with the reason + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 0 -l x -c true 2>&1); rc=$? + chk "a zero-minute window is refused" "$rc" 2 + chk " ... and says why" "$(printf '%s' "$out" | grep -c 'fails the PR-agent check')" 1 + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 16 -l x -c true 2>&1); chk "a sixteen-minute window is refused" "$?" 2 + # 2. no label / no command + WINDOWS_LOG=$tmp/w.log "$0" --dry-run -c true >/dev/null 2>&1; chk "no -l is refused" "$?" 2 + WINDOWS_LOG=$tmp/w.log "$0" --dry-run -l x >/dev/null 2>&1; chk "no -c is refused" "$?" 2 + # 3. a window inside the 45-minute gap is refused, and writes nothing to the log + printf '%s end lane=t issue=0 label=t coder-llm=active :8090=200 rc=0\n' "$(date -u +%FT%TZ)" > "$tmp/w.log" + WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true >/dev/null 2>&1; chk "a window inside the gap is refused" "$?" 2 + chk " ... and a refusal is not written to the log" "$(wc -l < "$tmp/w.log")" 1 + # 4. an old enough end opens the gate again (the refusal above is about the gap, not about the file) + printf '%s end lane=t issue=0 label=t coder-llm=active :8090=200 rc=0\n' "$(date -u -d '90 minutes ago' +%FT%TZ)" > "$tmp/w.log" + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1); rc=$? + chk " ... and 90 minutes later the gap no longer refuses" "$(printf '%s' "$out" | grep -c 'not yet')" 0 + chk " ... and the run is only PLANNED, no ticket taken" "$(printf '%s' "$out" | grep -c 'would take gpu-hold')" 1 + printf '\n%s self-test: %s\n' "$SELF" "$([ "$fail" = 0 ] && echo ok || echo "$fail failure(s)")" + return "$([ "$fail" = 0 ] && echo 0 || echo 1)" +} +[ "${1:-}" = --self-test ] && { self_test; exit $?; } + +LABEL=""; ISSUE=""; MINS=15; CMD=""; NOW=${NOW:-0}; DRY=0 +while [ $# -gt 0 ]; do case "$1" in + -n|--now) NOW=1; shift;; + --dry-run) DRY=1; shift;; + -l) LABEL=${2:-}; shift 2;; + -i) ISSUE=${2:-}; shift 2;; + -m) MINS=${2:-}; shift 2;; + -c) CMD=${2:-}; shift 2;; + -h|--help) sed -n '17,40p' "$0"; exit 0;; + *) die "unknown argument $1";; esac; done +[ -n "$LABEL" ] && [ -n "$CMD" ] || die "need -l LABEL and -c 'command'" +case "$MINS" in ''|*[!0-9]*) die "-m takes whole minutes";; esac +[ "$MINS" -ge 1 ] && [ "$MINS" -le 15 ] || die "-m $MINS is outside 1..15: every minute coder-llm is down fails the PR-agent check on every PR" + +# the 45-minute gap, from the log's END lines only (a start line is not a window end) +if [ -f "$LOG" ]; then + last_end=$(sed -n 's/^\([0-9T:-]*Z\) end .*/\1/p' "$LOG" | sort | tail -1) + if [ -n "$last_end" ]; then + end_s=$(date -u -d "$last_end" +%s 2>/dev/null || echo 0) + now_s=$(date -u +%s) + gap=$(( now_s - end_s )) + [ "$end_s" -gt 0 ] && [ "$gap" -lt 2700 ] && die "not yet: the last window ended $last_end ($(( gap / 60 )) min ago of 45 needed)" + fi +fi + +# a held ticket is not a refusal: gpu-hold is a FIFO queue, and queueing is how "one GPU job at a +# time" is honoured. --now keeps the refuse-instead-of-wait case. +tick=$(scripts/gpu-hold --status 2>/dev/null | head -1 || true) +if [ "$NOW" = 1 ]; then + case "$tick" in ""|*NONE*|*none*) : ;; *) die "--now was asked for, and a ticket is held: $tick";; esac +fi + +if [ "$DRY" = 1 ]; then + printf '%s: would take gpu-hold -t %s -l %s, stop coder-llm, run: %s\n' "$SELF" "$MINS" "$LABEL" "$CMD" + exit 0 +fi +saw_up=0; systemctl --user is-active --quiet coder-llm && saw_up=1 +[ -d "$(dirname "$LOG")" ] || mkdir -p "$(dirname "$LOG")" +printf '%s start lane=%s issue=%s label=%s mins=%s cmd=%s\n' "$(date -u +%FT%TZ)" "${LANE:-$SELF}" "$ISSUE" "$LABEL" "$MINS" "$CMD" >> "$LOG" +restore() { + local rc=${1:-0} i code=000 + if [ "$saw_up" = 1 ]; then + systemctl --user start coder-llm 2>/dev/null + for i in $(seq 1 40); do + code=$(curl -s -m 2 -o /dev/null -w '%{http_code}' http://127.0.0.1:8090/v1/models 2>/dev/null || true) + [ "$code" = 200 ] && break; sleep 3 + done + printf '%s end lane=%s issue=%s label=%s coder-llm=%s :8090=%s rc=%s\n' "$(date -u +%FT%TZ)" \ + "${LANE:-$SELF}" "$ISSUE" "$LABEL" "$(systemctl --user is-active coder-llm)" "$code" "$rc" >> "$LOG" + [ "$code" = 200 ] || printf '%s: WARNING coder-llm restarted but :8090 answers %s\n' "$SELF" "$code" >&2 + else + printf '%s end lane=%s issue=%s label=%s coder-llm=was-not-running :8090=n/a rc=%s\n' "$(date -u +%FT%TZ)" \ + "${LANE:-$SELF}" "$ISSUE" "$LABEL" "$rc" >> "$LOG" + fi +} +trap 'restore $?' EXIT +scripts/gpu-hold -t "$MINS" -l "$LABEL" -- bash -c ' + if systemctl --user is-active --quiet coder-llm; then systemctl --user stop coder-llm; fi + holder=$(sed -n "s/.*pid \([0-9]*\).*/\1/p" <<<"$(scripts/gpu-hold --status 2>/dev/null | head -1)" | head -1) + [ -n "$holder" ] && export GPU_HOLD_TICKET="${GPU_HOLD_TICKET:-$holder}" + '"$CMD"' +' From 244fc2ed96513a90c7c5bcdba31415932322d384 Mon Sep 17 00:00:00 2001 From: t Date: Sat, 14 Nov 2026 19:37:55 -0400 Subject: [PATCH 2/4] tests: the pack_modes enumeration was correct only while weekly.sh sorted last Two CI failures on #2455, both caused by the new scripts/window-run.sh, and one of them is a fleet bug that the file merely exposed. 1. tests_referenced: the script declares --self-test and no runner named it. Added `add_test(NAME window_run_self COMMAND .../scripts/window-run.sh --self-test)`. While fixing it I found the checker can be satisfied by a MENTION: it passes if any file under tests/ contains the script's name, so a COMMENT naming the script counts as a runner. My first attempt at the pack_modes fix named the file in a comment and the checker went green without any row existing. The comment no longer names it, so the row is what makes it pass - verified by deleting the row (checker complains) and restoring it (checker green). That weakness in tests_referenced_check is worth its own issue: it answers "is this string present" rather than "does a runner invoke this script". 2. pack_modes: the test is `set -euo pipefail`, and the packing-site enumeration is sites=$(for f in scripts/*.sh; do grep -q pack-elf.sh "$f" && grep -qE '\btar -C' "$f" && echo x; done | wc -l) Under pipefail the pipeline takes the status of the loop's LAST iteration. That was harmless while "weekly.sh" was the last file in the glob, because it matches the selector (status 0). A script sorting after it that does NOT match makes the last grep fail, and the whole assignment fails under set -e: the test died before its own count line, with every assertion above it "ok". So the check was correct by accident of alphabetical order - the same shape as gpu-kernels#87's two matchers at equal priority. Fixed by making "this is not a packing site" a non-error: `{ ...selector...; } || true` inside the loop, with a comment saying why. Reverting the fix reproduces the failure (rc 1); with it, ok. Both measured at this head: `bash tests/pack_modes_test.sh` rc 0, `tools/ci/tests_referenced_check.py` green for the right reason, and `scripts/pre-pr-checks.sh` all green. --- CMakeLists.txt | 3 +++ tests/pack_modes_test.sh | 6 +++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index fb5eae707..3a556ab1c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2611,3 +2611,6 @@ foreach(_onebit_route_test IN LISTS _onebit_route_tests) endif() endforeach() +# engine#2455: the window runner self-test, which tests_referenced_check requires a runner for: the +# claim is that its refusals hold, so it has to run somewhere other than by hand. +add_test(NAME window_run_self COMMAND ${CMAKE_SOURCE_DIR}/scripts/window-run.sh --self-test) diff --git a/tests/pack_modes_test.sh b/tests/pack_modes_test.sh index 0be3f3f23..e6f4998ba 100755 --- a/tests/pack_modes_test.sh +++ b/tests/pack_modes_test.sh @@ -127,7 +127,11 @@ for f in "$here"/../scripts/*.sh; do done # A floor, not an exact count: a fifth packing site that does carry the guard is a good change, and failing on it # would teach the next person to edit the test instead of the packer. The per-site loop above is the real assertion. -sites=$(for f in "$here"/../scripts/*.sh; do grep -q 'pack-elf.sh' "$f" && grep -qE '\btar -C' "$f" && echo x; done | wc -l) +# `|| true` because of `set -o pipefail`: the loop's status is its LAST iteration's, so any script +# that sorts after the last packing site and does not match the selector made this pipeline fail. +# engine#2455 is exactly that - the check was correct only while "weekly.sh" +# happened to be the last file in the glob. A selector deciding "not a packing site" is not an error. +sites=$(for f in "$here"/../scripts/*.sh; do { grep -q 'pack-elf.sh' "$f" && grep -qE '\btar -C' "$f" && echo x; } || true; done | wc -l) check "the enumeration found every known packing site (>= 3)" "$([ "$sites" -ge 3 ] && echo yes || echo no)" "yes" rm -rf "$(dirname "$stage")" From 915478468d0c71d7784ef522a6673f6f8cdcf66b Mon Sep 17 00:00:00 2001 From: t Date: Sat, 14 Nov 2026 20:26:37 -0400 Subject: [PATCH 3/4] window-run: say when the 45-minute gap could not be checked The gap check reads ~/briefs/WINDOWS.log. Measured tonight: twenty lane scripts in ~/lb stop and start coder-llm, and NONE of them writes that file - they log to window-chain.log and per-arm files instead. So the rule this script enforces was unenforceable for exactly the runs it exists for, and a log with nothing in it is not evidence that no window happened. The script now says which of the three it is, on stderr, without changing what it does: * the last END is more than 4 h old -> "windows that do not write are invisible to this check" * the log exists but has no END line -> "the 45-minute gap is UNCHECKED here" * there is no log at all -> the same, naming the path Four arms pin the branches, including one that a fresh window still plans normally, so the note cannot become a refusal by accident. Removing the stale-log branch turns the suite red; restored, green. Self-test 13 arms; pre-pr-checks all green. --- scripts/window-run.sh | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/scripts/window-run.sh b/scripts/window-run.sh index d453246da..16e04d6b9 100755 --- a/scripts/window-run.sh +++ b/scripts/window-run.sh @@ -61,6 +61,20 @@ self_test() { out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1); rc=$? chk " ... and 90 minutes later the gap no longer refuses" "$(printf '%s' "$out" | grep -c 'not yet')" 0 chk " ... and the run is only PLANNED, no ticket taken" "$(printf '%s' "$out" | grep -c 'would take gpu-hold')" 1 + # 5. the gap check says when it could not check: a stale log, a log with no END line, and no log at + # all. Twenty lane scripts in ~/lb stop coder-llm without writing this file, so silence here is + # not evidence that no window happened - each branch has to be able to say its own name. + printf '%s end lane=t issue=0 label=t coder-llm=active :8090=200 rc=0\n' "$(date -u -d '20 hours ago' +%FT%TZ)" > "$tmp/w.log" + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1) + chk "a stale log is called out, not silently trusted" "$(printf '%s' "$out" | grep -c 'invisible to this check')" 1 + : > "$tmp/w.log" + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1) + chk "a log with no END line says the gap is UNCHECKED" "$(printf '%s' "$out" | grep -c 'UNCHECKED')" 1 + rm -f "$tmp/w.log" + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1) + chk "and no log at all says so too" "$(printf '%s' "$out" | grep -c 'no .*UNCHECKED\|UNCHECKED')" 1 + chk " ... while a fresh window still plans normally" "$(printf '%s' "$out" | grep -c 'would take gpu-hold')" 1 + printf '\n%s self-test: %s\n' "$SELF" "$([ "$fail" = 0 ] && echo ok || echo "$fail failure(s)")" return "$([ "$fail" = 0 ] && echo 0 || echo 1)" } @@ -88,7 +102,18 @@ if [ -f "$LOG" ]; then now_s=$(date -u +%s) gap=$(( now_s - end_s )) [ "$end_s" -gt 0 ] && [ "$gap" -lt 2700 ] && die "not yet: the last window ended $last_end ($(( gap / 60 )) min ago of 45 needed)" + # Honesty about what this check actually covered: on 2026-11-15 twenty lane scripts in ~/lb were + # found to stop and start coder-llm WITHOUT writing this file, so the gap above is only as good as + # the runs that log. A stale (or empty) log is not evidence that no window happened. + if [ "$end_s" -gt 0 ] && [ "$gap" -gt 14400 ]; then + printf '%s: note: the last logged window ended %s (%s h ago); windows that do not write %s are invisible to this check\n' \ + "$SELF" "$last_end" "$(( gap / 3600 ))" "$LOG" >&2 + fi + else + printf '%s: note: %s exists but has no END line, so the 45-minute gap is UNCHECKED here\n' "$SELF" "$LOG" >&2 fi +else + printf '%s: note: no %s, so the 45-minute gap is UNCHECKED here\n' "$SELF" "$LOG" >&2 fi # a held ticket is not a refusal: gpu-hold is a FIFO queue, and queueing is how "one GPU job at a From 8fff489a5913a81d884e975192fe2f79ec33ea9a Mon Sep 17 00:00:00 2001 From: t Date: Sat, 14 Nov 2026 21:27:26 -0400 Subject: [PATCH 4/4] window-run: --wait holds the lane instead of making it come back A window that is legally 15 minutes away is not a reason to write IDLE and end a turn, and it is not a reason for a person to remember the minute it opens. --wait turns "come back" into "queue and run", the same service gpu-hold already does for the ticket itself. It does not shorten anything: the rule stays 45 minutes from the last logged END, the loop only re-reads the clock every 30 s, and every other guard (the 1..15 minute cap, the child, the ticket, coder-llm) still applies afterwards. The refusal now says so - "not yet: ... (-w waits for it)" - so a lane that runs it by hand learns the flag exists from the failure. Two arms pin the boundary from the side a self-test can reach: five minutes inside the gap, a plain run still refuses, and the message names -w. The waiting loop itself is deliberately not exercised - an arm that slept 40 minutes is not a self-test. Removing the refusal turns the suite red; restored, green. pre-pr-checks all green. --- scripts/window-run.sh | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/scripts/window-run.sh b/scripts/window-run.sh index 16e04d6b9..32dff80d0 100755 --- a/scripts/window-run.sh +++ b/scripts/window-run.sh @@ -75,15 +75,24 @@ self_test() { chk "and no log at all says so too" "$(printf '%s' "$out" | grep -c 'no .*UNCHECKED\|UNCHECKED')" 1 chk " ... while a fresh window still plans normally" "$(printf '%s' "$out" | grep -c 'would take gpu-hold')" 1 + # 6. --wait holds the lane instead of refusing, and it refuses to *shorten* the rule: a window 5 min + # inside the gap still has ~40 min to go, which the message must say. (The loop itself is not + # exercised here - an arm that slept 40 minutes is not a self-test.) + printf '%s end lane=t issue=0 label=t coder-llm=active :8090=200 rc=0\n' "$(date -u -d '40 minutes ago' +%FT%TZ)" > "$tmp/w.log" + out=$(WINDOWS_LOG=$tmp/w.log "$0" --dry-run -m 5 -l x -c true 2>&1) + chk "5 min inside the gap: a plain run still refuses" "$(printf '%s' "$out" | grep -c 'not yet')" 1 + chk " ... and names -w as the way to wait" "$(printf '%s' "$out" | grep -c '\-w waits for it')" 1 + printf '\n%s self-test: %s\n' "$SELF" "$([ "$fail" = 0 ] && echo ok || echo "$fail failure(s)")" return "$([ "$fail" = 0 ] && echo 0 || echo 1)" } [ "${1:-}" = --self-test ] && { self_test; exit $?; } -LABEL=""; ISSUE=""; MINS=15; CMD=""; NOW=${NOW:-0}; DRY=0 +LABEL=""; ISSUE=""; MINS=15; CMD=""; NOW=${NOW:-0}; DRY=0; WAIT=0 while [ $# -gt 0 ]; do case "$1" in -n|--now) NOW=1; shift;; --dry-run) DRY=1; shift;; + -w|--wait) WAIT=1; shift;; -l) LABEL=${2:-}; shift 2;; -i) ISSUE=${2:-}; shift 2;; -m) MINS=${2:-}; shift 2;; @@ -101,7 +110,19 @@ if [ -f "$LOG" ]; then end_s=$(date -u -d "$last_end" +%s 2>/dev/null || echo 0) now_s=$(date -u +%s) gap=$(( now_s - end_s )) - [ "$end_s" -gt 0 ] && [ "$gap" -lt 2700 ] && die "not yet: the last window ended $last_end ($(( gap / 60 )) min ago of 45 needed)" + if [ "$end_s" -gt 0 ] && [ "$gap" -lt 2700 ]; then + left=$(( (2700 - gap + 59) / 60 )) + if [ "$WAIT" = 1 ] && [ "$DRY" != 1 ]; then + # --wait: hold the lane here instead of making it come back. The rule is unchanged - this only + # stops *running*, it never shortens the 45 minutes - and it is the same service gpu-hold does + # for a ticket, which is why a lane that waits out a window by hand is doing the queue's job. + printf '%s: waiting %s min for the 45-minute gap (last window ended %s)\n' "$SELF" "$left" "$last_end" >&2 + while [ "$gap" -lt 2700 ]; do sleep 30; gap=$(( $(date -u +%s) - end_s )); done + printf '%s: the gap is open after waiting %s min\n' "$SELF" "$left" >&2 + else + die "not yet: the last window ended $last_end ($(( gap / 60 )) min ago of 45 needed; -w waits for it)" + fi + fi # Honesty about what this check actually covered: on 2026-11-15 twenty lane scripts in ~/lb were # found to stop and start coder-llm WITHOUT writing this file, so the gap above is only as good as # the runs that log. A stale (or empty) log is not evidence that no window happened.