@oneie/claude 0.5.0 → 0.7.0

package/scripts/chrome.mjs

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+/**
+ * chrome.mjs — headless-shell browser driver. Replaces the `claude-in-chrome`
+ * MCP tools for every non-interactive job: PROVE gates, page diagnostics,
+ * scraping, form drills, screenshots.
+ *
+ * Engine: chrome-headless-shell, launched through Playwright's
+ * `chromium-headless-shell` channel. No extension, no Chrome profile, no
+ * running desktop browser, no human in the loop. One process per invocation.
+ *
+ * Usage:
+ *   node .claude/scripts/chrome.mjs <url> [flags]
+ *
+ * Flags:
+ *   --text                 include page innerText (truncated, see --max)
+ *   --html                 include page HTML (truncated, see --max)
+ *   --sel <css>            scope --text/--html to a selector
+ *   --screenshot [path]    PNG (default /tmp/chrome-shot.png); --full-page for the whole document
+ *   --console              include ALL console lines (errors are always included)
+ *   --network              include every request/response (default: /api/ only, on --network-all)
+ *   --network-all          widen --network past /api/
+ *   --eval <js>            evaluate an expression in the page, return its value
+ *   --do <json>            run a step list — see STEPS below
+ *   --send <msg>           chat drill: fill the first textarea, Enter, capture the SSE stream
+ *   --wait <ms>            settle time after load (default 2500)
+ *   --timeout <ms>         navigation timeout (default 20000)
+ *   --state <path>         persist cookies + localStorage to <path> and reuse them next
+ *                          run — the one thing a fresh process cannot have on its own
+ *   --cookie <n=v>         add a cookie for the target host (repeatable)
+ *   --header <k: v>        extra HTTP header (repeatable)
+ *   --ua <string>          user agent
+ *   --viewport <WxH>       viewport (default 1280x800)
+ *   --headed               use full Chromium with a visible window instead of the shell
+ *   --max <n>              truncation ceiling for text/html/eval (default 4000)
+ *
+ * STEPS (--do) — a JSON array, executed in order, each a single-key object:
+ *   {"goto":"https://…"}            navigate
+ *   {"click":"<css|text=…>"}        click
+ *   {"fill":"<css>","value":"…"}    fill an input
+ *   {"press":"Enter","sel":"<css>"} key press (sel optional → page-level)
+ *   {"select":"<css>","value":"…"}  <select> option
+ *   {"dblclick":"<css>"}            double click
+ *   {"hover":"<css>"}               hover
+ *   {"check":"<css>","value":false} check / uncheck a box (value defaults true)
+ *   {"upload":"<css>","files":[…]}  set file inputs
+ *   {"scroll":600} | {"scroll":"<css>"}  wheel by px, or scroll a node into view
+ *   {"wait":1500}                   sleep ms
+ *   {"waitFor":"<css>"}             wait for a selector
+ *   {"eval":"<js>"}                 evaluate, appended to steps[].result
+ *   {"screenshot":"/path.png"}      capture mid-run
+ * Every step reports {step, ok, error?, result?} — a failed step does not abort the run.
+ *
+ * Env:
+ *   PROVE_SESSION_COOKIE   "name=value" — same contract as browser-check.mjs
+ *   ONE_PLAYWRIGHT_DIR     explicit path to a node_modules dir holding playwright
+ *
+ * Output: one JSON report on stdout. Exit 0 = the run completed (read httpStatus
+ * and jsErrors for the verdict); exit 1 = the browser could not run at all.
+ */
+
+import { createRequire } from 'node:module'
+import { existsSync, readdirSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { execFileSync } from 'node:child_process'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const REPO = resolve(HERE, '../..')
+
+// ---------------------------------------------------------------- playwright
+// No package name is hardcoded — this must work in any tree that has Playwright
+// somewhere, at the root or in a workspace member. A linked worktree has no
+// node_modules of its own, so the main worktree is probed too, via git's common
+// dir. Never hardcode an absolute user path.
+const SKIP_DIR = /^(\.|node_modules$|dist$|build$|target$|\.git$)/
+
+function subdirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((d) => d.isDirectory() && !SKIP_DIR.test(d.name))
+      .map((d) => join(dir, d.name))
+  } catch { return [] }
+}
+
+function playwrightRoots() {
+  const roots = []
+  if (process.env.ONE_PLAYWRIGHT_DIR) roots.push(process.env.ONE_PLAYWRIGHT_DIR)
+
+  const trees = [REPO]
+  try {
+    const common = execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+      cwd: REPO, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    if (common) trees.push(dirname(common))
+  } catch { /* not a git tree — fine */ }
+
+  // Root first, then workspace members up to two levels down. Bounded on
+  // purpose: deep enough for `<app>/<surface>/node_modules`, shallow enough
+  // never to walk a whole tree.
+  for (const t of trees) {
+    roots.push(join(t, 'node_modules'))
+    for (const d1 of subdirs(t)) {
+      roots.push(join(d1, 'node_modules'))
+      for (const d2 of subdirs(d1)) roots.push(join(d2, 'node_modules'))
+    }
+  }
+  roots.push('/tmp/node_modules') // legacy browser-check location
+  return [...new Set(roots)]
+}
+
+function loadPlaywright() {
+  for (const root of playwrightRoots()) {
+    const entry = join(root, 'playwright', 'index.js')
+    if (!existsSync(entry)) continue
+    try {
+      return { mod: createRequire(join(root, 'noop.js'))('playwright'), from: root }
+    } catch { /* try the next root */ }
+  }
+  return null
+}
+
+const pw = loadPlaywright()
+if (!pw) {
+  console.error(JSON.stringify({
+    error: 'playwright_not_found',
+    searched: playwrightRoots(),
+    fix: 'install playwright in this tree, then: npx playwright install chromium-headless-shell',
+  }, null, 2))
+  process.exit(1)
+}
+const { chromium } = pw.mod
+
+// ---------------------------------------------------------------------- args
+const argv = process.argv.slice(2)
+const flag = (name) => argv.includes(`--${name}`)
+const val = (name, fallback = null) => {
+  const i = argv.indexOf(`--${name}`)
+  if (i === -1) return fallback
+  const v = argv[i + 1]
+  return v === undefined || v.startsWith('--') ? true : v
+}
+const all = (name) => argv.flatMap((a, i) => (a === `--${name}` && argv[i + 1] && !argv[i + 1].startsWith('--') ? [argv[i + 1]] : []))
+
+const url = argv.find((a) => /^(https?|file):\/\//.test(a)) ?? 'http://localhost:4321'
+const MAX = Number(val('max', 4000)) || 4000
+const waitMs = Number(val('wait', 2500)) || 0
+const timeout = Number(val('timeout', 20000)) || 20000
+const cut = (s) => (typeof s === 'string' && s.length > MAX ? `${s.slice(0, MAX)}…[+${s.length - MAX}]` : s)
+
+let steps = []
+const doArg = val('do')
+if (typeof doArg === 'string') {
+  try { steps = JSON.parse(doArg) } catch (e) {
+    console.error(JSON.stringify({ error: 'bad_steps_json', detail: e.message }, null, 2))
+    process.exit(1)
+  }
+  if (!Array.isArray(steps)) { console.error(JSON.stringify({ error: 'steps_must_be_array' })); process.exit(1) }
+}
+
+// ------------------------------------------------------------------- browser
+const headed = flag('headed')
+let browser
+try {
+  browser = headed
+    ? await chromium.launch({ headless: false })
+    : await chromium.launch({ channel: 'chromium-headless-shell' })
+} catch (e) {
+  // Channel missing (shell not installed) → plain headless chromium still works.
+  try {
+    browser = await chromium.launch({ headless: !headed })
+  } catch (e2) {
+    console.error(JSON.stringify({
+      error: 'browser_launch_failed', shell: e.message, fallback: e2.message,
+      fix: 'npx playwright install chromium-headless-shell',
+    }, null, 2))
+    process.exit(1)
+  }
+}
+
+// --state gives this tool the one thing a fresh process cannot have: a session
+// that survives the run. Sign in once with --state, and every later invocation
+// reuses the cookies and localStorage instead of re-authenticating.
+const statePath = typeof val('state') === 'string' ? val('state') : null
+const stateLoaded = Boolean(statePath && existsSync(statePath))
+
+const [vw, vh] = String(val('viewport', '1280x800')).split('x').map(Number)
+const context = await browser.newContext({
+  viewport: { width: vw || 1280, height: vh || 800 },
+  ...(stateLoaded ? { storageState: statePath } : {}),
+  ...(typeof val('ua') === 'string' ? { userAgent: val('ua') } : {}),
+  ...(all('header').length
+    ? { extraHTTPHeaders: Object.fromEntries(all('header').map((h) => {
+        const i = h.indexOf(':')
+        return [h.slice(0, i).trim(), h.slice(i + 1).trim()]
+      })) }
+    : {}),
+})
+
+const cookieSpecs = [...all('cookie'), ...(process.env.PROVE_SESSION_COOKIE ? [process.env.PROVE_SESSION_COOKIE] : [])]
+if (cookieSpecs.length && /^https?:/.test(url)) { // a file:// url has no host to scope a cookie to
+  const { hostname } = new URL(url)
+  await context.addCookies(cookieSpecs.flatMap((spec) => {
+    const [name, ...rest] = spec.split('=')
+    const value = rest.join('=')
+    return name && value ? [{ name, value, domain: hostname, path: '/' }] : []
+  }))
+}
+
+const page = await context.newPage()
+
+// ------------------------------------------------------------------ recorders
+const consoleLogs = []
+const jsErrors = []
+const requests = []
+page.on('console', (m) => consoleLogs.push({ type: m.type(), text: m.text().slice(0, 500) }))
+page.on('pageerror', (e) => jsErrors.push(String(e).slice(0, 500)))
+
+const wantNetwork = flag('network') || flag('network-all')
+const netAll = flag('network-all')
+if (wantNetwork) {
+  page.on('response', async (r) => {
+    const u = r.url()
+    if (!netAll && !u.includes('/api/')) return
+    requests.push({ method: r.request().method(), status: r.status(), url: u.split('?')[0] })
+  })
+}
+
+// SSE/chat capture — kept byte-for-byte compatible with browser-check.mjs so
+// `--send` reports the same chatCapture shape /do PROVE steps already read.
+const sendMsg = typeof val('send') === 'string' ? val('send') : null
+if (sendMsg) {
+  await page.addInitScript(() => {
+    const orig = window.fetch
+    window.__chatCapture = []
+    window.fetch = async (...args) => {
+      const u = args[0]?.toString() || ''
+      if (u.includes('/api/chat') && !u.includes('warmup') && !u.includes('tts')) {
+        const method = args[1]?.method || 'GET'
+        const body = typeof args[1]?.body === 'string' ? args[1].body : ''
+        if (method === 'POST') {
+          window.__chatCapture.push({ type: 'request', body: body.substring(0, 200) })
+          const resp = await orig(...args)
+          const reader = resp.clone().body?.getReader()
+          if (reader) {
+            let chunks = ''
+            for (;;) {
+              const { done, value } = await reader.read()
+              if (done) break
+              chunks += new TextDecoder().decode(value)
+            }
+            window.__chatCapture.push({ type: 'stream', status: resp.status, body: chunks.substring(0, 800) })
+          }
+          return resp
+        }
+      }
+      return orig(...args)
+    }
+  })
+}
+
+// ---------------------------------------------------------------------- load
+let httpStatus = 0
+let navError = null
+try {
+  const res = await page.goto(url, { waitUntil: 'load', timeout })
+  httpStatus = res ? res.status() : 0
+} catch (e) {
+  navError = e.message
+}
+if (waitMs) await page.waitForTimeout(waitMs)
+
+const title = await page.title().catch(() => null)
+const railBefore = sendMsg
+  ? await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 200) || null).catch(() => null)
+  : undefined
+
+// --------------------------------------------------------------------- steps
+const stepResults = []
+for (const [i, step] of steps.entries()) {
+  const kind = Object.keys(step)[0]
+  const rec = { step: i, kind, ok: true }
+  try {
+    if (step.goto) { const r = await page.goto(step.goto, { waitUntil: 'load', timeout }); rec.result = r?.status() ?? 0 }
+    else if (step.click) await page.click(step.click, { timeout: 8000 })
+    else if (step.fill !== undefined) await page.fill(step.fill, String(step.value ?? ''), { timeout: 8000 })
+    else if (step.press) { step.sel ? await page.press(step.sel, step.press) : await page.keyboard.press(step.press) }
+    else if (step.select) await page.selectOption(step.select, String(step.value ?? ''))
+    else if (step.dblclick) await page.dblclick(step.dblclick, { timeout: 8000 })
+    else if (step.hover) await page.hover(step.hover, { timeout: 8000 })
+    else if (step.check) await page.setChecked(step.check, step.value !== false, { timeout: 8000 })
+    else if (step.upload) await page.setInputFiles(step.upload, [].concat(step.files ?? step.value ?? []), { timeout: 8000 })
+    else if (step.scroll !== undefined) {
+      // window.scrollBy, not mouse.wheel — the wheel needs a pointer parked over
+      // the document and silently scrolls nothing in the headless shell when it
+      // isn't (measured: {"scroll":1200} left scrollY at 0 on a 4000px page).
+      typeof step.scroll === 'string'
+        ? await page.evaluate((s) => document.querySelector(s)?.scrollIntoView({ block: 'center' }), step.scroll)
+        : await page.evaluate((px) => window.scrollBy(0, px), Number(step.scroll))
+    }
+    else if (step.wait) await page.waitForTimeout(Number(step.wait))
+    else if (step.waitFor) await page.waitForSelector(step.waitFor, { timeout: 10000 })
+    else if (step.eval) rec.result = cut(JSON.stringify(await page.evaluate(step.eval)))
+    else if (step.screenshot) { await page.screenshot({ path: step.screenshot, fullPage: flag('full-page') }); rec.result = step.screenshot }
+    else { rec.ok = false; rec.error = `unknown step kind: ${kind}` }
+  } catch (e) {
+    rec.ok = false
+    rec.error = e.message.split('\n')[0].slice(0, 300)
+  }
+  stepResults.push(rec)
+}
+
+// ---------------------------------------------------------------- chat drill
+let chatCapture
+let railAfter
+if (sendMsg) {
+  const ta = await page.$('textarea')
+  if (ta) {
+    await ta.fill(sendMsg)
+    await ta.press('Enter')
+    await page.waitForTimeout(Number(val('send-wait', 12000)) || 12000)
+    railAfter = await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 400) || null)
+  }
+  chatCapture = await page.evaluate(() => window.__chatCapture || [])
+}
+
+// ------------------------------------------------------------------- extract
+const sel = typeof val('sel') === 'string' ? val('sel') : null
+let text
+let html
+if (flag('text')) {
+  text = cut(await page.evaluate((s) => (s ? document.querySelector(s)?.innerText : document.body?.innerText) || '', sel))
+}
+if (flag('html')) {
+  html = cut(await page.evaluate((s) => (s ? document.querySelector(s)?.outerHTML : document.documentElement?.outerHTML) || '', sel))
+}
+
+let evalResult
+const evalJs = typeof val('eval') === 'string' ? val('eval') : null
+if (evalJs) {
+  try { evalResult = cut(JSON.stringify(await page.evaluate(evalJs))) }
+  catch (e) { evalResult = `ERROR: ${e.message.split('\n')[0]}` }
+}
+
+let screenshot
+if (flag('screenshot')) {
+  screenshot = typeof val('screenshot') === 'string' ? val('screenshot') : '/tmp/chrome-shot.png'
+  await page.screenshot({ path: screenshot, fullPage: flag('full-page') }).catch((e) => { screenshot = `ERROR: ${e.message}` })
+}
+
+let stateSaved
+if (statePath) {
+  try { await context.storageState({ path: statePath }); stateSaved = statePath }
+  catch (e) { stateSaved = `ERROR: ${e.message}` }
+}
+
+await browser.close()
+
+// -------------------------------------------------------------------- report
+console.log(JSON.stringify({
+  url,
+  finalUrl: page.url(),
+  engine: headed ? 'chromium (headed)' : 'chrome-headless-shell',
+  playwrightFrom: pw.from,
+  stateLoaded: statePath ? stateLoaded : undefined,
+  stateSaved,
+  httpStatus,
+  navError,
+  title,
+  jsErrors,
+  consoleErrors: consoleLogs.filter((l) => l.type === 'error').map((l) => l.text),
+  console: flag('console') ? consoleLogs : undefined,
+  network: wantNetwork ? requests : undefined,
+  steps: steps.length ? stepResults : undefined,
+  chatCapture,
+  chatRailBefore: railBefore,
+  chatRailAfter: sendMsg ? railAfter : undefined,
+  text,
+  html,
+  eval: evalResult,
+  screenshot,
+}, null, 2))

package/scripts/do-accept.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# do-accept.sh — record a human's merge/abandon decision on a do/<slug> branch.
+#
+# The cost-per-accepted-change signal (the one the improvements queue flagged and
+# the trust ladder needs). Trust climbs on ACCEPTED change, not self-graded
+# rubric. Run at the merge gate: `do-accept.sh <slug> accept` when you land a
+# branch, `do-accept.sh <slug> reject` when you abandon it. Updates the rolling
+# acceptCount/acceptTotal in .do-trust.json — autonomyLevel (do-autonomous.ts)
+# reads them to decide L3 (auto-build) / L4 (auto-merge).
+#
+# Mirrors recordAccept() in one.ie/web/src/lib/do-autonomous.ts.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+TRUST="$ROOT/.do-trust.json"
+slug="${1:?usage: do-accept.sh <slug> accept|reject}"
+decision="${2:?usage: do-accept.sh <slug> accept|reject}"
+case "$decision" in accept|reject) ;; *) echo "decision must be accept|reject" >&2; exit 2 ;; esac
+
+python3 - "$TRUST" "$slug" "$decision" << 'PY'
+import json, sys, os
+trust_path, slug, decision = sys.argv[1], sys.argv[2], sys.argv[3]
+t = {}
+if os.path.exists(trust_path):
+    try: t = json.load(open(trust_path))
+    except Exception: t = {}
+t["acceptCount"] = int(t.get("acceptCount", 0)) + (1 if decision == "accept" else 0)
+t["acceptTotal"] = int(t.get("acceptTotal", 0)) + 1
+rate = t["acceptCount"] / t["acceptTotal"] if t["acceptTotal"] else 0.0
+t["acceptRate"] = round(rate, 4)
+json.dump(t, open(trust_path, "w"), indent=2)
+print(f"[do-accept] {slug} {decision} → {t['acceptCount']}/{t['acceptTotal']} accepted (rate {t['acceptRate']})")
+# echo the level gate the ladder would now allow (informational)
+if t["acceptTotal"] >= 20 and rate >= 0.9: lvl = "L4 (auto-merge eligible)"
+elif t["acceptTotal"] >= 10 and rate >= 0.7: lvl = "L3 (auto-build eligible)"
+else: lvl = "L1-L2 (build stays supervised)"
+print(f"[do-accept] trust ladder: {lvl}")
+PY

package/scripts/do-analyze.sh

@@ -7,12 +7,29 @@
 # CRITICAL (exit 1, blocks build):
 #   - deliverables: frontmatter is empty            → plan ships nothing
 #   - a ## C# cycle has no **Deliverable:** line     → cycle ships nothing (coverage hole)
+#   - a ## C# cycle has no `- [ ] W` wave checkbox   → do-auto/do-engine read the cycle as
+#                                                      already-done and FALSE-COMPLETE the plan
+#                                                      (built nothing; verified done-ui 2026-07-23)
 # HIGH (warn, does not block):
 #   - a cycle has no demo:/Cycle outcome line        → AC→test gap (no planned verification)
+#   - a promise deliverable's accept: appears in NO cycle → the promise ships broken even
+#                                                      though every cycle closes green
+#                                                      (verified factory 2026-07-28: stream,
+#                                                      walk-speed, tracer had no cycle at all —
+#                                                      they existed only in the todo's outcome:)
+#     `--strict-promise` promotes this to CRITICAL (exit 1).
 # Never edits.
-# Usage:  do-analyze.sh <todo.md>
+# Usage:  do-analyze.sh <todo.md> [--strict-promise]
 set -euo pipefail
-todo="${1:?usage: do-analyze.sh <todo.md>}"
+todo=""; strict=0
+for a in "$@"; do
+  case "$a" in
+    --strict-promise) strict=1 ;;
+    -*) echo "CRITICAL: unknown flag: $a"; exit 1 ;;
+    *) [ -n "$todo" ] || todo="$a" ;;
+  esac
+done
+[ -n "$todo" ] || { echo "usage: do-analyze.sh <todo.md> [--strict-promise]"; exit 1; }
 [ -f "$todo" ] || { echo "CRITICAL: todo not found: $todo"; exit 1; }
 
 crit=0; high=0
@@ -30,7 +47,7 @@ fi
 
 # 2. every cycle ships a deliverable AND has a planned test. Walk each ## C# section
 #    (header to the next ## header — ### W-waves and **bold** lines stay inside).
-ncyc=0; nodeliv=0; notest=0
+ncyc=0; nodeliv=0; notest=0; nowave=0
 for c in $(grep -oE '^## C[0-9]+' "$todo" | grep -oE 'C[0-9]+'); do
   ncyc=$((ncyc+1))
   block=$(awk -v c="$c" '
@@ -41,12 +58,100 @@ for c in $(grep -oE '^## C[0-9]+' "$todo" | grep -oE 'C[0-9]+'); do
   printf '%s' "$block" | grep -qE '^\*\*Deliverable' || {
     echo "CRITICAL: $c has no **Deliverable:** line (cycle ships nothing — coverage hole)"; crit=1; nodeliv=$((nodeliv+1))
   }
+  # Wave-checkbox presence: do-auto.sh _sync_status (IC3) and do-engine.js openCyclesFromTodo
+  # decide a cycle is done when its ## C# SECTION has zero `- [ ] W` lines. A cycle with NO
+  # `- [ ] W`/`- [x] W`/`- [~] W` line at all is read as already-complete → the loop builds
+  # nothing and reports "plan complete". Refuse it before build.
+  printf '%s' "$block" | grep -qE '^[[:space:]]*- \[[ x~]\] W' || {
+    echo "CRITICAL: $c has no '- [ ] W' wave checkbox in its section — do-auto/do-engine will read it as already-done and false-complete the plan (add a '### Definition of done' with '- [ ] W1..W4')"; crit=1; nowave=$((nowave+1))
+  }
   printf '%s' "$block" | grep -qiE 'demo:|^\*\*Cycle outcome' || {
     echo "HIGH: $c has no planned test (demo: or **Cycle outcome:** line)"; high=$((high+1)); notest=$((notest+1))
   }
 done
 
+# 3. PROMISE coverage: every deliverable in text/<slug>.md is served by some cycle.
+#    Checks 1-2 only ever compare the todo against ITSELF, so a plan can be internally
+#    consistent, pass ANALYZE, close every cycle green — and still leave the promise
+#    broken, discovered first at settle. This reads the promise.
+#    Matching rule: the deliverable's whole `accept:` command, whitespace-normalised, must
+#    appear inside a `## C<n>` SECTION (its demo.command or body). Frontmatter (where
+#    `outcome:` restates every accept: verbatim) and `Correct-course` blocks are NOT corpus —
+#    that is exactly where the three missing factory deliverables did appear, which is why
+#    the gap was invisible. Trailing boundary stops `... view` matching `... view-gaps`.
+promise="$(dirname "$todo")/$(basename "$todo" -todo.md).md"
+pndel=0; pcov=0; puncov=0
+if [ -f "$promise" ]; then
+  accepts=$(awk '
+    /^---[[:space:]]*$/ { d++; if (d>=2) exit; next }
+    d!=1 { next }
+    /^deliverables:[[:space:]]*$/ { f=1; next }
+    f && /^[A-Za-z_][A-Za-z0-9_-]*:/ { f=0 }
+    !f { next }
+    /^[[:space:]]*-?[[:space:]]*item:[[:space:]]*/ {
+      it=$0; sub(/^[[:space:]]*-?[[:space:]]*item:[[:space:]]*/,"",it); item=unq(it); next
+    }
+    /^[[:space:]]*accept:[[:space:]]*/ {
+      ac=$0; sub(/^[[:space:]]*accept:[[:space:]]*/,"",ac); ac=unq(ac)
+      gsub(/[[:space:]]+/," ",ac); sub(/^ /,"",ac); sub(/ $/,"",ac)
+      if (ac != "") printf "%s\t%s\n", ac, item
+    }
+    # strip the YAML quote wrapper, then unescape \" so a single-quoted promise and a
+    # double-quoted todo demo of the SAME command still compare equal
+    function unq(s) {
+      sub(/[[:space:]]+$/,"",s)
+      if (s ~ /^".*"$/ || s ~ /^'"'"'.*'"'"'$/) s=substr(s,2,length(s)-2)
+      gsub(/\\"/,"\"",s)
+      return s
+    }
+  ' "$promise")
+  # cycle corpus: ## C<n> sections only, whitespace-normalised, one line per source line
+  corpus=$(awk '
+    /^---[[:space:]]*$/ { d++; next }
+    d<2 { next }
+    # depth-aware: a cycle section runs until a heading at the SAME-OR-SHALLOWER depth.
+    # `#### W3 edit` inside `### C1` stays in; `## Cycles`/`### C2` ends it. Correct-course
+    # is excluded at ANY depth (a `#### Correct-course` nested inside a cycle would
+    # otherwise re-open the exact blind spot this check exists to close).
+    /^#+[[:space:]]*C[0-9]+([[:space:]]|$)/ { match($0,/^#+/); opd=RLENGTH; inc=1; next }
+    tolower($0) ~ /^#+[[:space:]]*.*correct-course/ { inc=0; next }
+    /^#+[[:space:]]/ { match($0,/^#+/); if (RLENGTH<=opd) { inc=0; next } }
+    inc { gsub(/\\"/,"\""); gsub(/[[:space:]]+/," "); sub(/^ /,""); sub(/ $/,""); if ($0 != "") print }
+  ' "$todo")
+  pndel=$(printf '%s' "$accepts" | grep -c . || true)
+  # cycles as the CORPUS sees them — `### C1` under a `## Cycles` parent is a real cycle
+  # even though check #2's `^## C#` scan (unchanged) doesn't count it.
+  pcyc=$(grep -cE '^#+[[:space:]]*C[0-9]+([[:space:]]|$)' "$todo" || true)
+  if [ "$pndel" -gt 0 ] && [ "$pcyc" -eq 0 ]; then
+    echo "HIGH: promise-coverage CANNOT RUN — $promise has $pndel deliverables but no 'C<n>' cycle section parsed in $todo"
+    high=$((high+1)); pndel=0
+  elif [ "$pndel" -gt 0 ]; then
+    while IFS=$'\t' read -r ac item; do
+      [ -n "$ac" ] || continue
+      if printf '%s\n' "$corpus" | awk -v s="$ac" '
+        { p=index($0,s); while (p>0) {
+            c=substr($0,p+length(s),1)
+            if (c=="" || c !~ /[A-Za-z0-9_.\/-]/) { found=1; exit }
+            rest=substr($0,p+1); q=index(rest,s); if (q==0) break; p=p+q
+          } }
+        END { exit !found }
+      '; then
+        pcov=$((pcov+1))
+      else
+        puncov=$((puncov+1))
+        lvl="HIGH"; [ "$strict" -eq 1 ] && lvl="CRITICAL"
+        echo "$lvl: promise deliverable has NO cycle — accept: $ac"
+        [ -n "${item:-}" ] && echo "        item: $item"
+        if [ "$strict" -eq 1 ]; then crit=1; else high=$((high+1)); fi
+      fi
+    done <<< "$accepts"
+  fi
+fi
+
 echo "----"
-echo "coverage: $ndel deliverables / $ncyc cycles · cycles-without-deliverable=$nodeliv · cycles-without-test=$notest · high=$high"
+echo "coverage: $ndel deliverables / $ncyc cycles · cycles-without-deliverable=$nodeliv · cycles-without-wave=$nowave · cycles-without-test=$notest · high=$high"
+if [ "$pndel" -gt 0 ]; then
+  echo "promise-coverage: $pndel promised / $pcov covered / $puncov uncovered · promise=$promise$([ "$strict" -eq 1 ] && echo ' · strict')"
+fi
 if [ "$crit" -ne 0 ]; then echo "ANALYZE: CRITICAL — fix coverage before build"; exit 1; fi
 echo "ANALYZE: pass (every cycle ships + is testable)"; exit 0