@oneie/claude 0.6.0 → 0.8.0

package/scripts/blocks-usage.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+// The census, regenerable — text/blocks.md deliverable 2.
+//
+// Reads every row of the `pages` table (D1, --remote by default, --local on
+// request), resolves each page's block list EXACTLY the way production does
+// (data column when present, else componentsToPuck(parseComponents(components))
+// — see one.ie/web/src/pages/u/[slug]/p/[pageSlug].astro), tallies pagesUsing
+// (distinct pages with >=1 instance) and instances (total instances) per
+// registered block name, cross-references nonPageRefs (uses of the name
+// outside one.ie/web/src/lib/puck/), and writes
+// one.ie/web/src/lib/puck/block-usage.json.
+//
+// --check: regenerate in memory and diff against the committed file's
+// `blocks` map (measuredAt excluded from the diff). Runs with NO network/D1
+// access as long as the committed file already exists.
+//
+// Usage:
+//   node .claude/scripts/blocks-usage.mjs              # --remote, write the file
+//   node .claude/scripts/blocks-usage.mjs --local       # read local D1 instead
+//   node .claude/scripts/blocks-usage.mjs --check        # diff, no write, no D1 unless file missing
+
+import { execFileSync } from 'node:child_process'
+import { writeFileSync, readFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const REPO_ROOT = path.resolve(__dirname, '../..')
+const WEB_DIR = path.join(REPO_ROOT, 'one.ie/web')
+const CONFIG_PATH = path.join(WEB_DIR, 'src/lib/puck/config.tsx')
+const OUT_PATH = path.join(WEB_DIR, 'src/lib/puck/block-usage.json')
+const PUCK_LIB_DIR = path.join(WEB_DIR, 'src/lib/puck')
+// GENERATED and gitignored — `src/data/promises.json` is built from text/*.md by
+// the promise-manifest step, so every block name written into a PROMISE lands in
+// `src/` and reads as a code reference. It is not one: a block named in a
+// marketing contract is not a block anything can reach. Counting it made
+// `--check` go red on a DOC edit (measured 2026-08-19: naming HeroCentered and
+// PricingSection in text/blocks.md moved ten blocks and flipped one from
+// unchosen to chosen), and worse, made the archive verdict depend on prose.
+// Redundant since the scan intersects with `git ls-files` (the file is
+// gitignored, so it is never tracked) — kept as a backstop against a stray
+// `git add -f` making prose count again.
+const PROMISES_JSON = path.join(WEB_DIR, 'src/data/promises.json')
+
+const args = process.argv.slice(2)
+const CHECK = args.includes('--check')
+const LOCAL = args.includes('--local')
+
+function readRegisteredNames() {
+  const tmp = mkdtempSync(path.join(tmpdir(), 'blocks-census-'))
+  const runner = path.join(tmp, 'names.mjs')
+  writeFileSync(
+    runner,
+    `import { puckConfig } from ${JSON.stringify(CONFIG_PATH)}\nconsole.log(JSON.stringify(Object.keys(puckConfig.components)))\n`,
+  )
+  try {
+    const out = execFileSync('bunx', ['tsx', runner], { cwd: WEB_DIR, encoding: 'utf8' })
+    return JSON.parse(out.trim())
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+// The census must measure the RETIRED names too, not just the 130 that survive
+// collapseFamilies. Stored pages still carry `LandingHero`, and it resolves to
+// Hero through BLOCK_ALIASES at render — so if the census only knows canonicals,
+// every collapsed family measures 0 demand and the usage-ordered palette ranks
+// them last. Measured 2026-08-18 on the first true regeneration since the cut:
+// Hero fell to pagesUsing=0 and palette-order's family-inheritance test went red.
+function readAliasNames() {
+  const tmp = mkdtempSync(path.join(tmpdir(), 'blocks-alias-'))
+  const runner = path.join(tmp, 'aliases.mjs')
+  writeFileSync(
+    runner,
+    `import { BLOCK_ALIASES } from ${JSON.stringify(path.join(WEB_DIR, 'src/lib/puck/families.ts'))}\nconsole.log(JSON.stringify(Object.keys(BLOCK_ALIASES ?? {})))\n`,
+  )
+  try {
+    const out = execFileSync('bunx', ['tsx', runner], { cwd: WEB_DIR, encoding: 'utf8' })
+    return JSON.parse(out.trim())
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+function readPagesRows() {
+  const flag = LOCAL ? '--local' : '--remote'
+  const out = execFileSync(
+    'bunx',
+    ['wrangler', 'd1', 'execute', 'one-owners', flag, '--json', '--command', 'SELECT slug, workspace, components, data FROM pages'],
+    { cwd: WEB_DIR, encoding: 'utf8', maxBuffer: 1024 * 1024 * 256 },
+  )
+  const parsed = JSON.parse(out)
+  return parsed[0]?.results ?? []
+}
+
+// Mirrors one.ie/web/src/pages/u/[slug]/p/[pageSlug].astro's resolution order:
+// data column wins when present and parseable; else derive from legacy
+// components via componentsToPuck(parseComponents(...)).
+function resolveBlockNames(row) {
+  const names = []
+  let content = null
+  if (row.data) {
+    try {
+      const parsed = JSON.parse(row.data)
+      content = Array.isArray(parsed?.content) ? parsed.content : null
+    } catch {
+      content = null
+    }
+  }
+  if (!content) {
+    let sections = []
+    try {
+      const raw = typeof row.components === 'string' ? JSON.parse(row.components) : row.components
+      if (Array.isArray(raw)) {
+        sections = raw.filter((e) => e && typeof e === 'object' && typeof e.component === 'string')
+      }
+    } catch {
+      sections = []
+    }
+    content = sections.map((s) => ({ type: s.component }))
+  }
+  for (const block of content) {
+    const type = block && typeof block === 'object' ? block.type : null
+    if (typeof type === 'string') names.push(type)
+  }
+  return names
+}
+
+function computeUsage(rows, registered) {
+  const pagesUsing = new Map()
+  const instances = new Map()
+  for (const name of registered) {
+    pagesUsing.set(name, 0)
+    instances.set(name, 0)
+  }
+  for (const row of rows) {
+    const names = resolveBlockNames(row)
+    const seenOnThisPage = new Set()
+    for (const name of names) {
+      if (!instances.has(name)) continue // not a registered block (dead name, alias, etc.)
+      instances.set(name, instances.get(name) + 1)
+      seenOnThisPage.add(name)
+    }
+    for (const name of seenOnThisPage) {
+      pagesUsing.set(name, pagesUsing.get(name) + 1)
+    }
+  }
+  return { pagesUsing, instances }
+}
+
+// nonPageRefs: how many files OUTSIDE lib/puck/ mention this component name
+// (social composer, mail renderer, etc.) — a block reachable from there is
+// CHOSEN even at zero page instances.
+function computeNonPageRefs(registered) {
+  const result = new Map()
+  for (const name of registered) result.set(name, 0)
+  let out
+  try {
+    out = execFileSync(
+      'grep',
+      ['-rl', '-E', `\\b(${registered.map(escapeRe).join('|')})\\b`, path.join(WEB_DIR, 'src')],
+      { encoding: 'utf8', maxBuffer: 1024 * 1024 * 64 },
+    )
+  } catch (err) {
+    // grep exits 1 when nothing matches — that's a valid empty result, not an error.
+    out = err.stdout ?? ''
+  }
+  const tracked = trackedSourceFiles()
+  const files = out
+    .split('\n')
+    .filter(Boolean)
+    .filter((f) => tracked.has(f))
+    .filter((f) => !f.startsWith(PUCK_LIB_DIR + path.sep) && f !== CONFIG_PATH && f !== PROMISES_JSON)
+    .filter((f) => !f.includes('.test.') && !f.includes('/tests/'))
+  for (const file of files) {
+    let text
+    try {
+      text = readFileSync(file, 'utf8')
+    } catch {
+      continue
+    }
+    for (const name of registered) {
+      const re = new RegExp(`\\b${escapeRe(name)}\\b`)
+      if (re.test(text)) result.set(name, result.get(name) + 1)
+    }
+  }
+  return result
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+// The census is a claim about the REPO, so the scan must read what git tracks,
+// not what happens to be sitting on disk. A regenerate run during a neighbour's
+// half-finished work otherwise records references that do not exist in the
+// repo — measured 2026-08-19: an uncommitted src/components/speed/SpeedMetrics.tsx
+// from a concurrent session contributed Timeline and Stats refs to the committed
+// census. Locally-MODIFIED tracked files still count: the bar is tracked, not
+// clean, because a modified file is still a file the repo has.
+function trackedSourceFiles() {
+  let out
+  try {
+    out = execFileSync('git', ['ls-files', '-z', '--', 'src'], {
+      cwd: WEB_DIR,
+      encoding: 'utf8',
+      maxBuffer: 1024 * 1024 * 64,
+    })
+  } catch (err) {
+    throw new Error(`blocks-usage: git ls-files failed — cannot tell tracked from untracked: ${err.message}`)
+  }
+  const files = new Set(
+    out
+      .split('\0')
+      .filter(Boolean)
+      .map((rel) => path.join(WEB_DIR, rel)),
+  )
+  // A broken sensor must never degrade quietly: an empty or implausibly small
+  // tracked set would zero every nonPageRefs and read as "archive everything".
+  // 2474 files were tracked under one.ie/web/src when this floor was measured.
+  if (files.size < 500) {
+    throw new Error(`blocks-usage: git ls-files returned only ${files.size} files under one.ie/web/src — refusing to census a repo this scan cannot see`)
+  }
+  return files
+}
+
+function buildCensus() {
+  const registered = readRegisteredNames().sort()
+  // registered ∪ retired-but-reachable — see readAliasNames above
+  const measured = [...new Set([...registered, ...readAliasNames()])].sort()
+  const rows = readPagesRows()
+  const { pagesUsing, instances } = computeUsage(rows, measured)
+  const nonPageRefs = computeNonPageRefs(measured)
+  const blocks = {}
+  let chosen = 0
+  for (const name of measured) {
+    const pu = pagesUsing.get(name) ?? 0
+    const inst = instances.get(name) ?? 0
+    const npr = nonPageRefs.get(name) ?? 0
+    blocks[name] = { pagesUsing: pu, instances: inst, nonPageRefs: npr }
+    if (pu > 0 || npr > 0) chosen++
+  }
+  return {
+    measuredAt: new Date().toISOString().slice(0, 10),
+    registered: registered.length,
+    measured: measured.length,
+    chosen,
+    unchosen: measured.length - chosen,
+    blocks,
+  }
+}
+
+function diffBlocks(committed, fresh) {
+  const lines = []
+  const names = new Set([...Object.keys(committed.blocks ?? {}), ...Object.keys(fresh.blocks)])
+  for (const name of [...names].sort()) {
+    const a = committed.blocks?.[name]
+    const b = fresh.blocks[name]
+    if (!a) {
+      lines.push(`+ ${name} ${JSON.stringify(b)}`)
+      continue
+    }
+    if (!b) {
+      lines.push(`- ${name} ${JSON.stringify(a)}`)
+      continue
+    }
+    if (a.pagesUsing !== b.pagesUsing || a.instances !== b.instances || a.nonPageRefs !== b.nonPageRefs) {
+      lines.push(`~ ${name} committed=${JSON.stringify(a)} fresh=${JSON.stringify(b)}`)
+    }
+  }
+  if (committed.registered !== fresh.registered) lines.push(`~ registered committed=${committed.registered} fresh=${fresh.registered}`)
+  if (committed.chosen !== fresh.chosen) lines.push(`~ chosen committed=${committed.chosen} fresh=${fresh.chosen}`)
+  if (committed.unchosen !== fresh.unchosen) lines.push(`~ unchosen committed=${committed.unchosen} fresh=${fresh.unchosen}`)
+  return lines
+}
+
+function main() {
+  if (CHECK) {
+    if (!existsSync(OUT_PATH)) {
+      console.error(`blocks-usage --check: ${OUT_PATH} does not exist — run without --check first to seed it.`)
+      process.exit(1)
+    }
+    const committed = JSON.parse(readFileSync(OUT_PATH, 'utf8'))
+    const fresh = buildCensusOffline(committed)
+    const diff = diffBlocks(committed, fresh)
+    if (diff.length > 0) {
+      console.error('blocks-usage --check: drift detected')
+      for (const line of diff) console.error(line)
+      process.exit(1)
+    }
+    console.log('blocks-usage --check: ok (no drift)')
+    process.exit(0)
+  }
+
+  const census = buildCensus()
+  writeFileSync(OUT_PATH, JSON.stringify(census, null, 2) + '\n')
+  console.log(`wrote ${OUT_PATH} — registered=${census.registered} chosen=${census.chosen} unchosen=${census.unchosen}`)
+}
+
+// In --check mode, re-derive registered names + nonPageRefs from the committed
+// file's OWN key set. This lets --check run with zero D1/network access when
+// the caller doesn't need a live page-usage recompute (i.e. it trusts the
+// committed pagesUsing/instances numbers and only re-verifies name/ref shape).
+// If a live D1 recheck is wanted, delete block-usage.json and re-run without
+// --check first.
+function buildCensusOffline(committed) {
+  // --check runs with no D1: it re-derives only the source-scanned half
+  // (nonPageRefs) and trusts the committed D1 half. The name set is therefore
+  // whatever the committed file measured — registered UNION retired — so it
+  // must NOT be reported as `registered`, which counts actual registrations.
+  const measuredNames = Object.keys(committed.blocks ?? {}).sort()
+  const nonPageRefs = computeNonPageRefs(measuredNames)
+  const blocks = {}
+  let chosen = 0
+  for (const name of measuredNames) {
+    const pu = committed.blocks[name]?.pagesUsing ?? 0
+    const inst = committed.blocks[name]?.instances ?? 0
+    const npr = nonPageRefs.get(name) ?? 0
+    blocks[name] = { pagesUsing: pu, instances: inst, nonPageRefs: npr }
+    if (pu > 0 || npr > 0) chosen++
+  }
+  return {
+    measuredAt: committed.measuredAt,
+    registered: committed.registered,
+    measured: measuredNames.length,
+    chosen,
+    unchosen: measuredNames.length - chosen,
+    blocks,
+  }
+}
+
+main()

package/scripts/browser-check.mjs

@@ -1,122 +1,63 @@
 #!/usr/bin/env node
 /**
- * browser-check.mjs — Playwright browser diagnostic tool.
+ * browser-check.mjs — DEPRECATED SHIM. Kept so existing callers keep working.
  *
- * Usage:
- *   node .claude/scripts/browser-check.mjs [url] [--send "message"] [--screenshot] [--network]
+ * The engine is now `.claude/scripts/chrome.mjs` (chrome-headless-shell via
+ * Playwright). This file maps the old flag set onto it and renames the report
+ * fields back to the shape `do-prove.sh` and `/browser` already parse.
  *
- * Requires: playwright in /tmp/node_modules (installed once, persists across sessions)
- * Install:  cd /tmp && npm install playwright && npx playwright install chromium
+ * New work calls chrome.mjs directly — it has steps, network, eval, selectors,
+ * cookies and headers this shim does not expose.
  *
- * What it checks:
- *   - Page load (status, title, console errors)
- *   - Chat rail text before/after sending a message (--send)
- *   - API request/response monitoring (--network)
- *   - Screenshot saved to /tmp/browser-check.png (--screenshot)
- *   - JS errors, React hydration errors
+ * Old usage (unchanged):
+ *   node .claude/scripts/browser-check.mjs [url] [--send "msg"] [--screenshot] [--network]
+ *
+ * Old prerequisite (`npm install playwright` into /tmp) is GONE. chrome.mjs
+ * finds Playwright wherever this tree installed it, including from a linked
+ * worktree. The /tmp copy had already evaporated, which silently degraded every
+ * browser PROVE to a curl fallback.
  */
 
-import pkg from '/tmp/node_modules/playwright/index.js'
-const { chromium } = pkg
-import { writeFileSync } from 'fs'
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
+const HERE = dirname(fileURLToPath(import.meta.url))
 const args = process.argv.slice(2)
-const urlArg = args.find(a => a.startsWith('http')) ?? 'http://localhost:4321'
+
+const url = args.find((a) => a.startsWith('http')) ?? 'http://localhost:4321'
 const sendMsg = args.find((_, i) => args[i - 1] === '--send') ?? null
 const doScreenshot = args.includes('--screenshot')
 const doNetwork = args.includes('--network')
 
-const browser = await chromium.launch({ headless: true })
-const page = await browser.newPage()
-
-// Capture console output
-const consoleLogs = []
-const jsErrors = []
-page.on('console', m => consoleLogs.push({ type: m.type(), text: m.text() }))
-page.on('pageerror', e => jsErrors.push(String(e)))
-
-// Network monitoring
-const apiRequests = []
-const apiResponses = []
-if (doNetwork) {
-  page.on('request', req => {
-    if (req.url().includes('/api/')) {
-      apiRequests.push({ method: req.method(), url: req.url().split('?')[0] })
-    }
-  })
-}
-
-// Patch fetch to capture chat API body + stream
-await page.addInitScript(() => {
-  const orig = window.fetch
-  window.__chatCapture = []
-  window.fetch = async (...args) => {
-    const url = args[0]?.toString() || ''
-    if (url.includes('/api/chat') && !url.includes('warmup') && !url.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 clone = resp.clone()
-        const reader = clone.body?.getReader()
-        if (reader) {
-          let chunks = ''
-          while (true) {
-            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)
-  }
-})
+const argv = [join(HERE, 'chrome.mjs'), url]
+if (sendMsg) argv.push('--send', sendMsg)
+if (doScreenshot) argv.push('--screenshot', '/tmp/browser-check.png')
+if (doNetwork) argv.push('--network')
 
-// Load page
-const res = await page.goto(urlArg, { waitUntil: 'load', timeout: 15000 }).catch(e => ({ status: () => 0, error: e.message }))
-const httpStatus = typeof res?.status === 'function' ? res.status() : 0
-await page.waitForTimeout(2500)
-
-const title = await page.title().catch(() => '(no title)')
-const chatRailBefore = await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 200) || null)
-
-// Send message if requested
-let chatRailAfter = null
-if (sendMsg) {
-  const ta = await page.$('textarea')
-  if (ta) {
-    await ta.fill(sendMsg)
-    await ta.press('Enter')
-    await page.waitForTimeout(12000)
-    chatRailAfter = await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 400) || null)
-  }
+const run = spawnSync(process.execPath, argv, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
+if (run.status !== 0) {
+  process.stderr.write(run.stderr || 'chrome.mjs failed\n')
+  process.exit(run.status ?? 1)
 }
 
-// Screenshot
-if (doScreenshot) {
-  await page.screenshot({ path: '/tmp/browser-check.png', fullPage: false })
+let r
+try {
+  r = JSON.parse(run.stdout)
+} catch {
+  process.stdout.write(run.stdout)
+  process.exit(0)
 }
 
-const chatCapture = await page.evaluate(() => window.__chatCapture || [])
-
-await browser.close()
-
-// Report
-const report = {
-  url: urlArg,
-  httpStatus,
-  title,
-  jsErrors,
-  consoleErrors: consoleLogs.filter(l => l.type === 'error').map(l => l.text),
-  chatRailBefore,
-  chatRailAfter: sendMsg ? chatRailAfter : undefined,
-  chatCapture: sendMsg ? chatCapture : undefined,
-  apiRequests: doNetwork ? apiRequests : undefined,
+console.log(JSON.stringify({
+  url: r.url,
+  httpStatus: r.httpStatus,
+  title: r.title ?? '(no title)',
+  jsErrors: r.jsErrors,
+  consoleErrors: r.consoleErrors,
+  chatRailBefore: r.chatRailBefore ?? null,
+  chatRailAfter: sendMsg ? (r.chatRailAfter ?? null) : undefined,
+  chatCapture: sendMsg ? (r.chatCapture ?? []) : undefined,
+  apiRequests: doNetwork ? (r.network ?? []).map((n) => ({ method: n.method, url: n.url })) : undefined,
   screenshot: doScreenshot ? '/tmp/browser-check.png' : undefined,
-}
-
-console.log(JSON.stringify(report, null, 2))
+}, null, 2))

package/scripts/cc-events-proof.sh

@@ -56,8 +56,6 @@ if ! _is_one_web "$API_URL"; then
     kill "$SELF_STARTED_PID" 2>/dev/null
     exit 2
   fi
-  # do-tasks-bridge.py (wire 3, invoked below) reads this same env var independently —
-  # without exporting it here it would still default to the wrong :4321.
   export ONE_API_URL="$API_URL"
 fi
 
@@ -124,18 +122,21 @@ if [ "$neg_ok" = "true" ]; then
 fi
 echo "[cc-events-proof] wire1 negative control ok — wrong key correctly rejected ($neg_resp)"
 
-# ── wire 3 — the tasks bridge sends ──────────────────────────────────────────
-send_out="$(python3 "$ROOT/.claude/scripts/do-tasks-bridge.py" --send 2>/dev/null)"
-send_count="$(printf '%s' "$send_out" | jq 'length' 2>/dev/null || echo 0)"
-send_matched_total="$(printf '%s' "$send_out" | jq '[.[] | .result.matched // 0] | add // 0' 2>/dev/null)"
-if [ "${send_count:-0}" -eq 0 ]; then
-  echo "[cc-events-proof] wire3 tasks skipped — local build queue is empty (not a failure)"
-  wire3_ok=skip
-elif [ "${send_matched_total:-0}" -ge 1 ]; then
-  echo "[cc-events-proof] wire3 tasks ok — $send_count sent, matched_total=$send_matched_total"
+# ── wire 3 — tasks:announce direct (shared-atom wire, text/tasks-do-plan.md C1/C8:
+# tasks:create already fires tasks:announce in-process, so this proof calls the same
+# receiver the create path calls instead of going through the deleted reconciler
+# script) ───────────────────────────────────────────────────────────────────
+tasks_payload="$(jq -nc --arg tid "task:${PROOF_SLUG}-$$" '{taskId:$tid,tags:["cc","session"],board:"marketplace"}')"
+tasks_resp="$(curl -sS --max-time 5 -X POST "$API_URL/api/ask/tasks:announce" \
+  -H 'Content-Type: application/json' --config "$AUTHCFG" \
+  -H 'Cookie: signed_out=1' -d "{\"data\":$tasks_payload}")"
+tasks_ok="$(printf '%s' "$tasks_resp" | jq -r '.result.ok // false' 2>/dev/null)"
+tasks_matched="$(printf '%s' "$tasks_resp" | jq -r '.result.matched // 0' 2>/dev/null)"
+echo "[cc-events-proof] wire3 tasks:announce ok=$tasks_ok matched=$tasks_matched"
+if [ "$tasks_ok" = "true" ] && [ "${tasks_matched:-0}" -ge 1 ]; then
   wire3_ok=true
 else
-  echo "[cc-events-proof] wire3 tasks FAIL — $send_count sent, matched_total=$send_matched_total"
+  echo "[cc-events-proof] wire3 tasks FAIL — $tasks_resp"
   wire3_ok=false
 fi