@oneie/claude 0.7.0 → 0.9.0

package/scripts/one-agents.mjs

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+// one-agents.mjs — the BRIDGE: platform agents → Claude Code subagents.
+//
+// classification: monorepo-only  (hard-asserts against one.ie/ai/agents/)
+//
+// Reads every `kind: agent` file under one.ie/ai/agents/**.md and emits a
+// spawnable Claude Code subagent into .claude/agents/one/<name>.md.
+//
+// WHY THIS EXISTS — the whole point of /one's desk mode:
+//   A subagent starts with a FRESH context. That is exactly what a new tab
+//   buys, without losing the thread. The platform org chart already names 81
+//   agents with tier/reports_to/domain/subscribes; this makes them callable by
+//   the Agent tool so the desk can route to them instead of the operator
+//   opening another window.
+//
+// THE ONE HARD CONSTRAINT: a spawned subagent inherits NO parent CLAUDE.md
+// (.claude/CLAUDE.md says so flatly). So the generated body INLINES the
+// load-bearing substrate constants — otherwise the fresh context that solves
+// the tab problem is also what makes every subagent violate the locked rules.
+//
+// Authority for the frontmatter shape: one.ie/web/src/lib/agent-md.ts
+// (this script reads a deliberate SUBSET — name/tier/reports_to/domain/
+// tagline/skills/subscribes — and never writes back).
+//
+// Usage:
+//   node .claude/scripts/one-agents.mjs            # write .claude/agents/one/
+//   node .claude/scripts/one-agents.mjs --check    # exit 1 if regeneration would change anything
+//   node .claude/scripts/one-agents.mjs --chart    # print the routing table, emit nothing
+//   node .claude/scripts/one-agents.mjs --self-test
+
+import { readFileSync, writeFileSync, readdirSync, mkdirSync, rmSync, existsSync } from 'node:fs'
+import { join, relative, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..')
+const SRC = join(ROOT, 'one.ie', 'ai', 'agents')
+// FLAT, deliberately. Every agents/ directory on this machine — ten official
+// plugins plus the harness itself — is flat, and not one of them nests. A
+// subdirectory is unproven ground for the loader, so generated agents live
+// beside w1-w4 and are told apart by the GENERATED marker, never by their path.
+const OUT = join(ROOT, '.claude', 'agents')
+const MARKER = '<!-- GENERATED by .claude/scripts/one-agents.mjs'
+
+// Names the harness or the runtime already owns. Emitting one of these would
+// shadow a real agent, so they are skipped loudly rather than silently.
+const RESERVED = new Set([
+  'claude', 'Explore', 'Plan', 'general-purpose', 'statusline-setup',
+  'claude-code-guide', 'w1-recon', 'w2-decide', 'w3-edit', 'w4-verify', 'w4-tools',
+])
+
+// The Agent tool accepts ONLY these. Platform agents declare `model:
+// x-ai/grok-4.5` — an OpenRouter id that means nothing here, so it is mapped
+// by tier and never copied through.
+const MODEL_BY_TIER = {
+  chairman: 'opus', ceo: 'opus', director: 'opus',
+  specialist: 'sonnet', tool: 'haiku',
+  1: 'sonnet', 2: 'sonnet', '1': 'sonnet', '2': 'sonnet',
+}
+
+// Engineering agents touch the repo; everyone else touches the world.
+const TOOLS_ENGINEERING = 'Read, Grep, Glob, Bash, Edit, Write, WebFetch'
+const TOOLS_WORLD = 'Read, Grep, Glob, Bash, Write, WebFetch, WebSearch'
+const TOOLS_DIRECTOR = 'Read, Grep, Glob, Bash, WebFetch, WebSearch'
+
+const COLOR_BY_DOMAIN = {
+  governance: 'purple', engineering: 'blue', marketing: 'orange',
+  sales: 'green', service: 'cyan', education: 'yellow',
+  finance: 'green', community: 'pink',
+}
+
+// ---------------------------------------------------------------- frontmatter
+
+/** Minimal YAML-subset reader. Scalars, `[a, b]` inline lists, and `- item`
+ *  block lists — which is everything these files actually use. Deliberately
+ *  NOT a YAML parser: an unparseable value yields undefined and the agent is
+ *  skipped, which is the safe direction. */
+function frontmatter(text) {
+  if (!text.startsWith('---')) return null
+  const end = text.indexOf('\n---', 3)
+  if (end === -1) return null
+  const head = text.slice(4, end)
+  const body = text.slice(end + 4).replace(/^\n+/, '')
+  const meta = {}
+  let key = null
+  for (const raw of head.split('\n')) {
+    const line = raw.replace(/\s+$/, '')
+    if (!line || line.startsWith('#')) continue
+    const m = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/)
+    if (m) {
+      key = m[1]
+      const v = m[2].trim()
+      if (v === '') { meta[key] = []; continue }
+      if (v.startsWith('[') && v.endsWith(']')) {
+        meta[key] = v.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean)
+        key = null
+        continue
+      }
+      meta[key] = v.replace(/^["']|["']$/g, '')
+      key = null
+      continue
+    }
+    const item = line.match(/^\s*-\s+(.*)$/)
+    if (item && key) {
+      if (!Array.isArray(meta[key])) meta[key] = []
+      // `- signal: campaign:brief` appears in the wild — keep the value half.
+      const val = item[1].replace(/^signal:\s*/, '').trim().replace(/^["']|["']$/g, '')
+      if (val) meta[key].push(val)
+    }
+  }
+  return { meta, body }
+}
+
+function walk(dir, acc = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name)
+    if (e.isDirectory()) walk(p, acc)
+    else if (e.name.endsWith('.md')) acc.push(p)
+  }
+  return acc
+}
+
+// ------------------------------------------------------------------- collect
+
+const SKIPPED = []
+
+function collect() {
+  const out = []
+  const seen = new Map()
+  for (const path of walk(SRC).sort()) {
+    const rel = relative(ROOT, path)
+    let parsed
+    try { parsed = frontmatter(readFileSync(path, 'utf8')) } catch { parsed = null }
+    if (!parsed) { SKIPPED.push([rel, 'no frontmatter']); continue }
+    const { meta, body } = parsed
+
+    // `kind: agent` is the gate. It excludes AGENTS.md, README.md, the
+    // import-*/export-* connector stubs, and the doc files that live here.
+    if (meta.kind !== 'agent') { SKIPPED.push([rel, `kind=${meta.kind ?? '-'}`]); continue }
+
+    const name = String(meta.name ?? '').trim()
+    // The template file declares `name: <kebab-case>` with placeholder
+    // frontmatter. Without this guard the generator emits a subagent literally
+    // called `<kebab-case>`.
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) { SKIPPED.push([rel, `bad name: ${name || '(none)'}`]); continue }
+    if (RESERVED.has(name)) { SKIPPED.push([rel, 'reserved name']); continue }
+    if (meta.lifecycle && meta.lifecycle !== 'active') { SKIPPED.push([rel, `lifecycle=${meta.lifecycle}`]); continue }
+    if (seen.has(name)) { SKIPPED.push([rel, `duplicate of ${seen.get(name)}`]); continue }
+
+    seen.set(name, rel)
+    out.push({
+      name,
+      src: rel,
+      tier: String(meta.tier ?? 'specialist'),
+      reports_to: meta.reports_to ? String(meta.reports_to) : null,
+      domain: String(meta.domain ?? 'governance'),
+      title: meta.title ? String(meta.title) : name,
+      tagline: meta.tagline ? String(meta.tagline) : '',
+      skills: Array.isArray(meta.skills) ? meta.skills : (meta.skills ? [String(meta.skills)] : []),
+      subscribes: (Array.isArray(meta.subscribes) ? meta.subscribes : []).filter(t => t !== '*'),
+      body,
+    })
+  }
+  return out
+}
+
+// -------------------------------------------------------------------- render
+
+/** The constants a subagent cannot look up, because it inherits no CLAUDE.md.
+ *  Everything here is LOCKED in the substrate — a subagent that renames one of
+ *  these breaks the schema, not just its own reply. */
+const SUBSTRATE = `
+## Substrate constants (you inherit no CLAUDE.md — these are the locked facts)
+
+You are running inside the ONE monorepo at \`/Users/toc/Server/one-ie\`.
+
+**6 dimensions (LOCKED, never rename):** Groups · Actors · Things · Paths · Events · Learning.
+Dead names that must never appear: knowledge, connections, people, node, scent, alarm, trail, colony.
+
+**6 verbs (LOCKED):** \`signal\` · \`mark\` · \`warn\` · \`fade\` · \`follow\` · \`harden\`.
+Every signal closes with \`mark()\`, \`warn()\`, or dissolve. **No silent returns.**
+
+**Tags are BARE words** — \`marketing\`, \`lead\`, \`engineering\` — never \`lifecycle:marketing\`.
+A namespaced subscribe tag matches zero signals.
+
+**Structural time** — plan in tasks → waves → cycles. Never days/hours/weeks.
+
+**Where things live:** web UI + API routes \`one.ie/web/\` · TypeDB schema \`schema/\` (never
+duplicate .tql elsewhere) · specs and docs \`text/\` · payments \`pay/\` · agent runtime \`channels/\`.
+Backend routes live ONLY in \`one.ie/web/src/pages/api/\`.
+
+**Tests:** \`bun run verify:fast\` is the dev lane; the full \`bun run verify\` (~87s) is the review
+gate. Say which lane you ran — a fast pass is never reported as a full pass. A test touching the
+DOM needs \`// @vitest-environment jsdom\` on line 1.
+
+**Where you collaborate, and where you plan.** \`/u/<slug>/in\` is the room. Its Spaces ARE
+your \`subscribes:\` tags — \`FN_TAGS\` maps a department to bare words
+(\`one.ie/web/src/lib/in/spaces.ts:28\`), so staking \`marketing\` IS having a desk in the
+marketing Space. \`/u/<slug>/tasks\` is the same words as plannable rows.
+
+**A task comment is a message in that room — one store, one renderer, one vocabulary.**
+\`tasks:comment\` writes to the SAME D1 message store the inbox thread uses
+(\`one.ie/web/src/lib/resolvers/tasks.ts:1639\`, thread id \`task:<tid>\` at \`:1665\`), and it
+renders through the same \`Thread\` component the conversation uses
+(\`one.ie/web/src/components/in/TaskDetail.tsx:13,859\`). An \`@mention\` in a comment body
+INSERTs a \`follows\` row (\`resolvers/tasks.ts:1686-1693\`) — mentioning someone subscribes
+them to that task. So: report where the work already is. Never open a second room, and never
+invent a second vocabulary — the tag that routes your signal is the same word that names your
+Space and tags the task.
+
+**Proof discipline:** a presence grep is not proof. Probe the running thing. Report numbers you
+actually measured, and say plainly when a check did not run — an unrun gate is not a pass.
+`.trim()
+
+/** How many agents stake each tag — used to drop the non-discriminating ones
+ *  from descriptions. Rebuilt per render call set; cheap at this size. */
+let STAKE_FREQ = new Map()
+function indexStakes(roster) {
+  STAKE_FREQ = new Map()
+  for (const a of roster) for (const t of a.subscribes) STAKE_FREQ.set(t, (STAKE_FREQ.get(t) ?? 0) + 1)
+}
+
+function render(a, roster) {
+  if (STAKE_FREQ.size === 0) indexStakes(roster)
+  const model = MODEL_BY_TIER[a.tier] ?? 'sonnet'
+  const isDirector = a.tier === 'director' || a.tier === 'ceo' || a.tier === 'chairman'
+  const tools = isDirector ? TOOLS_DIRECTOR
+    : a.domain === 'engineering' ? TOOLS_ENGINEERING
+    : TOOLS_WORLD
+  const color = COLOR_BY_DOMAIN[a.domain] ?? 'blue'
+
+  // The description is what the Agent tool matches on when deciding whether to
+  // spawn this agent, so it must be TRIGGER-shaped — the tags it stakes on —
+  // not a job title.
+  //
+  // KEEP IT SHORT. Every description here is injected into the roster
+  // system-reminder on EVERY turn of EVERY session in this repo, desk or not.
+  // 80 agents is the difference between a few hundred tokens and several
+  // thousand of standing tax — and this design's whole thesis is that the tab
+  // stays light. So the description carries trigger words only. Tier, domain
+  // and reporting line are already in the body, where the spawned agent reads
+  // them, and none of the three helps the router decide to spawn this agent.
+  // Prefer DISCRIMINATING tags. `lead, mql, sql, marketing` is the department
+  // stake ~30 agents share — it costs bytes on every turn and tells the router
+  // nothing about which of the thirty to pick. `campaign:<id>:copy-needed`
+  // does. Fall back to the shared tags only when an agent has nothing else.
+  const own = a.subscribes.filter(t => (STAKE_FREQ.get(t) ?? 0) <= 5)
+  const stake = (own.length ? own : a.subscribes.length ? a.subscribes : [a.domain]).slice(0, 4).join(', ')
+  const desc = [
+    (a.tagline || `${a.title}.`).replace(/\s+/g, ' ').trim(),
+    `For: ${stake}.`,
+  ].join(' ').replace(/"/g, "'")
+
+  const reports = roster.filter(r => r.reports_to === a.name).map(r => r.name)
+  // The delegation line is tier-shaped. "You are a director, not a specialist"
+  // reads as a demotion on the top rung, whose whole function is that nobody is
+  // checking it — so the chairman gets the sentence its own job actually needs.
+  const delegation = a.tier === 'chairman'
+    ? `You are the top rung — nobody audits you, so ask what was MEASURED, never what was\nclaimed. Convene, press for the second answer, name disagreements. Do not do their work yourself.`
+    : `You are a director, not a specialist — decide which work is worth doing, name the agent\nthat owns the surface, and report back. Do not do their work yourself.`
+  const chain = reports.length
+    ? `\n## Your reports\n\nThese agents report to you and are spawnable by name: ${reports.join(' · ')}.\n${delegation}\n`
+    : ''
+
+  return `---
+name: ${a.name}
+description: "${desc}"
+tools: "${tools}"
+model: ${model}
+color: ${color}
+---
+${MARKER} from ${a.src} — do not hand-edit.
+     Edit the platform agent, then re-run the generator. -->
+
+${SUBSTRATE}
+${chain}
+---
+
+${a.body.trim()}
+
+---
+
+## Closing the loop
+
+Return a compact report: what you found or did, the file:line evidence, and one
+sentence naming what you did NOT do. If you were asked for something you cannot
+verify, say so — do not fill the gap with a plausible answer.
+`
+}
+
+// ---------------------------------------------------------------------- main
+
+const args = process.argv.slice(2)
+
+if (args.includes('--self-test')) {
+  let fail = 0
+  const ok = (label, cond) => { console.log(`${cond ? 'ok  ' : 'FAIL'} ${label}`); if (!cond) fail++ }
+
+  const fm = frontmatter('---\nname: x\nskills: [a, b]\nsubscribes:\n  - lead\n  - signal: route:to-x\n---\nbody here\n')
+  ok('scalar parsed', fm.meta.name === 'x')
+  ok('inline list parsed', JSON.stringify(fm.meta.skills) === '["a","b"]')
+  ok('block list parsed', JSON.stringify(fm.meta.subscribes) === '["lead","route:to-x"]')
+  ok('body split', fm.body.trim() === 'body here')
+  ok('no frontmatter -> null', frontmatter('# hello') === null)
+
+  // RED PROOF: the placeholder-name guard must actually bite. Without it the
+  // generator emits a subagent named `<kebab-case>`.
+  ok('placeholder name rejected', !/^[a-z][a-z0-9-]*$/.test('<kebab-case>'))
+  ok('reserved name held', RESERVED.has('w1-recon'))
+  // RED PROOF: an OpenRouter model id must never reach the Agent tool.
+  ok('grok id never mapped through', !Object.values(MODEL_BY_TIER).some(m => m.includes('/')))
+
+  const roster = collect()
+  ok(`roster non-empty (${roster.length})`, roster.length > 20)
+  ok('no placeholder in roster', !roster.some(r => r.name.includes('<')))
+  ok('every roster model is legal', roster.every(r => ['opus', 'sonnet', 'haiku', 'fable'].includes(MODEL_BY_TIER[r.tier] ?? 'sonnet')))
+  const ceo = roster.find(r => r.name === 'ceo')
+  ok('ceo present', !!ceo)
+  ok('ceo drops the "*" wildcard subscribe', ceo && !ceo.subscribes.includes('*'))
+  const rendered = ceo ? render(ceo, roster) : ''
+  ok('render inlines substrate constants', rendered.includes('6 verbs (LOCKED)'))
+  ok('render names the reports', rendered.includes('cto'))
+  ok('render carries the sweep marker', rendered.includes(MARKER))
+
+  // RED PROOF for the flat layout. The sweep deletes generated strays from a
+  // directory it SHARES with the hand-written harness agents, so the marker
+  // test is the only thing standing between a regenerate and losing w1-w4.
+  // Assert directly that they carry no marker and would therefore be invisible
+  // to it — and that a generated file WOULD be seen.
+  const HAND = ['w1-recon.md', 'w2-decide.md', 'w3-edit.md', 'w4-verify.md', 'w4-tools.md']
+  const survives = HAND.filter(f => {
+    const p = join(OUT, f)
+    return !existsSync(p) || !readFileSync(p, 'utf8').includes(MARKER)
+  })
+  ok(`sweep cannot see the ${HAND.length} hand-written harness agents`, survives.length === HAND.length)
+
+  // Every description is injected into the roster reminder on EVERY turn of
+  // EVERY session in this repo. This is the standing tax the design pays, so
+  // it is asserted, not assumed. ~90 chars x 80 agents ~= 7KB ~= 1.8k tokens.
+  const descBytes = roster.reduce((n, a) => n + render(a, roster).split('\n')[2].length, 0)
+  ok(`roster description budget ${(descBytes / 1024).toFixed(1)}KB < 14KB`, descBytes < 14 * 1024)
+
+  console.log(fail === 0 ? `\nPASS — ${roster.length} agents` : `\nFAIL — ${fail} check(s)`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+const roster = collect()
+
+if (args.includes('--chart')) {
+  const byDomain = {}
+  for (const a of roster) (byDomain[a.domain] ??= []).push(a)
+  console.log(`# ONE routing table — ${roster.length} spawnable agents\n`)
+  for (const d of Object.keys(byDomain).sort()) {
+    const list = byDomain[d]
+    const heads = list.filter(a => a.tier === 'director' || a.tier === 'ceo')
+    console.log(`## ${d}  (${list.length})${heads.length ? '  — head: ' + heads.map(h => h.name).join(', ') : ''}`)
+    for (const a of list.sort((x, y) => x.name.localeCompare(y.name))) {
+      console.log(`  ${a.name.padEnd(28)} ${a.tier.padEnd(11)} ${(a.subscribes.slice(0, 5).join(',') || '-')}`)
+    }
+    console.log('')
+  }
+  console.log(`skipped ${SKIPPED.length}:`)
+  for (const [f, why] of SKIPPED) console.log(`  ${f} — ${why}`)
+  process.exit(0)
+}
+
+const files = new Map()
+for (const a of roster) files.set(`${a.name}.md`, render(a, roster))
+
+/** The files WE wrote, identified by the marker in their body and never by
+ *  filename. This is the whole reason a flat directory is safe: w1-recon.md and
+ *  the other hand-written harness agents carry no marker, so the sweep below
+ *  cannot see them. */
+function generatedOnDisk() {
+  if (!existsSync(OUT)) return []
+  return readdirSync(OUT)
+    .filter(f => f.endsWith('.md'))
+    .filter(f => { try { return readFileSync(join(OUT, f), 'utf8').includes(MARKER) } catch { return false } })
+}
+
+if (args.includes('--check')) {
+  let drift = 0
+  const existing = new Set(generatedOnDisk())
+  for (const [f, content] of files) {
+    const p = join(OUT, f)
+    const cur = existsSync(p) ? readFileSync(p, 'utf8') : null
+    if (cur !== content) { console.log(`DRIFT ${f}${cur === null ? ' (missing)' : ''}`); drift++ }
+    existing.delete(f)
+  }
+  for (const f of existing) { console.log(`STALE ${f}`); drift++ }
+  console.log(drift === 0 ? `ok — ${files.size} agents in sync` : `\n${drift} file(s) out of sync — run: node .claude/scripts/one-agents.mjs`)
+  process.exit(drift === 0 ? 0 : 1)
+}
+
+mkdirSync(OUT, { recursive: true })
+let swept = 0
+for (const f of generatedOnDisk()) if (!files.has(f)) { rmSync(join(OUT, f)); swept++ }
+
+// Guard the WRITE the same way the delete is guarded. RESERVED only knows the
+// five harness agents that exist today; a hand-written agent added tomorrow
+// whose name collides with a platform agent would be silently overwritten —
+// and would then carry the marker, so the next sweep would own it too. Refuse
+// loudly instead.
+let refused = 0
+for (const [f, content] of files) {
+  const p = join(OUT, f)
+  if (existsSync(p) && !readFileSync(p, 'utf8').includes(MARKER)) {
+    console.log(`REFUSE ${f} — hand-written file, not overwriting (rename the platform agent)`)
+    refused++
+    continue
+  }
+  writeFileSync(p, content)
+}
+if (refused) console.log(`${refused} agent(s) refused`)
+console.log(`wrote ${files.size} agents -> ${relative(ROOT, OUT)}/  (skipped ${SKIPPED.length}, swept ${swept})`)
+console.log('NOTE: the roster is read at SESSION START — restart the session before spawning these.')

package/scripts/one-resume.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# one-resume.sh — the board, for a harness picking up someone else's fleets.
+#
+#   bash .claude/scripts/one-resume.sh            # print the board
+#   bash .claude/scripts/one-resume.sh --deploy   # board, then land+ship what is ready
+#
+# Zero model tokens. It reads the workflow journals and git, and tells you which
+# fleets finished, which are mid-flight, which branches are ready to land, and
+# the exact Workflow({scriptPath, resumeFromRunId}) call to continue each one.
+#
+# WHY: a session that runs out of credits must not lose its fleets. Every run
+# persists a script and a journal; a resume replays unchanged agents from CACHE
+# for free and only re-runs what changed. The expensive mistake is re-launching a
+# fleet whose work already landed — so this prints the branch state next to it.
+set -uo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$ROOT" || exit 1
+DEPLOY=0
+for a in "$@"; do case "$a" in --deploy) DEPLOY=1 ;; -h|--help) sed -n '2,18p' "${BASH_SOURCE[0]}"; exit 0 ;; esac; done
+
+GRN=$'\033[32m'; YEL=$'\033[33m'; DIM=$'\033[2m'; OFF=$'\033[0m'
+[[ -t 1 ]] || { GRN=""; YEL=""; DIM=""; OFF=""; }
+
+PROJ="$HOME/.claude/projects"
+echo "${DIM}══ fleets ══${OFF}"
+
+# One journal per run: {"type":"started"} / {"type":"result"} lines.
+found=0
+while IFS= read -r j; do
+  [[ -f "$j" ]] || continue
+  run="$(basename "$(dirname "$j")")"
+  read -r done total < <(python3 - "$j" <<'PY'
+import json,sys
+s=e=0
+for line in open(sys.argv[1]):
+    try: t=json.loads(line).get("type")
+    except Exception: continue
+    s += t=="started"; e += t=="result"
+print(e, s)
+PY
+)
+  [[ "${total:-0}" == "0" ]] && continue
+  found=1
+  state="in flight"; mark="$YEL"
+  [[ "$done" == "$total" ]] && { state="DONE"; mark="$GRN"; }
+  script="$(ls -t "$PROJ"/*/*/workflows/scripts/*"${run#wf_}"* 2>/dev/null | head -1)"
+  printf '%s  %-22s %s%s%s  %s/%s agents\n' "$mark" "$run" "$mark" "$state" "$OFF" "$done" "$total"
+  [[ -n "$script" ]] && printf '     resume: Workflow({scriptPath: "%s", resumeFromRunId: "%s"})\n' "$script" "$run"
+done < <(find "$PROJ" -path '*/subagents/workflows/wf_*/journal.jsonl' -mtime -3 2>/dev/null)
+(( found )) || echo "  (no workflow journals in the last 3 days)"
+
+echo
+echo "${DIM}══ branches ══${OFF}"
+READY=()
+while IFS= read -r br; do
+  [[ -z "$br" ]] && continue
+  ahead="$(git rev-list --count "main..$br" 2>/dev/null || echo 0)"
+  if [[ "$ahead" == "0" ]]; then
+    printf '  %-34s %sno commits beyond main%s\n' "$br" "$DIM" "$OFF"
+  else
+    printf '  %-34s %s%s commit(s) ready to land%s\n' "$br" "$GRN" "$ahead" "$OFF"
+    READY+=("$br")
+  fi
+done < <(git for-each-ref --format='%(refname:short)' --sort=-committerdate refs/heads/feat 2>/dev/null | head -20)
+
+echo
+echo "${DIM}══ next ══${OFF}"
+if (( ${#READY[@]} )); then
+  echo "  bash .claude/scripts/land.sh ${READY[*]} --deploy"
+else
+  echo "  nothing to land yet — resume a fleet above, or ./deploy dev"
+fi
+echo "  read text/HANDOFF.md BEFORE spawning anything new"
+
+if (( DEPLOY )) && (( ${#READY[@]} )); then
+  echo
+  bash "$ROOT/.claude/scripts/land.sh" "${READY[@]}" --deploy
+fi