MrCoder · August 1, 2026 12:11
diff --git a/overnight-1-SKILL.md b/overnight-1-SKILL.md
diff --git a/overnight-2-PREFLIGHT.md b/overnight-2-PREFLIGHT.md
diff --git a/overnight-3-LOOP.md b/overnight-3-LOOP.md
diff --git a/overnight-scripts-usage.sh b/overnight-scripts-usage.sh
 #!/usr/bin/env bash
 # usage.sh — read the LIVE Claude usage meters over HTTP. No browser, no model tokens.
 #
 # Replaced the old Playwright meter-scrape of claude.ai/settings/usage (deleted 2026-07-25):
 # ~0.5s, no Cloudflare challenge, no storageState to go stale, no browser at all.
 #
 # Source of truth: GET https://api.anthropic.com/api/oauth/usage — the exact endpoint
 # Claude Code's own /usage panel calls (binary string: "fetchUtilization: GET /api/oauth/usage").
 # Undocumented, so it can change without notice; the script fails closed if the shape shifts.
 #
 # Auth: the OAuth access token Claude Code already holds. Read-only — this script NEVER
 # writes or refreshes the credential (a refresh_token grant rotates the token and would
 # break the running CLI's session). While a Claude session is alive it keeps the stored
 # token fresh on its own, which is exactly the overnight case.
 #
 # Output JSON (stdout):
 #   { ok, session, weeklyAll, weeklySonnet, weeklyOpus, weeklyScoped[], extraUsage,
 #     sessionResets, weeklyResets, sessionResetsAt, weeklyResetsAt, plan, source, ts }
 # Percentages are integers 0-100 (same scale as the claude.ai meters).
 # The weekly gate is `weeklyAll`. The per-model meters are informational only.
 # Exit 0 = ok. Exit 2 = fail-closed (no auth / expired / bad shape / network) — the
 # overnight watcher must treat exit!=0 as OVERNIGHT_STALL and pause rather than burn blind.

 set -uo pipefail

 CLAUDE_VERSION="$(ls -1 "$HOME/.local/share/claude/versions" 2>/dev/null | sort -V | tail -1)"
 : "${CLAUDE_VERSION:=2.1.220}"
 # The UA must look like the real CLI: an unrecognised UA lands in an aggressively
 # rate-limited bucket and gets persistent 429s.
 UA="claude-cli/${CLAUDE_VERSION} (external, cli)"

 fail() {
  printf '{"ok":false,"reason":"%s","ts":"%s"}\n' "$1" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  exit 2
 }

 # ---- token ---------------------------------------------------------------
 RAW=""
 if [ -n "${CLAUDE_CODE_OAUTH_TOKEN:-}" ]; then
  RAW="{\"claudeAiOauth\":{\"accessToken\":\"${CLAUDE_CODE_OAUTH_TOKEN}\"}}"
 elif command -v security >/dev/null 2>&1 && \
     RAW="$(security find-generic-password -s 'Claude Code-credentials' -a "$USER" -w 2>/dev/null)" && \
     [ -n "$RAW" ]; then
  :                                   # macOS keychain (the normal path)
 elif [ -f "$HOME/.claude/.credentials.json" ]; then
  RAW="$(cat "$HOME/.claude/.credentials.json")"   # Linux / devcontainer
 else
  fail "no-credentials"
 fi

 read -r TOKEN PLAN EXPIRED <<EOF
 $(printf '%s' "$RAW" | python3 -c '
 import sys, json, time
 try:
    o = json.load(sys.stdin).get("claudeAiOauth") or {}
 except Exception:
    print("- - shape"); raise SystemExit
 t = o.get("accessToken")
 if not t:
    print("- - missing"); raise SystemExit
 exp = o.get("expiresAt")
 expired = "yes" if (exp and exp/1000 < time.time()) else "no"
 print(t, o.get("subscriptionType") or "unknown", expired)
 ' 2>/dev/null)
 EOF

 [ "${TOKEN:--}" = "-" ] && fail "credential-${EXPIRED:-unreadable}"
 # An expired token is still worth one attempt — the CLI may have just rotated it and
 # lost the race with our read. A real 401 below turns into fail-closed anyway.

 # ---- fetch ---------------------------------------------------------------
 # The endpoint is aggressively rate-limited — measured: ~15 calls in a minute earns a 429
 # with `retry-after: 41`. Poll no tighter than the heartbeat (30 min is far inside the
 # budget). One retry that honours `retry-after` absorbs a transient 429 so a blip doesn't
 # stall the whole run.
 HDRS="$(mktemp -t overnight-usage)"
 trap 'rm -f "$HDRS"' EXIT

 fetch() {
  curl -sS --max-time 20 -D "$HDRS" -w '\n%{http_code}' https://api.anthropic.com/api/oauth/usage \
    -H "Authorization: Bearer ${TOKEN}" \
    -H "anthropic-beta: oauth-2025-04-20" \
    -H "Content-Type: application/json" \
    -H "User-Agent: ${UA}" 2>/dev/null
 }

 BODY="$(fetch)" || fail "network-error"
 if [ "$(printf '%s' "$BODY" | tail -1)" = "429" ]; then
  WAIT="$(awk 'tolower($1) ~ /^retry-after:/ {gsub(/[^0-9]/,"",$2); print $2}' "$HDRS" | tail -1)"
  case "${WAIT:-}" in ''|*[!0-9]*) WAIT=30 ;; esac
  [ "$WAIT" -gt "${OVERNIGHT_USAGE_MAX_WAIT:-120}" ] && fail "rate-limited-probe"
  sleep "$WAIT"
  BODY="$(fetch)" || fail "network-error"
 fi

 printf '%s' "$BODY" | PLAN="${PLAN:-unknown}" python3 -c '
 import sys, json, os, datetime

 raw = sys.stdin.read()
 body, _, status = raw.rpartition("\n")
 status = status.strip()

 def fail(reason):
    print(json.dumps({"ok": False, "reason": reason,
                      "ts": datetime.datetime.now(datetime.timezone.utc)
                                .strftime("%Y-%m-%dT%H:%M:%SZ")}))
    raise SystemExit(2)

 if status == "401":
    fail("token-expired-or-revoked")
 if status == "429":
    fail("rate-limited-probe")           # wrong UA, or probing far too often
 if status != "200":
    fail(f"http-{status}")
 try:
    d = json.loads(body)
 except Exception:
    fail("unparseable-body")
 if not isinstance(d, dict) or "five_hour" not in d:
    fail("unexpected-shape")             # endpoint changed → fail closed, never guess

 def pct(node):
    if not node or node.get("utilization") is None:
        return None
    return int(round(node["utilization"]))

 def when(node):
    return (node or {}).get("resets_at")

 def human(iso):
    """"Resets in 2h 30m" — LOOP.md sleeps the heartbeat to this."""
    if not iso:
        return None
    try:
        t = datetime.datetime.fromisoformat(iso)
    except ValueError:
        return None
    secs = (t - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
    if secs <= 0:
        return "Resets now"
    h, m = int(secs // 3600), int((secs % 3600) // 60)
    return f"Resets in {h}h {m}m" if h else f"Resets in {m}m"

 # Per-model weekly meters — INFORMATIONAL ONLY. The run gates on `weeklyAll`
 # (user decision 2026-07-25); these are reported so the morning report can say which
 # model meter was hot, never to make the stop decision. Which model is scoped depends
 # on the plan (Fable on Max today), so read the generic `limits` array too — never
 # assume "Sonnet" is the scoped one.
 scoped = []
 for lim in d.get("limits") or []:
    if lim.get("kind") == "weekly_scoped":
        scoped.append({
            "model": ((lim.get("scope") or {}).get("model") or {}).get("display_name"),
            "percent": lim.get("percent"),
            "resetsAt": lim.get("resets_at"),
            "severity": lim.get("severity"),
        })

 def by_model(name):
    for s in scoped:
        if (s["model"] or "").lower() == name:
            return s["percent"]
    return None

 five, seven = d.get("five_hour"), d.get("seven_day")
 extra = d.get("extra_usage") or {}

 out = {
    "ok": pct(five) is not None and pct(seven) is not None,
    "session": pct(five),
    "weeklyAll": pct(seven),
    "weeklySonnet": pct(d.get("seven_day_sonnet")) or by_model("sonnet"),
    "weeklyOpus": pct(d.get("seven_day_opus")) or by_model("opus"),
    "weeklyScoped": scoped,
    "extraUsage": {"enabled": extra.get("is_enabled"),
                   "utilization": extra.get("utilization")},
    "sessionResets": human(when(five)),
    "weeklyResets": human(when(seven)),
    "sessionResetsAt": when(five),
    "weeklyResetsAt": when(seven),
    "plan": os.environ.get("PLAN", "unknown"),
    "source": "api/oauth/usage",
    "ts": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
 }
 if not out["ok"]:
    fail("meters-null")
 print(json.dumps(out))
 '
diff --git a/overnight-scripts-watch.sh b/overnight-scripts-watch.sh
 #!/usr/bin/env bash
 # watch.sh — overnight usage watcher. ZERO model tokens: it only runs the headless
 # probe and emits sentinels that /loop's monitored output (notify_on_output) wakes the
 # coordinator on. Arm with notify_on_output regex: ^OVERNIGHT_(WAKE|TERMINATE|STALL)
 #
 # Env:
 #   OVERNIGHT_RUN_DIR      (required)  run dir for logs
 #   OVERNIGHT_SESSION_STOP (required)  stop dispatching at this session %   e.g. 80
 #   OVERNIGHT_WEEKLY_CAP   (required)  hard terminate at this weekly %      e.g. 85
 #   OVERNIGHT_INTERVAL     (default 1800)  seconds between probes
 #   OVERNIGHT_WAKE_PROMPT  (optional)  prompt sent on each wake
 set -uo pipefail

 DIR="$(cd "$(dirname "$0")" && pwd)"
 : "${OVERNIGHT_RUN_DIR:?set OVERNIGHT_RUN_DIR}"
 : "${OVERNIGHT_SESSION_STOP:?set OVERNIGHT_SESSION_STOP}"
 : "${OVERNIGHT_WEEKLY_CAP:?set OVERNIGHT_WEEKLY_CAP}"
 INTERVAL="${OVERNIGHT_INTERVAL:-1800}"
 PROMPT="${OVERNIGHT_WAKE_PROMPT:-Continue the overnight run: re-ground from state.json + NIGHT-PLAN.md and work the next dispatchable task.}"
 mkdir -p "$OVERNIGHT_RUN_DIR"

 while true; do
  # usage.sh = tokenless HTTP read of api/oauth/usage (see LOOP.md §Usage check).
  RAW="$("$DIR/usage.sh" 2>>"$OVERNIGHT_RUN_DIR/watch.err")"
  # Gate on weeklyAll (all-models). Per-model meters are informational only.
  PARSED="$(printf '%s' "$RAW" | python3 -c '
 import sys, json
 try:
    j = json.load(sys.stdin)
    if j.get("ok"):
        print("OK", j["session"], j["weeklyAll"])
    else:
        print("ERR")
 except Exception:
    print("ERR")')"
  printf '%s [watch] %s\n' "$(date -u +%FT%TZ)" "$RAW" >> "$OVERNIGHT_RUN_DIR/watch.log"

  if [ "${PARSED%% *}" != "OK" ]; then
    echo 'OVERNIGHT_STALL {"prompt":"Usage probe failed (see watch.log for the reason field: no-credentials / token-expired-or-revoked / rate-limited-probe / unexpected-shape). Fail-closed: pause work, push an alert, and restore the usage read before resuming."}'
  else
    SESSION="$(printf '%s' "$PARSED" | awk '{print $2}')"
    WEEKLY="$(printf '%s' "$PARSED" | awk '{print $3}')"
    if [ "$WEEKLY" -ge "$OVERNIGHT_WEEKLY_CAP" ] 2>/dev/null; then
      echo "OVERNIGHT_TERMINATE {\"weekly\":$WEEKLY,\"prompt\":\"Weekly cap reached ($WEEKLY% >= $OVERNIGHT_WEEKLY_CAP%). Write MORNING-REPORT.md, push the report notification, and stop the run.\"}"
      break
    elif [ "$SESSION" -lt "$OVERNIGHT_SESSION_STOP" ] 2>/dev/null; then
      echo "OVERNIGHT_WAKE {\"session\":$SESSION,\"weekly\":$WEEKLY,\"prompt\":\"$PROMPT\"}"
    fi
    # else: session over stop, weekly fine → throttled window; stay SILENT (don't wake) until reset.
  fi
  sleep "$INTERVAL"
 done
diff --git a/overnight-template-DECISIONS-FOR-MORNING.md b/overnight-template-DECISIONS-FOR-MORNING.md
diff --git a/overnight-template-MORNING-REPORT.md b/overnight-template-MORNING-REPORT.md
diff --git a/overnight-template-NIGHT-PLAN.md b/overnight-template-NIGHT-PLAN.md
diff --git a/overnight-template-state.json b/overnight-template-state.json
 {
  "run_id": "<repo>/<YYYY-MM-DD-HHMM>",
  "repo": "<abs path>",
  "base_branch": "main",
  "limits": {
    "session_stop_pct": 80,
    "weekly_cap_pct": 85,
    "weekly_start_pct": 0,
    "interval_seconds": 1800
  },
  "ceiling_default": "pr",
  "current_task": 1,
  "tasks": [
    {
      "id": 1,
      "title": "<task title>",
      "source": "prompt | issue #NN",
      "ceiling": "pr",
      "status": "todo",
      "branch": null,
      "pr": null,
      "criteria": [
        { "text": "<assertion>", "kind": "auto|spotcheck|deferred", "state": "todo|pass|skipped", "evidence": null, "blocker": null }
      ],
      "retries": {},
      "notes": null
    }
  ],
  "critical_forks": [],
  "morning_queue_count": 0,
  "night_complete": null,
  "stop_reason": null,
  "weekly_end_pct": null,
  "last_probe": { "session": null, "weeklyAll": null, "ts": null }
 }
Need	Discover / verify (look here, don't assume absent)
push / PR / babysit / issues	`gh auth status`; can you `gh repo create`? (you'll likely need new repos)
usage check (always)	`scripts/usage.sh` returns exit 0 / `ok:true` (reads the Claude Code OAuth token from the keychain)
Atlassian token (for live Confluence read/write tests)	*grep `.env` / `.dev.vars` / `wrangler.toml` / `git config` / env** — e.g. `FORGE_API_TOKEN`, `ATLASSIAN_API_TOKEN`. It's almost always already there.
live Confluence/site verification	a logged-in Playwright profile / `storageState` for the site (same mechanism as the usage probe)
Forge / Cloudflare-D1 (if in scope)	`forge whoami` / `wrangler whoami`
any MCP the goal uses	reachable now (cheap read)
	#!/usr/bin/env bash
	# usage.sh — read the LIVE Claude usage meters over HTTP. No browser, no model tokens.
	#
	# Replaced the old Playwright meter-scrape of claude.ai/settings/usage (deleted 2026-07-25):
	# ~0.5s, no Cloudflare challenge, no storageState to go stale, no browser at all.
	#
	# Source of truth: GET https://api.anthropic.com/api/oauth/usage — the exact endpoint
	# Claude Code's own /usage panel calls (binary string: "fetchUtilization: GET /api/oauth/usage").
	# Undocumented, so it can change without notice; the script fails closed if the shape shifts.
	#
	# Auth: the OAuth access token Claude Code already holds. Read-only — this script NEVER
	# writes or refreshes the credential (a refresh_token grant rotates the token and would
	# break the running CLI's session). While a Claude session is alive it keeps the stored
	# token fresh on its own, which is exactly the overnight case.
	#
	# Output JSON (stdout):
	# { ok, session, weeklyAll, weeklySonnet, weeklyOpus, weeklyScoped[], extraUsage,
	# sessionResets, weeklyResets, sessionResetsAt, weeklyResetsAt, plan, source, ts }
	# Percentages are integers 0-100 (same scale as the claude.ai meters).
	# The weekly gate is `weeklyAll`. The per-model meters are informational only.
	# Exit 0 = ok. Exit 2 = fail-closed (no auth / expired / bad shape / network) — the
	# overnight watcher must treat exit!=0 as OVERNIGHT_STALL and pause rather than burn blind.

	set -uo pipefail

	CLAUDE_VERSION="$(ls -1 "$HOME/.local/share/claude/versions" 2>/dev/null \| sort -V \| tail -1)"
	: "${CLAUDE_VERSION:=2.1.220}"
	# The UA must look like the real CLI: an unrecognised UA lands in an aggressively
	# rate-limited bucket and gets persistent 429s.
	UA="claude-cli/${CLAUDE_VERSION} (external, cli)"

	fail() {
	printf '{"ok":false,"reason":"%s","ts":"%s"}\n' "$1" "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
	exit 2
	}

	# ---- token ---------------------------------------------------------------
	RAW=""
	if [ -n "${CLAUDE_CODE_OAUTH_TOKEN:-}" ]; then
	RAW="{\"claudeAiOauth\":{\"accessToken\":\"${CLAUDE_CODE_OAUTH_TOKEN}\"}}"
	elif command -v security >/dev/null 2>&1 && \
	RAW="$(security find-generic-password -s 'Claude Code-credentials' -a "$USER" -w 2>/dev/null)" && \
	[ -n "$RAW" ]; then
	: # macOS keychain (the normal path)
	elif [ -f "$HOME/.claude/.credentials.json" ]; then
	RAW="$(cat "$HOME/.claude/.credentials.json")" # Linux / devcontainer
	else
	fail "no-credentials"
	fi

	read -r TOKEN PLAN EXPIRED <<EOF
	$(printf '%s' "$RAW" \| python3 -c '
	import sys, json, time
	try:
	o = json.load(sys.stdin).get("claudeAiOauth") or {}
	except Exception:
	print("- - shape"); raise SystemExit
	t = o.get("accessToken")
	if not t:
	print("- - missing"); raise SystemExit
	exp = o.get("expiresAt")
	expired = "yes" if (exp and exp/1000 < time.time()) else "no"
	print(t, o.get("subscriptionType") or "unknown", expired)
	' 2>/dev/null)
	EOF

	[ "${TOKEN:--}" = "-" ] && fail "credential-${EXPIRED:-unreadable}"
	# An expired token is still worth one attempt — the CLI may have just rotated it and
	# lost the race with our read. A real 401 below turns into fail-closed anyway.

	# ---- fetch ---------------------------------------------------------------
	# The endpoint is aggressively rate-limited — measured: ~15 calls in a minute earns a 429
	# with `retry-after: 41`. Poll no tighter than the heartbeat (30 min is far inside the
	# budget). One retry that honours `retry-after` absorbs a transient 429 so a blip doesn't
	# stall the whole run.
	HDRS="$(mktemp -t overnight-usage)"
	trap 'rm -f "$HDRS"' EXIT

	fetch() {
	curl -sS --max-time 20 -D "$HDRS" -w '\n%{http_code}' https://api.anthropic.com/api/oauth/usage \
	-H "Authorization: Bearer ${TOKEN}" \
	-H "anthropic-beta: oauth-2025-04-20" \
	-H "Content-Type: application/json" \
	-H "User-Agent: ${UA}" 2>/dev/null
	}

	BODY="$(fetch)" \|\| fail "network-error"
	if [ "$(printf '%s' "$BODY" \| tail -1)" = "429" ]; then
	WAIT="$(awk 'tolower($1) ~ /^retry-after:/ {gsub(/[^0-9]/,"",$2); print $2}' "$HDRS" \| tail -1)"
	case "${WAIT:-}" in ''\|[!0-9]) WAIT=30 ;; esac
	[ "$WAIT" -gt "${OVERNIGHT_USAGE_MAX_WAIT:-120}" ] && fail "rate-limited-probe"
	sleep "$WAIT"
	BODY="$(fetch)" \|\| fail "network-error"
	fi

	printf '%s' "$BODY" \| PLAN="${PLAN:-unknown}" python3 -c '
	import sys, json, os, datetime

	raw = sys.stdin.read()
	body, _, status = raw.rpartition("\n")
	status = status.strip()

	def fail(reason):
	print(json.dumps({"ok": False, "reason": reason,
	"ts": datetime.datetime.now(datetime.timezone.utc)
	.strftime("%Y-%m-%dT%H:%M:%SZ")}))
	raise SystemExit(2)

	if status == "401":
	fail("token-expired-or-revoked")
	if status == "429":
	fail("rate-limited-probe") # wrong UA, or probing far too often
	if status != "200":
	fail(f"http-{status}")
	try:
	d = json.loads(body)
	except Exception:
	fail("unparseable-body")
	if not isinstance(d, dict) or "five_hour" not in d:
	fail("unexpected-shape") # endpoint changed → fail closed, never guess

	def pct(node):
	if not node or node.get("utilization") is None:
	return None
	return int(round(node["utilization"]))

	def when(node):
	return (node or {}).get("resets_at")

	def human(iso):
	""""Resets in 2h 30m" — LOOP.md sleeps the heartbeat to this."""
	if not iso:
	return None
	try:
	t = datetime.datetime.fromisoformat(iso)
	except ValueError:
	return None
	secs = (t - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
	if secs <= 0:
	return "Resets now"
	h, m = int(secs // 3600), int((secs % 3600) // 60)
	return f"Resets in {h}h {m}m" if h else f"Resets in {m}m"

	# Per-model weekly meters — INFORMATIONAL ONLY. The run gates on `weeklyAll`
	# (user decision 2026-07-25); these are reported so the morning report can say which
	# model meter was hot, never to make the stop decision. Which model is scoped depends
	# on the plan (Fable on Max today), so read the generic `limits` array too — never
	# assume "Sonnet" is the scoped one.
	scoped = []
	for lim in d.get("limits") or []:
	if lim.get("kind") == "weekly_scoped":
	scoped.append({
	"model": ((lim.get("scope") or {}).get("model") or {}).get("display_name"),
	"percent": lim.get("percent"),
	"resetsAt": lim.get("resets_at"),
	"severity": lim.get("severity"),
	})

	def by_model(name):
	for s in scoped:
	if (s["model"] or "").lower() == name:
	return s["percent"]
	return None

	five, seven = d.get("five_hour"), d.get("seven_day")
	extra = d.get("extra_usage") or {}

	out = {
	"ok": pct(five) is not None and pct(seven) is not None,
	"session": pct(five),
	"weeklyAll": pct(seven),
	"weeklySonnet": pct(d.get("seven_day_sonnet")) or by_model("sonnet"),
	"weeklyOpus": pct(d.get("seven_day_opus")) or by_model("opus"),
	"weeklyScoped": scoped,
	"extraUsage": {"enabled": extra.get("is_enabled"),
	"utilization": extra.get("utilization")},
	"sessionResets": human(when(five)),
	"weeklyResets": human(when(seven)),
	"sessionResetsAt": when(five),
	"weeklyResetsAt": when(seven),
	"plan": os.environ.get("PLAN", "unknown"),
	"source": "api/oauth/usage",
	"ts": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
	}
	if not out["ok"]:
	fail("meters-null")
	print(json.dumps(out))
	'
	#!/usr/bin/env bash
	# watch.sh — overnight usage watcher. ZERO model tokens: it only runs the headless
	# probe and emits sentinels that /loop's monitored output (notify_on_output) wakes the
	# coordinator on. Arm with notify_on_output regex: ^OVERNIGHT_(WAKE\|TERMINATE\|STALL)
	#
	# Env:
	# OVERNIGHT_RUN_DIR (required) run dir for logs
	# OVERNIGHT_SESSION_STOP (required) stop dispatching at this session % e.g. 80
	# OVERNIGHT_WEEKLY_CAP (required) hard terminate at this weekly % e.g. 85
	# OVERNIGHT_INTERVAL (default 1800) seconds between probes
	# OVERNIGHT_WAKE_PROMPT (optional) prompt sent on each wake
	set -uo pipefail

	DIR="$(cd "$(dirname "$0")" && pwd)"
	: "${OVERNIGHT_RUN_DIR:?set OVERNIGHT_RUN_DIR}"
	: "${OVERNIGHT_SESSION_STOP:?set OVERNIGHT_SESSION_STOP}"
	: "${OVERNIGHT_WEEKLY_CAP:?set OVERNIGHT_WEEKLY_CAP}"
	INTERVAL="${OVERNIGHT_INTERVAL:-1800}"
	PROMPT="${OVERNIGHT_WAKE_PROMPT:-Continue the overnight run: re-ground from state.json + NIGHT-PLAN.md and work the next dispatchable task.}"
	mkdir -p "$OVERNIGHT_RUN_DIR"

	while true; do
	# usage.sh = tokenless HTTP read of api/oauth/usage (see LOOP.md §Usage check).
	RAW="$("$DIR/usage.sh" 2>>"$OVERNIGHT_RUN_DIR/watch.err")"
	# Gate on weeklyAll (all-models). Per-model meters are informational only.
	PARSED="$(printf '%s' "$RAW" \| python3 -c '
	import sys, json
	try:
	j = json.load(sys.stdin)
	if j.get("ok"):
	print("OK", j["session"], j["weeklyAll"])
	else:
	print("ERR")
	except Exception:
	print("ERR")')"
	printf '%s [watch] %s\n' "$(date -u +%FT%TZ)" "$RAW" >> "$OVERNIGHT_RUN_DIR/watch.log"

	if [ "${PARSED%% *}" != "OK" ]; then
	echo 'OVERNIGHT_STALL {"prompt":"Usage probe failed (see watch.log for the reason field: no-credentials / token-expired-or-revoked / rate-limited-probe / unexpected-shape). Fail-closed: pause work, push an alert, and restore the usage read before resuming."}'
	else
	SESSION="$(printf '%s' "$PARSED" \| awk '{print $2}')"
	WEEKLY="$(printf '%s' "$PARSED" \| awk '{print $3}')"
	if [ "$WEEKLY" -ge "$OVERNIGHT_WEEKLY_CAP" ] 2>/dev/null; then
	echo "OVERNIGHT_TERMINATE {\"weekly\":$WEEKLY,\"prompt\":\"Weekly cap reached ($WEEKLY% >= $OVERNIGHT_WEEKLY_CAP%). Write MORNING-REPORT.md, push the report notification, and stop the run.\"}"
	break
	elif [ "$SESSION" -lt "$OVERNIGHT_SESSION_STOP" ] 2>/dev/null; then
	echo "OVERNIGHT_WAKE {\"session\":$SESSION,\"weekly\":$WEEKLY,\"prompt\":\"$PROMPT\"}"
	fi
	# else: session over stop, weekly fine → throttled window; stay SILENT (don't wake) until reset.
	fi
	sleep "$INTERVAL"
	done
	{
	"run_id": "<repo>/<YYYY-MM-DD-HHMM>",
	"repo": "<abs path>",
	"base_branch": "main",
	"limits": {
	"session_stop_pct": 80,
	"weekly_cap_pct": 85,
	"weekly_start_pct": 0,
	"interval_seconds": 1800
	},
	"ceiling_default": "pr",
	"current_task": 1,
	"tasks": [
	{
	"id": 1,
	"title": "<task title>",
	"source": "prompt \| issue #NN",
	"ceiling": "pr",
	"status": "todo",
	"branch": null,
	"pr": null,
	"criteria": [
	{ "text": "<assertion>", "kind": "auto\|spotcheck\|deferred", "state": "todo\|pass\|skipped", "evidence": null, "blocker": null }
	],
	"retries": {},
	"notes": null
	}
	],
	"critical_forks": [],
	"morning_queue_count": 0,
	"night_complete": null,
	"stop_reason": null,
	"weekly_end_pct": null,
	"last_probe": { "session": null, "weeklyAll": null, "ts": null }
	}