@oneie/claude 0.8.0 → 0.10.0

package/scripts/lib/gc-finished.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+# gc-finished.sh — "is this branch's work already on the platform?"
+#
+# ONE definition, sourced by both the sweep (do-auto.sh --gc) and its red proof
+# (gc-content-check.sh). The matcher for hook:governor-escape lives in a shared
+# lib for the same reason: a checker that re-implements what it checks proves
+# only that two copies agree.
+#
+# NOT `rev-list --count BASE..branch`. That counts COMMITS, and a branch whose
+# patch reached BASE under a different sha — cherry-picked, rebased, landed by a
+# squash — keeps commits of its own for ever. Measured 2026-09-07 on this repo:
+# fix/webhook-500's single patch was already in dev under another sha, so the
+# count read "1 unmerged" and the sweep had been keeping a ~120MB checkout of
+# work the platform already had. A sweep that cannot recognise its own work is
+# not a sweep, it is a hoard.
+#
+# `git cherry` is the obvious fix and is NOT sufficient alone. A MERGE commit
+# carries no patch of its own, so cherry reports 0-new for a branch that holds
+# content nothing else has — merge/trunk-reconcile, the same day, 24 files and
+# 3416 lines dev had never seen. Sweeping on cherry would have deleted the only
+# checkout of a hand-made merge resolution.
+#
+# The predicate true in BOTH cases is content identity: every path the branch
+# touched since the merge base is now byte-identical in BASE. A rebased duplicate
+# passes; a merge carrying unique files fails; an ordinary unlanded branch fails.
+
+# gc_finished <base> <branch> -> 0 = finished (its content is in base), 1 = not
+gc_finished() {
+  local base="$1" b="$2"
+  local -a paths=()
+  # Paths the branch changed since the merge base. `...` (three dots) is the
+  # load-bearing part: `..` would also list what BASE changed underneath it, and
+  # a busy trunk would then make every branch look like it carries everything.
+  while IFS= read -r f; do [ -n "$f" ] && paths+=("$f"); done < <(git diff --name-only "${base}...${b}" 2>/dev/null)
+  # A branch that changed nothing since the merge base is finished by definition.
+  [ ${#paths[@]} -eq 0 ] && return 0
+  # Compare those paths as they stand NOW in each tip. --quiet exits 1 on any
+  # difference, which is the answer, not an error — never let `set -e` see it.
+  git diff --quiet "$base" "$b" -- "${paths[@]}" 2>/dev/null
+}
+
+# gc_carries <base> <branch> — how many paths the BRANCH still carries that base
+# does not have. This is the number the sweep prints, so it has to mean what it
+# says: `git diff --name-only base branch | wc -l` (two dots) counts everything
+# that differs in EITHER direction, so a branch adding one file to a trunk that
+# has moved on by 500 commits reports "carries 508 paths". Measured on this repo
+# 2026-09-07: fix/webhook-500-again touches ONE file and read 508. The paths that
+# belong to the branch are the ones it changed since the merge base AND that
+# still differ from base now — the same set gc_finished tests.
+gc_carries() {
+  local base="$1" b="$2" n=0 f
+  while IFS= read -r f; do
+    [ -n "$f" ] || continue
+    git diff --quiet "$base" "$b" -- "$f" 2>/dev/null || n=$((n+1))
+  done < <(git diff --name-only "${base}...${b}" 2>/dev/null)
+  echo "$n"
+}
+
+# Dirt that is not work: build output, worktree bookkeeping, a regenerated data
+# file. None of it is recoverable from a checkout and all of it regenerates, so
+# it must not stand between a finished branch and its removal.
+GC_EPHEMERAL="${GC_EPHEMERAL:-one\.ie/web/\.astro|one\.ie/web/\.wrangler|one\.ie/web/\.preview|\.dev\.pid|\.worktree-port|deploy-runs\.json|node_modules}"
+
+# gc_real_dirt <worktree> — the uncommitted lines that are actually WORK, empty
+# when the tree is clean or carries only ephemera.
+#
+# The `|| true` is load-bearing and is why this is a function rather than an
+# inline pipeline. `grep -v` exits 1 when it filters EVERYTHING out — which is
+# exactly the clean-worktree case — and the caller runs under `set -euo
+# pipefail`, so `real="$(... | grep -v ...)"` killed the sweep the first time it
+# met a worktree it was supposed to remove. Measured 2026-09-07: the sweep
+# printed four keep lines, exited 1, and never reached its own summary; piped
+# through `cat` or `tail` the failure was invisible, which is how it nearly got
+# reported as a clean run.
+gc_real_dirt() {
+  git -C "$1" status --porcelain 2>/dev/null | grep -vE "$GC_EPHEMERAL" || true
+}

package/scripts/livekit-ratchet.sh

@@ -10,6 +10,23 @@
 
 set -uo pipefail
 
+# _GATE — route a heavy compute through the machine governor. A gate_lock only
+# dedupes IDENTICAL work; a SLOT is what bounds N worktrees each running one of
+# these at once (measured 2026-09-07: three concurrent 2.5GB typecheckers, every
+# lock uncontended, load 171). Empty when already inside a gate, so a nested call
+# inherits the outer slot rather than taking a second one.
+#
+# Resolves gate-run.sh from its OWN directory, deliberately: an earlier version
+# keyed off $ROOT and got inserted above the line that sets it, so _GATE was
+# silently empty and every call ran ungoverned -- a fail-OPEN, which is the exact
+# defect this preamble exists to close.
+_GATE=()
+if [ "${GOVERN_IN_GATE:-0}" != "1" ]; then
+  _GR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/gate-run.sh"
+  [ -f "$_GR" ] && _GATE=( bash "$_GR" "compute:$(basename "${BASH_SOURCE[0]}")" -- )
+fi
+
+
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$ROOT" || exit 1
 
@@ -21,7 +38,7 @@ if [ ! -f "one.ie/web/$TEST_REL" ]; then
   exit 1
 fi
 
-(cd one.ie/web && bunx vitest run "$TEST_REL") || {
+(cd one.ie/web && "${_GATE[@]}" bunx vitest run "$TEST_REL") || {
   echo "livekit-ratchet FAIL — more than one LiveKit block is registered" >&2
   exit 1
 }

package/scripts/machine-check.sh

@@ -93,7 +93,7 @@ fi
 echo
 echo "── orphans (parent died, work still burning CPU) ──"
 ps -Ao pid=,ppid=,etime=,rss=,command= | awk '$2==1' \
-  | grep -E 'tsc --noEmit|vitest|bun run (verify|test)|node .*(one-ie|\.do-worktrees)|sleep [0-9]+$' \
+  | grep -E 'tsc --noEmit|vitest|bun run (verify|test)|node .*(one-ie|\.do-worktrees)|node_modules.*workerd serve|sleep [0-9]+$' \
   | awk '{printf "  %-7s %-9s %6.0fMB  %s\n",$1,$3,$4/1024,substr($0,index($0,$5),55)}' \
   || echo "  none"
 

package/scripts/memory-index-budget.sh

@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+# memory-index-budget.sh — is the auto-memory index still inside the loader's budget?
+#
+# WHY THIS EXISTS. Measured 2026-09-12: MEMORY.md was 89,954 bytes / 479 lines,
+# and a session loaded 128 lines = 25,162 bytes. The cut is a ~25KB BYTE budget.
+# 73% of the index never reached context, and the only warning was a line at the
+# BOTTOM of the file — inside the 73% nobody reads. The corpus passed the budget
+# around June and nothing noticed for three months.
+#
+# The loader's own advice ("one line under ~200 chars") does not fix it: 245 of
+# 479 lines violated it, and trimming every one yields 77,943 bytes — still 3.1x
+# over. The constraint is total bytes, so that is what this measures.
+#
+# Growth is 7.3 files/day (Sep 2026), so an index cut by hand re-grows within
+# weeks. This is the thing that says so.
+#
+#   bash memory-index-budget.sh              # check, exit 3 if over
+#   bash memory-index-budget.sh --self-test  # prove it can go RED
+set -uo pipefail
+
+BUDGET_BYTES="${MEMORY_INDEX_BUDGET:-25162}"   # measured cut, not a guess
+WARN_AT_PCT="${MEMORY_INDEX_WARN_PCT:-80}"
+
+_check() {
+  local idx="$1"
+  [ -f "$idx" ] || { echo "[memory-budget] no index at $idx"; return 2; }
+
+  local bytes lines pct
+  bytes=$(wc -c < "$idx" | tr -d ' ')
+  lines=$(wc -l < "$idx" | tr -d ' ')
+  pct=$(( bytes * 100 / BUDGET_BYTES ))
+
+  # How much actually loads: bytes are the cap, so count lines until the budget.
+  local fit
+  fit=$(awk -v b="$BUDGET_BYTES" '{s+=length($0)+1; if(s<=b) n++} END{print n+0}' "$idx")
+  local dark=$(( lines - fit ))
+  local darkpct=0
+  [ "$lines" -gt 0 ] && darkpct=$(( dark * 100 / lines ))
+
+  echo "[memory-budget] $idx"
+  echo "  bytes   $bytes / $BUDGET_BYTES budget  (${pct}%)"
+  echo "  lines   $lines total, ~$fit reach context, $dark dark (${darkpct}%)"
+
+  if [ "$bytes" -gt "$BUDGET_BYTES" ]; then
+    echo "  RED — over budget. ~${darkpct}% of the index never reaches context."
+    echo "        Trimming long lines does not fix this; the cap is total bytes."
+    echo "        Shrink to a hot set and move the tail to its files — they stay"
+    echo "        reachable by their description:, which is the real recall key."
+    return 3
+  fi
+  if [ "$pct" -ge "$WARN_AT_PCT" ]; then
+    echo "  WARN — ${pct}% of budget. At ~7 new memories/day this goes red soon."
+    return 0
+  fi
+  echo "  ok — inside budget, whole index reaches context."
+  return 0
+}
+
+_self_test() {
+  local t; t=$(mktemp -d); local rc=0
+  # GREEN: a small index must pass.
+  printf 'a%.0s' $(seq 1 100) > "$t/small.md"
+  if _check "$t/small.md" >/dev/null 2>&1; then echo "  ok   green half: small index passes"
+  else echo "  FAIL green half: small index did not pass"; rc=1; fi
+  # RED: an oversized index must fail, or this checker is theatre.
+  awk -v n=$((BUDGET_BYTES * 2)) 'BEGIN{for(i=0;i<n/50;i++) print "x-------------------------------------------------"}' > "$t/big.md"
+  if _check "$t/big.md" >/dev/null 2>&1; then echo "  FAIL red half: oversized index PASSED — checker is broken"; rc=1
+  else echo "  ok   red half: oversized index correctly goes red"; fi
+  rm -rf "$t"
+  [ $rc -eq 0 ] && echo "[memory-budget] self-test PASS" || echo "[memory-budget] self-test FAIL"
+  return $rc
+}
+
+INDEX="${MEMORY_INDEX:-$HOME/.claude/projects/-Users-toc-Server-one-ie/memory/MEMORY.md}"
+case "${1:-}" in
+  --self-test) _self_test ;;
+  --index)     _check "${2:?--index needs a path}" ;;
+  *)           _check "$INDEX" ;;
+esac

package/scripts/npm-downloads.sh

@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+# npm-downloads.sh — all-time download counts for every @oneie package.
+#
+#   bash .claude/scripts/npm-downloads.sh            # table, all time
+#   bash .claude/scripts/npm-downloads.sh --json     # machine-readable
+#   bash .claude/scripts/npm-downloads.sh --since 2026-01-01
+#   bash .claude/scripts/npm-downloads.sh --scope @other
+#
+# portability: needs-env (network + jq; no repo state, no credentials)
+#
+# WHY THIS IS NOT ONE CURL: npm's downloads API answers `last-day`, `last-week`
+# and `last-month`, and for anything else a date range — but it REFUSES a range
+# longer than 18 months (`{"error":"...exceeds maximum of 18 months"}`), and it
+# answers that with HTTP 200. So "all time" is a WALK: start at the package's
+# first publish (registry `time.created`), step in 17-month windows, and sum.
+# A single wide range does not error loudly, it just returns nothing useful.
+#
+# THE SCOPED-NAME TRAP: `@oneie/sdk` must be percent-encoded as `@oneie%2Fsdk`
+# in the downloads API path. Unencoded, the `/` reads as a path separator and
+# the API returns a 404 that looks exactly like "this package has no downloads"
+# — a zero you would believe. Encoded here, once.
+#
+# A package published days ago legitimately reads 0. That is not a failure, and
+# it is reported as 0 with its first-publish date beside it so the number can be
+# read in context rather than mistaken for a broken query.
+set -uo pipefail
+
+SCOPE="@oneie"; JSON=0; SINCE=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --json)  JSON=1 ;;
+    --scope) SCOPE="$2"; shift ;;
+    --since) SINCE="$2"; shift ;;
+    -h|--help) sed -n '2,12p' "${BASH_SOURCE[0]}"; exit 0 ;;
+    *) echo "npm-downloads.sh: unknown flag '$1'" >&2; exit 2 ;;
+  esac
+  shift
+done
+
+command -v jq >/dev/null || { echo "npm-downloads.sh: needs jq" >&2; exit 2; }
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+# The package list comes from the workspace, not from `npm access list packages`
+# — that command returns nothing for a granular token whose scope is per-package
+# (measured 2026-09-14: "packages in scope: 0" while all nine were readable).
+# The manifests on disk are the honest list.
+pkgs=()
+while IFS= read -r pj; do
+  n="$(jq -r '.name // empty' "$pj" 2>/dev/null)"
+  [[ "$n" == "$SCOPE/"* ]] || continue
+  [[ "$(jq -r '.private // false' "$pj")" == "true" ]] && continue
+  pkgs+=("$n")
+done < <(find "$ROOT/packages" -maxdepth 2 -name package.json -not -path '*/node_modules/*' 2>/dev/null | sort)
+
+(( ${#pkgs[@]} )) || { echo "npm-downloads.sh: no public $SCOPE packages found under packages/" >&2; exit 1; }
+
+# add_months <YYYY-MM-DD> <n> — date(1) differs between BSD and GNU; try both.
+add_months() {
+  date -j -v+"$2"m -f '%Y-%m-%d' "$1" '+%Y-%m-%d' 2>/dev/null \
+    || date -d "$1 + $2 months" '+%Y-%m-%d' 2>/dev/null
+}
+today() { date -u '+%Y-%m-%d'; }
+
+rows="[]"
+for p in "${pkgs[@]}"; do
+  enc="${p/\//%2F}"                                   # @oneie/sdk -> @oneie%2Fsdk
+  created="$(npm view "$p" time.created 2>/dev/null | head -1 | cut -c1-10)"
+  [[ -n "$created" ]] || { created="2024-01-01"; }
+  start="${SINCE:-$created}"
+  end="$(today)"
+
+  total=0; cursor="$start"
+  while [[ "$cursor" < "$end" ]]; do
+    stop="$(add_months "$cursor" 17)"
+    [[ -z "$stop" || "$stop" > "$end" ]] && stop="$end"
+    body="$(curl -sS --max-time 25 "https://api.npmjs.org/downloads/point/${cursor}:${stop}/${enc}" 2>/dev/null)"
+    # the API reports its refusals in a 200 body — read the field, not the status
+    err="$(printf '%s' "$body" | jq -r '.error // empty' 2>/dev/null)"
+    if [[ -n "$err" ]]; then
+      printf '  ! %s: %s\n' "$p" "$err" >&2
+    else
+      n="$(printf '%s' "$body" | jq -r '.downloads // 0' 2>/dev/null)"
+      [[ "$n" =~ ^[0-9]+$ ]] && total=$(( total + n ))
+    fi
+    [[ "$stop" == "$end" ]] && break
+    cursor="$(add_months "$stop" 0)"
+  done
+
+  wk="$(curl -sS --max-time 15 "https://api.npmjs.org/downloads/point/last-week/${enc}" 2>/dev/null | jq -r '.downloads // 0')"
+  ver="$(npm view "$p" version 2>/dev/null | tail -1)"
+  rows="$(printf '%s' "$rows" | jq --arg p "$p" --arg v "$ver" --arg c "$created" \
+            --argjson t "${total:-0}" --argjson w "${wk:-0}" \
+            '. + [{package:$p, version:$v, since:$c, all_time:$t, last_week:$w}]')"
+done
+
+if (( JSON )); then
+  printf '%s\n' "$rows" | jq .
+  exit 0
+fi
+
+printf '\n  %-24s %-9s %12s %10s   %s\n' "PACKAGE" "VERSION" "ALL TIME" "LAST WK" "SINCE"
+printf '  %s\n' "$(printf '─%.0s' {1..74})"
+printf '%s' "$rows" | jq -r '.[] | [.package,.version,(.all_time|tostring),(.last_week|tostring),.since] | @tsv' \
+  | while IFS=$'\t' read -r p v a w s; do printf '  %-24s %-9s %12s %10s   %s\n' "$p" "$v" "$a" "$w" "$s"; done
+printf '  %s\n' "$(printf '─%.0s' {1..74})"
+printf '  %-24s %-9s %12s %10s\n\n' "TOTAL" "" \
+  "$(printf '%s' "$rows" | jq '[.[].all_time]|add')" \
+  "$(printf '%s' "$rows" | jq '[.[].last_week]|add')"

package/scripts/one-agents.mjs

@@ -26,6 +26,8 @@
 //   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 --models   # which model each agent gets and WHY, emit nothing
+//   node .claude/scripts/one-agents.mjs --models --json   # the same as JSON on stdout (nothing written)
 //   node .claude/scripts/one-agents.mjs --self-test
 
 import { readFileSync, writeFileSync, readdirSync, mkdirSync, rmSync, existsSync } from 'node:fs'
@@ -48,15 +50,66 @@ const RESERVED = new Set([
   '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.
+// The Agent tool accepts ONLY these. MODEL_BY_TIER is the FALLBACK — the answer
+// when the declared model is not expressible here, or when nothing is declared.
 const MODEL_BY_TIER = {
   chairman: 'opus', ceo: 'opus', director: 'opus',
   specialist: 'sonnet', tool: 'haiku',
   1: 'sonnet', 2: 'sonnet', '1': 'sonnet', '2': 'sonnet',
 }
 
+// The closed set. NOTHING outside it may ever reach the Agent tool — which is
+// why resolveClaudeModel returns a member of this set and NEVER the declared
+// string. `fable` is legal and has no tier that produces it: it can only ever
+// arrive by being declared.
+const CLAUDE_MODELS = new Set(['opus', 'sonnet', 'haiku', 'fable'])
+
+/** The Anthropic family named by an OpenRouter-shaped id, or null.
+ *  Deliberately FAMILY-shaped, not an id list: `anthropic/claude-opus-5`,
+ *  `claude-sonnet-4-5`, `claude-sonnet-4-6` and whatever version ships next all
+ *  answer the same way, so a normalisation pass over the corpus cannot silently
+ *  change which Claude Code model an agent gets. */
+function claudeFamily(id) {
+  const base = id.toLowerCase().split('/').pop()
+  if (!base.startsWith('claude')) return null
+  return base.split(/[^a-z]+/).find(w => w === 'opus' || w === 'sonnet' || w === 'haiku') ?? null
+}
+
+/**
+ * Which Claude Code model this agent runs on, and WHICH RUNG SAID SO.
+ *
+ * Three outcomes, and the generated file names the one that happened — an agent
+ * running on sonnet because its grok declaration cannot be expressed here is a
+ * different fact from one running on sonnet because a human chose sonnet, and a
+ * reader who cannot tell them apart will "fix" the wrong one.
+ *
+ *   declared  — the declared model is expressible; it travels.
+ *   fallback  — declared, but an OpenRouter id Claude Code cannot run (grok,
+ *               kimi). A real limit of this bridge, not a bug in the agent.
+ *   tier      — nothing declared. Since C14 an absent `model:` means the
+ *               PLATFORM default at runtime (`DEFAULT_MODEL = 'x-ai/grok-4.5'`,
+ *               packages/sdk/src/billing.ts) — also not expressible here, so
+ *               absent lands on tier for the same honest reason grok does.
+ *
+ * @returns {{model: string, source: 'declared'|'fallback'|'tier', note: string}}
+ */
+function resolveClaudeModel(declared, tier) {
+  const fallback = MODEL_BY_TIER[tier] ?? 'sonnet'
+  const d = typeof declared === 'string' ? declared.trim() : ''
+  if (!d) return { model: fallback, source: 'tier', note: `${fallback} (tier — no model declared)` }
+  if (CLAUDE_MODELS.has(d.toLowerCase())) {
+    const m = d.toLowerCase()
+    return { model: m, source: 'declared', note: `${m} (declared ${d})` }
+  }
+  const fam = claudeFamily(d)
+  if (fam) return { model: fam, source: 'declared', note: `${fam} (declared ${d})` }
+  return {
+    model: fallback,
+    source: 'fallback',
+    note: `${fallback} (tier fallback — declared ${d} is not expressible in Claude Code)`,
+  }
+}
+
 // 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'
@@ -151,6 +204,11 @@ function collect() {
       name,
       src: rel,
       tier: String(meta.tier ?? 'specialist'),
+      // The RAW declared value, or undefined. Nothing fills a default here: this
+      // script parses the file itself (`frontmatter(readFileSync(...))` above),
+      // never the web loader — which since C14 fills the platform default in and
+      // would make every single agent read as `declared`.
+      model: meta.model ? String(meta.model) : undefined,
       reports_to: meta.reports_to ? String(meta.reports_to) : null,
       domain: String(meta.domain ?? 'governance'),
       title: meta.title ? String(meta.title) : name,
@@ -192,8 +250,73 @@ Backend routes live ONLY in \`one.ie/web/src/pages/api/\`.
 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.
+
+## The four verbs of working together — claim · delegate · chat · chain
+
+A meeting is not where you report. It is where you **take a row, hand a row, argue on the row,
+and put the rows in order.** All four are receivers; none is a convention you can improvise.
+
+    claim     tasks:claim    {"data":{"tid":"task:<24hex>","workspace":"<slug>"}}
+    delegate  tasks:reassign {"data":{"tid":"...","assignee":"<slug>","workspace":"..."}}
+              tasks:announce {"data":{"taskId":"...","tags":["bare","words"],"workspace":"..."}}
+    chat      tasks:comment  {"data":{"tid":"...","workspace":"...","body":"..."}}
+              thread:append  {"data":{"slug":"one","group":"space:one","sender":"<you>","role":"assistant","content":"..."}}
+    chain     tasks:subtask  {"data":{"parent":"task:...","title":"...","blockedBy":["task:..."],"workspace":"..."}}
+              tasks:depend   {"data":{"tid":"task:<blocked>","blockedBy":"task:<blocker>","workspace":"..."}}
+
+**CHAINING IS NOT BOOKKEEPING — it is what makes the board sequence itself.** \`tasks:claim\`
+is **blocker-gated**, and \`tasks:depend\` writes the very \`blocks\` edge that gate reads. So an
+unchained board hands every agent every row at once and nothing knows what comes first; a chained
+one refuses a claim whose prerequisites are still open. **Chain before you fan out, or the fan-out
+is a race.** \`tasks:depend\` refuses a self-edge and a reverse edge, so a cycle cannot be filed.
+
+**\`tasks:subtask\` is the verb for splitting work, not \`tasks:create\`.** It writes the row, its
+notes, its tags, its \`containment\` edge to the parent AND every \`blockedBy\` prerequisite in ONE
+pipeline — precisely so a child never appears claimable with an empty body or missing ordering.
+A child made with \`tasks:create\` is an orphan that somebody will claim before it is ready.
+
+**Delegation moves a row; it does not copy one.** \`tasks:reassign\` swaps the \`@<slug>\` tag in
+place and announces on the new tag set. An empty assignee unassigns and moves a \`picked\` row back
+to \`open\` — claimable means **open AND unassigned**. Never "delegate" by filing a second task:
+that is how a board grows a duplicate \`Handle: <title>\` row for work that already had one.
+
+**\`tasks:announce\` returns \`matched\`, and matched is not delivered.** It reports how many staked
+actors the tags reached, not how many acted. Quote it as reach; never as done.
+
+**The claimant is the attested caller, never a body field.** You cannot claim on someone else's
+behalf — hand them the row with \`tasks:reassign\` and let them claim it. **Under the shared
+gateway key the attested caller is the workspace, so every head's claim lands as \`@one\`** — follow
+\`tasks:claim\` with \`tasks:reassign {assignee: "<your slug>"}\` in the same breath, or the ledger
+cannot say who took the row.
+
+**Two rules that keep a chain honest**, and they are the same rule twice:
+- **A child's cast is a subset of its parent's.** Inherit by default, declare to narrow, **never
+  declare to widen.** A leaf must not quietly attach a stakeholder the parent never had.
+- **Depth needs a floor.** A parent that spawns children without any settling is a leak, not a
+  big plan. Freeze the parent's outcome before its children mint, and let \`fade\`/\`warn\` decay
+  what goes quiet.
+
+**No agent leaves a meeting without a tid.** Claimed, delegated (name who to), chained (name the
+parent), or **declined with an argument** — a refusal on principle is sometimes the best act
+available. "Blocked" with no named blocker is not a status, it is a shrug. A meeting whose output
+is a document and no moved row has failed, however good the document.
 `.trim()
 
 /** How many agents stake each tag — used to drop the non-discriminating ones
@@ -206,7 +329,8 @@ function indexStakes(roster) {
 
 function render(a, roster) {
   if (STAKE_FREQ.size === 0) indexStakes(roster)
-  const model = MODEL_BY_TIER[a.tier] ?? 'sonnet'
+  const resolved = resolveClaudeModel(a.model, a.tier)
+  const model = resolved.model
   const isDirector = a.tier === 'director' || a.tier === 'ceo' || a.tier === 'chairman'
   const tools = isDirector ? TOOLS_DIRECTOR
     : a.domain === 'engineering' ? TOOLS_ENGINEERING
@@ -232,14 +356,27 @@ function render(a, roster) {
   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(),
-    `Use for: ${stake}.`,
+    `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(' · ')}.\nYou 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.\n`
+    ? `\n## Your reports\n\nThese agents report to you and are spawnable by name: ${reports.join(' · ')}.\n${delegation}\n`
     : ''
 
+  // The provenance line goes in the MARKER block, NOT as a YAML comment inside
+  // the frontmatter. Measured: not one agent file Claude Code loads on this box
+  // carries a `#` line inside its frontmatter (0 of the 96 generated + 5
+  // hand-written), so a YAML comment there is unproven ground — and the failure
+  // would land on all 96 files at once, at a regeneration nobody is watching.
+  // The HTML comment below is proven to survive: it is the first line of every
+  // spawned agent's own system prompt.
   return `---
 name: ${a.name}
 description: "${desc}"
@@ -248,6 +385,7 @@ model: ${model}
 color: ${color}
 ---
 ${MARKER} from ${a.src} — do not hand-edit.
+     model: ${resolved.note}
      Edit the platform agent, then re-run the generator. -->
 
 ${SUBSTRATE}
@@ -288,10 +426,53 @@ if (args.includes('--self-test')) {
   // 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('/')))
 
+  // RED PROOFS for C16 — a declared Claude model must TRAVEL, and the generated
+  // file must SAY which of the three things happened. Literal fixtures, never
+  // corpus rows: exactly one agent declares opus today, so a corpus-keyed test
+  // would go red the moment that file is renamed.
+  const fx = (tier, model) => ({
+    name: 'fx', src: 'fx.md', tier, reports_to: null, domain: 'engineering',
+    title: 'Fixture', tagline: 'A fixture.', skills: [], subscribes: [], body: 'fixture body', model,
+  })
+  const declaredOpus = render(fx('specialist', 'anthropic/claude-opus-5'), [])
+  ok('declared opus travels', /^model: opus$/m.test(declaredOpus))
+  ok('declared opus says declared', declaredOpus.includes('model: opus (declared anthropic/claude-opus-5)'))
+  const declaredGrok = render(fx('specialist', 'x-ai/grok-4.5'), [])
+  ok('grok falls back to tier', /^model: sonnet$/m.test(declaredGrok))
+  ok('grok never travels verbatim', !declaredGrok.includes('x-ai/grok-4.5\n') && !/^model: .*\//m.test(declaredGrok))
+  ok('grok says tier fallback', declaredGrok.includes('model: sonnet (tier fallback — declared x-ai/grok-4.5 is not expressible in Claude Code)'))
+  const noModel = render(fx('specialist', undefined), [])
+  ok('no model declared falls back to tier', /^model: sonnet$/m.test(noModel))
+  ok('no model declared says so', noModel.includes('model: sonnet (tier — no model declared)'))
+  // The family map must be version-agnostic — C15 is normalising these ids right now.
+  ok('bare claude-sonnet-4-5 is expressible', /^model: sonnet$/m.test(render(fx('director', 'claude-sonnet-4-5'), [])))
+  ok('bare `sonnet` is expressible', /^model: sonnet$/m.test(render(fx('director', 'sonnet'), [])))
+  ok('fable stays a legal declared value', /^model: fable$/m.test(render(fx('specialist', 'fable'), [])))
+  ok('a director declaring haiku is honoured over its tier', /^model: haiku$/m.test(render(fx('director', 'anthropic/claude-haiku-4-5'), [])))
+  // C15 measured that OpenRouter's real ids use DOTS, not hyphens, for the
+  // version (`grok-4.5`), and 78 of 105 declared ids are not served at all — so
+  // the normalisation landing beside this one will rewrite the version
+  // separator. The family map must not care, and here is the proof that it does
+  // not: hyphen, dot, prefixed, unprefixed, all four answer the same.
+  ok('a dotted version resolves (anthropic/claude-sonnet-4.5)', /^model: sonnet$/m.test(render(fx('director', 'anthropic/claude-sonnet-4.5'), [])))
+  ok('a dotted unprefixed version resolves (claude-opus-4.6)', /^model: opus$/m.test(render(fx('specialist', 'claude-opus-4.6'), [])))
+  ok('a dotted haiku resolves (anthropic/claude-haiku-4.5)', /^model: haiku$/m.test(render(fx('ceo', 'anthropic/claude-haiku-4.5'), [])))
+  ok('a non-claude vendor id never resolves to a family', claudeFamily('x-ai/grok-4.5') === null && claudeFamily('moonshotai/kimi-k3') === null)
+
   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')))
+  // RED PROOF, STRENGTHENED for C16. Until a declared model could travel, this
+  // assertion read MODEL_BY_TIER[r.tier] — the table, not the emitted value —
+  // and so did `grok id never mapped through` above. Both were true and both
+  // were BLIND to the declared path, which is now the only way an OpenRouter id
+  // could reach the Agent tool. Assert on what render() actually writes, for
+  // every real roster row.
+  ok('every RESOLVED roster model is legal', roster.every(r => CLAUDE_MODELS.has(resolveClaudeModel(r.model, r.tier).model)))
+  const emitted = roster.map(r => (render(r, roster).match(/^model: (.*)$/m) ?? [])[1])
+  ok('no OpenRouter id reaches the Agent tool', emitted.every(m => CLAUDE_MODELS.has(m)))
+  ok('no emitted model carries a vendor slash', emitted.every(m => m && !m.includes('/')))
+  ok('every agent says which rung chose its model', roster.every(r => /\n     model: .+ \((declared |tier)/.test(render(r, roster))))
   const ceo = roster.find(r => r.name === 'ceo')
   ok('ceo present', !!ceo)
   ok('ceo drops the "*" wildcard subscribe', ceo && !ceo.subscribes.includes('*'))
@@ -316,7 +497,7 @@ if (args.includes('--self-test')) {
   // 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 < 12KB`, descBytes < 12 * 1024)
+  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)
@@ -324,6 +505,21 @@ if (args.includes('--self-test')) {
 
 const roster = collect()
 
+if (args.includes('--models')) {
+  const rows = roster.map(a => ({ name: a.name, tier: a.tier, declared: a.model ?? null, ...resolveClaudeModel(a.model, a.tier) }))
+  const tally = { declared: 0, fallback: 0, tier: 0 }
+  for (const r of rows) tally[r.source]++
+  if (args.includes('--json')) {
+    console.log(JSON.stringify({ total: rows.length, tally, agents: rows }, null, 2))
+    process.exit(0)
+  }
+  for (const r of rows.sort((x, y) => x.source.localeCompare(y.source) || x.name.localeCompare(y.name))) {
+    console.log(`  ${r.name.padEnd(28)} ${r.model.padEnd(7)} ${r.source.padEnd(9)} ${r.declared ?? '(none declared)'}`)
+  }
+  console.log(`\n${rows.length} agents — declared ${tally.declared} · tier fallback ${tally.fallback} · no model declared ${tally.tier}`)
+  process.exit(0)
+}
+
 if (args.includes('--chart')) {
   const byDomain = {}
   for (const a of roster) (byDomain[a.domain] ??= []).push(a)