create-pmos 0.15.0 → 0.16.1

package/workspace/focus.test.js

@@ -1,650 +0,0 @@
-#!/usr/bin/env node
-/* Unit suite for lib/focus.js — the Focus queue's pure classifier and its six sections.
- *
- * No framework, no mocks and no server: `buildFocus` does no I/O, so every case here is a real
- * input shape handed straight to the real function. That is the whole reason the module is pure —
- * the domain can be WALKED rather than sampled, and the property this surface lives or dies by is a
- * property about the domain, not about one screenshot.
- *
- * The suite is organised around the one invariant the module exists to hold:
- *
- *   A · the ladder domain — every step key × every status, and the two near-misses by name
- *   B · the session domain — all twelve cells of session-state's join
- *   C · the needs domain, and the exclusions that keep the queue short
- *   D · tier order, stable ranking, and the anchor/unanchored dedupe
- *   E · the badge — a bare number is impossible over a failed, deriving or absent read
- *   F · coverage — the in-flight cap is stated, with real numbers
- *   G · handoffs — a STATED absence, no digits, and never "nothing owed by you"
- *   H · objectives — four distinguishable states
- *   I · upkeep — memory absence stated, budget caveat present, no percentage anywhere
- *   J · delegated — verbatim session words, and delegate offers that resolve or are not made
- *   K · empty, absent and malformed inputs — nothing throws, nothing is invented
- *   L · purity + the grep that pins the one thing a future edit is most likely to "improve"
- *
- * Exits non-zero if any check fails.
- */
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const assert = require('assert');
-
-const focus = require('./lib/focus');
-const sessionState = require('./lib/session-state');
-
-const results = [];
-const ok = (name, cond, extra = '') => { results.push({ name, cond }); console.log(`${cond ? '✓' : '✗'} ${name}${extra ? ' — ' + extra : ''}`); };
-
-// ── fixture builders ────────────────────────────────────────────────────────────────────────────
-const AS_OF = '2026-07-29T14:02:11.000Z';
-/** A step as `computeWorkflow` emits it. */
-const step = (key, status, evidence = null, next = null) => ({ key, status, evidence, next, blocking: false, rule: null });
-/** A ladder row as the board's `data.live[]` carries it. */
-const row = (id, steps, extra = {}) => Object.assign({
-  id, title: `${id} title`, lane: 'feature', stage: 'spec', record: `planning/initiatives/${id}.md`,
-  anchor: 'q3-2026:o1:kr1', blockers: [], next: null, steps,
-}, extra);
-/** A board as `boardCache.board(root)` returns it. */
-const board = (rows, extra = {}) => {
-  const { data, ...env } = extra;
-  return Object.assign({
-    ok: true, empty: false, source: 'file-mode',
-    data: Object.assign({ live: rows, hidden: 0, total: rows.length, unreadable: [], accepted: 0, blocked: 0 }, data || {}),
-    as_of: AS_OF, stale: false, refreshing: false,
-  }, env);
-};
-const needsOk = (items) => ({ ok: true, empty: !items.length, data: { items } });
-const spineOk = (extra = {}) => Object.assign({ objectives: [], budgets: [], unanchored: [], unreadable: null, budgets_readable: true }, extra);
-const session = (id, shown, extra = {}) => Object.assign({ id, ws: 'w1', name: id, agent: 'claude', shown, quietMs: 60000 }, extra);
-
-const q = (f, kind) => f.queue.filter((i) => i.kind === kind);
-const hasQ = (f, kind) => q(f, kind).length > 0;
-
-try {
-  // ── A · the ladder domain ─────────────────────────────────────────────────────────────────────
-  const cells = [];
-  for (const key of focus.STEP_KEYS) for (const status of focus.STEP_STATUSES) {
-    cells.push({ key, status, c: focus.classifyStep(key, status) });
-  }
-  const admits = cells.filter((x) => x.c.qualifies).map((x) => `${x.key}/${x.status}`).sort();
-
-  ok('A1: the whole step domain is walked — 12 keys × 6 statuses = 72 cells, all answered',
-    cells.length === 72 && cells.every((x) => typeof x.c.qualifies === 'boolean' && typeof x.c.reason === 'string' && x.c.reason.length > 10),
-    `${cells.length} cells`);
-
-  ok('A2: EXACTLY three combinations admit — contract/blocked, accept/pending, anchor/blocked',
-    admits.join(', ') === 'accept/pending, anchor/blocked, contract/blocked', admits.join(', ') || 'none');
-
-  // The two near-misses, asserted BY NAME. Each is a plausible-looking admission that would make
-  // the queue long, comprehensive and worthless.
-  const acceptBlocked = focus.classifyStep('accept', 'blocked');
-  ok('A3 (near-miss): accept+blocked is REFUSED — the Gate does not open over an unfinished ladder',
-    acceptBlocked.qualifies === false && acceptBlocked.reason.includes('unfinished ladder'),
-    acceptBlocked.reason.slice(0, 78));
-
-  const contractPending = focus.classifyStep('contract', 'pending');
-  ok('A4 (near-miss): contract+pending is REFUSED — nothing is built yet, so nothing is owed',
-    contractPending.qualifies === false && contractPending.reason.includes('nothing has been built'),
-    contractPending.reason.slice(0, 78));
-
-  ok('A5: every agent-act step is refused at EVERY status — these are delegated\'s raw material',
-    focus.AGENT_ACT_STEPS.every((k) => focus.STEP_STATUSES.every((s) => !focus.classifyStep(k, s).qualifies)),
-    focus.AGENT_ACT_STEPS.join(', '));
-
-  ok('A6: build and quality never qualify, and quality says why (it is unknown by design)',
-    focus.STEP_STATUSES.every((s) => !focus.classifyStep('build', s).qualifies && !focus.classifyStep('quality', s).qualifies)
-      && focus.classifyStep('quality', 'unknown').reason.includes('never claims a test result it did not run'),
-    focus.classifyStep('quality', 'unknown').reason.slice(0, 60));
-
-  // The classifier is TOTAL, not a filter list. This is the check that separates the two: a step key
-  // the engine grows next quarter must default OUT, in every status, without anyone editing a list.
-  ok('A7: an unknown step key defaults OUT at every status, with a reason that says so',
-    focus.STEP_STATUSES.every((s) => focus.classifyStep('triage', s).qualifies === false)
-      && focus.classifyStep('triage', 'blocked').reason.includes('defaults OUT'),
-    focus.classifyStep('triage', 'blocked').reason.slice(0, 78));
-
-  ok('A8: an unknown STATUS on a PM step defaults OUT too (blocked-ish is not blocked)',
-    focus.classifyStep('contract', 'stalled').qualifies === false
-      && focus.classifyStep('accept', 'open').qualifies === false
-      && focus.classifyStep('anchor', 'missing').qualifies === false,
-    focus.classifyStep('contract', 'stalled').reason.slice(0, 70));
-
-  ok('A9: null/undefined key and status are answered rather than thrown at',
-    focus.classifyStep(null, null).qualifies === false && focus.classifyStep(undefined, undefined).qualifies === false,
-    focus.classifyStep(null, null).reason.slice(0, 60));
-
-  // The end-to-end version of A2/A3: the same fixture the anti-optimism note demands — an `accept`
-  // that is blocked, beside a `contract` that is blocked.
-  const nearMiss = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([
-      row('unfinished', [step('accept', 'blocked', 'blocked by: spec, anchor', 'the Acceptance Gate is the PM\'s (D12) — but it does not open over an unfinished ladder')]),
-      row('owes-contract', [step('contract', 'blocked', '3 run(s) logged, none with pre_run_contract.PM_approved: true', 'agree numbered done_criteria + test_method with the PM and record the approval in planning/runs/runs.jsonl')]),
-    ]),
-    needs: needsOk([]), spine: spineOk(),
-  });
-  ok('A10: end to end — accept+blocked is absent from the queue while contract+blocked is present',
-    nearMiss.queue.length === 1 && nearMiss.queue[0].kind === 'contract' && nearMiss.queue[0].subject === 'owes-contract',
-    JSON.stringify(nearMiss.queue.map((i) => `${i.kind}:${i.subject}`)));
-
-  ok('A11: the qualifying row carries rank, product, a why, and a read: line naming real files',
-    nearMiss.queue[0].rank === 1 && nearMiss.queue[0].product === 'w1'
-      && nearMiss.queue[0].why.includes('done_criteria')
-      && nearMiss.queue[0].read.includes(AS_OF)
-      && nearMiss.queue[0].read.includes('planning/initiatives/owes-contract.md')
-      && nearMiss.queue[0].read.includes('ladder step contract (blocked)')
-      && nearMiss.queue[0].read.includes('PM_approved'),
-    nearMiss.queue[0].read.slice(0, 110));
-
-  // ── B · the session domain ────────────────────────────────────────────────────────────────────
-  const twelve = sessionState.presentedStates();
-  ok('B1: all twelve cells of session-state\'s join are classified',
-    twelve.length === 12 && twelve.every((c) => typeof focus.classifySession(c.presented).qualifies === 'boolean'),
-    `${twelve.length} cells`);
-
-  ok('B2: ONLY `needs` admits — and it is reachable only from quiet + turn user',
-    twelve.filter((c) => focus.classifySession(c.presented).qualifies).every((c) => c.cadence === 'quiet' && c.turn === 'user')
-      && twelve.some((c) => focus.classifySession(c.presented).qualifies),
-    JSON.stringify(twelve.filter((c) => focus.classifySession(c.presented).qualifies)));
-
-  ok('B3: `working` is refused, and the reason names it as the most tempting thing to count',
-    focus.classifySession('working').qualifies === false && focus.classifySession('working').reason.includes('tempting'),
-    focus.classifySession('working').reason.slice(0, 70));
-
-  ok('B4: `blocked` is refused from the queue — a queue promising "you are the blocker" holds no maybes',
-    focus.classifySession('blocked').qualifies === false && focus.classifySession('blocked').reason.includes('maybe blocked'),
-    focus.classifySession('blocked').reason.slice(0, 80));
-
-  ok('B5: an unrecognised presented state defaults OUT',
-    focus.classifySession('stalled').qualifies === false && focus.classifySession('stalled').reason.includes('defaults OUT'),
-    focus.classifySession('stalled').reason.slice(0, 60));
-
-  const sess = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([]), needs: needsOk([]), spine: spineOk(),
-    sessions: [session('s-work', 'working'), session('s-quiet', 'quiet'), session('s-need', 'needs'),
-      session('s-block', 'blocked'), session('s-dead', 'exited')],
-  });
-  ok('B6: end to end — exactly one session reaches the queue, and it is the `needs` one',
-    sess.queue.length === 1 && sess.queue[0].kind === 'session-needs' && sess.queue[0].subject === 's-need',
-    JSON.stringify(sess.queue.map((i) => i.subject)));
-
-  ok('B7: `blocked` reaches DELEGATED carrying session-state\'s hedge verbatim',
-    sess.delegated.running.some((r) => r.id === 's-block' && r.word === 'maybe blocked' && r.hedged === true),
-    JSON.stringify(sess.delegated.running.map((r) => [r.id, r.word])));
-
-  ok('B8: delegated lists every non-exited session and drops only the exited one',
-    sess.delegated.running.map((r) => r.id).sort().join() === 's-block,s-need,s-quiet,s-work',
-    sess.delegated.running.map((r) => r.id).join());
-
-  ok('B9: every delegated word comes from session-state\'s WORD table, never re-typed here',
-    sess.delegated.running.every((r) => r.word === sessionState.WORD[r.shown]),
-    JSON.stringify(sess.delegated.running.map((r) => r.word)));
-
-  // ── C · the needs domain ──────────────────────────────────────────────────────────────────────
-  ok('C1: a derived `accept` and a derived `outcome` qualify; an unenumerated derived kind does not',
-    focus.classifyNeed('accept', true).qualifies && focus.classifyNeed('outcome', true).qualifies
-      && focus.classifyNeed('question', true).qualifies === false
-      && focus.classifyNeed('triage', true).qualifies === false,
-    focus.classifyNeed('question', true).reason.slice(0, 70));
-
-  ok('C2: a HARNESS-written entry qualifies whatever its kind — someone filed it against the PM',
-    focus.classifyNeed('question', false).qualifies && focus.classifyNeed('anything', undefined).qualifies,
-    focus.classifyNeed('question', false).reason);
-
-  const needsFx = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([]), spine: spineOk(),
-    needs: needsOk([
-      { run_id: 'r1', kind: 'accept', initiative_id: 'alpha', derived: true, question: 'Acceptance Gate open — evaluator says PASS (0.9)' },
-      { run_id: 'outcome:beta', kind: 'outcome', initiative_id: 'beta', derived: true, question: 'Outcome check due' },
-      { run_id: 'h1', kind: 'question', initiative_id: 'gamma', derived: false, question: 'which of the two do you want?' },
-      { run_id: 'x1', kind: 'fyi', initiative_id: 'delta', derived: true, question: 'nothing is asked of you' },
-    ]),
-  });
-  ok('C3: three of four needs admit — the derived `fyi` is refused',
-    needsFx.queue.length === 3 && !needsFx.queue.some((i) => i.subject === 'delta'),
-    JSON.stringify(needsFx.queue.map((i) => `${i.kind}:${i.subject}`)));
-
-  ok('C4: each needs row\'s read: line names the actual jsonl files it was derived from',
-    q(needsFx, 'need-accept')[0].read.includes('evals.jsonl') && q(needsFx, 'need-accept')[0].read.includes('acceptances.jsonl')
-      && q(needsFx, 'need-outcome')[0].read.includes('outcome_checks.jsonl')
-      && q(needsFx, 'need-question')[0].read.includes('needs.json'),
-    q(needsFx, 'need-accept')[0].read);
-
-  // ── D · tier order, ranking, dedupe ───────────────────────────────────────────────────────────
-  // One item of each tier, in one product. `zzz-anchor` is deliberately first in the fixture and
-  // last in the queue: tier order must beat insertion order.
-  const tiered2 = focus.buildFocus({
-    products: [{
-      id: 'w1',
-      name: 'pmos',
-      board: board([
-        row('zzz-anchor', [step('anchor', 'blocked', 'parent_kr is empty — unanchored work is rejected (D59)', 'set parent_kr … (a PM act)')]),
-        row('aaa-contract', [step('contract', 'blocked', '1 run(s) logged, none with pre_run_contract.PM_approved: true', 'agree … with the PM')]),
-      ], { data: { hidden: 0, total: 3, unreadable: [{ id: 'broken', error: 'this record will not parse' }] } }),
-      needs: needsOk([]),
-      spine: spineOk(),
-      sessions: [session('s-need', 'needs')],
-    }],
-  });
-  ok('D1: tier order is board-integrity → contract/gate → session waiting → intake',
-    tiered2.queue.map((i) => i.tier).join(' ') === '1 2 2b 4',
-    tiered2.queue.map((i) => `${i.tier}:${i.kind}`).join(' '));
-
-  ok('D2: ranks are 1..n in queue order, and `count` is exactly the queue length',
-    tiered2.queue.map((i) => i.rank).join() === '1,2,3,4' && tiered2.count === tiered2.queue.length,
-    `count=${tiered2.count} n=${tiered2.queue.length}`);
-
-  ok('D3: the unreadable-record row leads, above every blocker — nothing below a failed read is trusted',
-    tiered2.queue[0].kind === 'record-unreadable' && tiered2.queue[0].subject === 'broken',
-    tiered2.queue[0].id);
-
-  // Within a tier: product name, then subject. Two products, one item each, deliberately named so
-  // insertion order and sorted order disagree.
-  const two = focus.buildFocus({
-    products: [
-      { id: 'w2', name: 'zebra', board: board([row('b', [step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([]), spine: spineOk() },
-      { id: 'w1', name: 'apple', board: board([row('a', [step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([]), spine: spineOk() },
-    ],
-  });
-  ok('D4: within a tier the order is product name then id — stable between renders',
-    two.queue.map((i) => i.productName).join() === 'apple,zebra',
-    two.queue.map((i) => `${i.productName}/${i.subject}`).join(' '));
-
-  ok('D5: a queue row targets the right product AND the right initiative (R11 landing)',
-    two.queue[0].target.product === 'w1' && two.queue[0].target.id === 'a' && two.queue[0].target.kind === 'initiative'
-      && two.queue[1].target.product === 'w2' && two.queue[1].target.id === 'b',
-    JSON.stringify(two.queue.map((i) => i.target)));
-
-  ok('D6: a session row targets the session, not an initiative',
-    sess.queue[0].target.kind === 'session' && sess.queue[0].target.id === 's-need',
-    JSON.stringify(sess.queue[0].target));
-
-  // One fact, two views: the ladder's blocked `anchor` and the spine's `unanchored[]` row.
-  const dedup = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([row('drifter', [step('anchor', 'blocked', 'q3-2026:integrity:kr-a — no such KR', 'add the KR (a PM act)')])]),
-    needs: needsOk([]),
-    spine: spineOk({ unanchored: [{ id: 'drifter', title: 't', file: 'planning/initiatives/drifter.md', raw: 'q3-2026:integrity:kr-a', status: 'unresolvable', reason: 'no such KR' }] }),
-  });
-  ok('D7: the ladder anchor step and the spine unanchored row are ONE item, not two',
-    dedup.queue.length === 1 && dedup.queue[0].kind === 'anchor', JSON.stringify(dedup.queue.map((i) => i.kind)));
-
-  ok('D8: …and the folded-in second source is still named in the read: line, never dropped',
-    dedup.queue[0].read.includes('also') && dedup.queue[0].read.includes('surfaceSpine().unanchored[]'),
-    dedup.queue[0].read.slice(-100));
-
-  ok('D9: an unanchored record with no ladder row still reaches the intake tier (the cap is escaped)',
-    (() => {
-      const f = focus.buildFocus({
-        products: [{ id: 'w1', name: 'pmos' }],
-        board: board([], { data: { hidden: 93, total: 105 } }), needs: needsOk([]),
-        spine: spineOk({ unanchored: [{ id: 'hidden-one', raw: '', status: 'empty', reason: 'parent_kr is empty' }] }),
-      });
-      return f.queue.length === 1 && f.queue[0].tier === '4' && f.queue[0].subject === 'hidden-one';
-    })(), 'uncapped unanchored[] is the intake source for exactly this reason');
-
-  ok('D10: no internal join/sort key leaks into a rendered row',
-    tiered2.queue.every((i) => !('dedup' in i) && !('sortKey' in i)),
-    Object.keys(tiered2.queue[0]).join(','));
-
-  // ── E · the badge ─────────────────────────────────────────────────────────────────────────────
-  const healthy = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }], board: board([]), needs: needsOk([]), spine: spineOk(),
-  });
-  ok('E1: a successful read of nothing is CALM — zero, exact, and worded as an all-clear',
-    healthy.count === 0 && healthy.badge.exact === true && healthy.badge.unreadable === false
-      && healthy.badge.text === 'nothing needs you',
-    healthy.badge.text);
-
-  const brokenNeeds = focus.buildFocus({
-    products: [
-      { id: 'w1', name: 'pmos', board: board([row('a', [step('contract', 'blocked', 'e', 'n')])]), needs: { ok: false, error: 'the needs-you queue file is not valid JSON — corrupt state, not empty' }, spine: spineOk() },
-      { id: 'w2', name: 'other', board: board([]), needs: needsOk([]), spine: spineOk() },
-    ],
-  });
-  ok('E2: ANY failed read makes the badge read `needs unreadable` — never a partial sum',
-    brokenNeeds.badge.text === 'needs unreadable' && brokenNeeds.badge.unreadable === true && brokenNeeds.badge.exact === false,
-    brokenNeeds.badge.text);
-
-  ok('E3: …and the badge text contains NO DIGIT, so a broken product cannot hide inside a number',
-    !/\d/.test(brokenNeeds.badge.text), JSON.stringify(brokenNeeds.badge.text));
-
-  ok('E4: the failure is still reported — the reader\'s own string, verbatim, with its product',
-    brokenNeeds.badge.reasons.some((r) => r.includes('w1') && r.includes('not valid JSON')),
-    JSON.stringify(brokenNeeds.badge.reasons));
-
-  ok('E5: a failed needs read also FILES a tier-1 item — a broken honesty surface reads red, not zero',
-    hasQ(brokenNeeds, 'needs-unreadable') && q(brokenNeeds, 'needs-unreadable')[0].tier === '1',
-    q(brokenNeeds, 'needs-unreadable')[0].detail);
-
-  const pending = focus.buildFocus({
-    products: [
-      { id: 'w1', name: 'pmos', board: board([row('a', [step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([]), spine: spineOk() },
-      { id: 'w2', name: 'other', board: { pending: true, refreshing: true, as_of: null, stale: false }, needs: needsOk([]), spine: spineOk() },
-    ],
-  });
-  ok('E6: a DERIVING board is neither empty nor broken — the badge says so beside the number',
-    pending.badge.text === '1 need you · 1 product still deriving' && pending.badge.exact === false
-      && pending.badge.unreadable === false && pending.badge.deriving === 1,
-    pending.badge.text);
-
-  ok('E7: a deriving board files NO queue item and NO error — deriving is its own state',
-    !pending.queue.some((i) => i.product === 'w2')
-      && pending.coverage.find((c) => c.product === 'w2').state === 'deriving',
-    JSON.stringify(pending.coverage.map((c) => [c.product, c.state])));
-
-  const unsupplied = focus.buildFocus({ products: [{ id: 'w1', name: 'pmos' }] });
-  ok('E8: a read that never HAPPENED is `not read`, distinct from one that failed, and suppresses the number',
-    unsupplied.badge.exact === false && unsupplied.badge.unreadable === false
-      && unsupplied.badge.text.includes('not read') && unsupplied.badge.not_read === 3,
-    unsupplied.badge.text);
-
-  ok('E9: `count` is always exactly the queue length — there is no second total anywhere',
-    [healthy, brokenNeeds, pending, tiered2, needsFx, dedup].every((f) => f.count === f.queue.length && f.badge.n === f.queue.length),
-    'count === queue.length in every fixture');
-
-  const boardBroken = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: { ok: false, error: 'the board took longer than 120s to derive and was stopped', as_of: AS_OF, stale: true },
-    needs: needsOk([]), spine: spineOk(),
-  });
-  ok('E10: a failed BOARD leads the queue with the derivation\'s own reason, verbatim',
-    boardBroken.queue[0].kind === 'board-unreadable' && boardBroken.queue[0].tier === '1'
-      && boardBroken.queue[0].detail === 'the board took longer than 120s to derive and was stopped'
-      && boardBroken.badge.text === 'needs unreadable',
-    boardBroken.queue[0].detail);
-
-  // ── F · coverage ──────────────────────────────────────────────────────────────────────────────
-  const capped = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board(Array.from({ length: 12 }, (_, i) => row(`i${i}`, [step('build', 'done', '1 commit')])), { data: { hidden: 93, total: 105 } }),
-    needs: needsOk([]), spine: spineOk(),
-  });
-  ok('F1: the in-flight cap is stated per product with real numbers (R6\'s exact sentence)',
-    capped.coverage[0].line === "12 of 105 scanned · 93 outside the board's in-flight cap."
-      && capped.coverage[0].hidden === 93 && capped.coverage[0].total === 105,
-    capped.coverage[0].line);
-
-  ok('F2: nothing hidden is stated too — "none outside the cap" is a read, not a silence',
-    healthy.coverage[0].line.includes('none outside'), healthy.coverage[0].line);
-
-  const stale = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([], { stale: true, refreshing: true }), needs: needsOk([]), spine: spineOk(),
-  });
-  ok('F3: a stale board says when it was derived and that a refresh is running',
-    stale.coverage[0].stale === true && stale.coverage[0].line.includes(AS_OF) && stale.coverage[0].line.includes('refresh is running'),
-    stale.coverage[0].line);
-
-  ok('F4: a read: line off a stale board carries the staleness too — provenance is not laundered',
-    focus.buildFocus({
-      products: [{ id: 'w1', name: 'pmos' }],
-      board: board([row('a', [step('contract', 'blocked', 'e', 'n')])], { stale: true }),
-      needs: needsOk([]), spine: spineOk(),
-    }).queue[0].read.includes('stale, refresh running'), 'stale is named in the row, not only in the header');
-
-  // ── G · handoffs ──────────────────────────────────────────────────────────────────────────────
-  const h = healthy.handoffs;
-  ok('G1: handoffs is a STATED not-connected absence, not a calm empty and not a count',
-    h.connected === false && h.state === 'not-connected' && h.count === null && h.items.length === 0,
-    JSON.stringify({ state: h.state, count: h.count }));
-
-  ok('G2: the body contains NO DIGIT — no story count and no sync time can be read out of it',
-    !/\d/.test(h.body) && !/\d/.test(h.heading), h.body.slice(0, 80));
-
-  ok('G3: the body never says "nothing owed" — a calm all-clear over an absent connection is the watermelon',
-    !/nothing owed/i.test(h.body) && !/all clear/i.test(h.body) && /not connected/i.test(h.body),
-    h.body.slice(0, 96));
-
-  ok('G4: the body names WHY it cannot answer — credentials and an MCP server are a PM decision',
-    h.body.includes('No external tracker is configured') && h.body.includes('MCP server'), h.body.slice(-70));
-
-  ok('G5: tier 3 is declared and structurally empty — no queue item can ever carry it',
-    focus.TIERS.some((t) => t.tier === '3') && [healthy, tiered2, brokenNeeds, needsFx].every((f) => !f.queue.some((i) => i.tier === '3')),
-    'tier 3 declared, never populated');
-
-  // ── H · objectives ────────────────────────────────────────────────────────────────────────────
-  const objs = focus.buildFocus({
-    products: [
-      { id: 'w1', name: 'has', board: board([]), needs: needsOk([]), spine: spineOk({ objectives: [{ id: 'O1', key: 'o1', name: 'ship the loop' }, { id: 'O2', name: 'second' }] }) },
-      { id: 'w2', name: 'none', board: board([]), needs: needsOk([]), spine: spineOk() },
-      { id: 'w3', name: 'broke', board: board([]), needs: needsOk([]), spine: { objectives: [], budgets: [], unanchored: [], unreadable: 'the OKR documents could not be read' } },
-      { id: 'w4', name: 'unread', board: board([]), needs: needsOk([]) },
-    ],
-  }).objectives;
-  ok('H1: a product with objectives shows its TOP one only',
-    objs[0].state === 'objective' && objs[0].id === 'O1' && objs[0].name === 'ship the loop', JSON.stringify(objs[0]));
-
-  ok('H2: a successful read of a repo that declares none is CALM and says so',
-    objs[1].state === 'none' && objs[1].error === null && objs[1].note === 'this repository declares no objectives',
-    JSON.stringify(objs[1]));
-
-  ok('H3: a FAILED read is its own state and carries surfaceSpine\'s own string, not a paraphrase',
-    objs[2].state === 'error' && objs[2].error === 'the OKR documents could not be read', JSON.stringify(objs[2]));
-
-  ok('H4: a read that never happened is a FOURTH state — "not read" is not "declares none"',
-    objs[3].state === 'not-read' && objs[3].error.includes('not the same as none being declared'),
-    objs[3].error.slice(0, 80));
-
-  ok('H5: the failed objective row and the tier-1 queue item are two views of ONE fact',
-    (() => {
-      const f = focus.buildFocus({
-        products: [{ id: 'w3', name: 'broke', board: board([]), needs: needsOk([]), spine: { objectives: [], budgets: [], unanchored: [], unreadable: 'the OKR documents could not be read' } }],
-      });
-      return f.objectives[0].state === 'error' && hasQ(f, 'spine-unreadable')
-        && q(f, 'spine-unreadable')[0].detail === f.objectives[0].error;
-    })(), 'same string in both places');
-
-  // ── I · upkeep ────────────────────────────────────────────────────────────────────────────────
-  const up = focus.buildFocus({
-    products: [{
-      id: 'w1', name: 'pmos', board: board([]), needs: needsOk([]),
-      spine: spineOk({ budgets: [{ id: 'health:tech', name: 'tech', initiatives: [{ id: 'a' }, { id: 'b' }] }] }),
-    }],
-    budgetRegistry: [{ id: 'health:tech', cap: '20%', covers: 'refactors, debt paydown' }, { id: 'health:ops', cap: '10%', covers: 'pipelines' }],
-  }).upkeep;
-
-  ok('I1: memory grooming is a STATED absence — the mechanism is not built, and the count is null',
-    up.memory.state === 'absent' && up.memory.count === null && /not built/i.test(up.memory.body)
-      && !/\d/.test(up.memory.body), up.memory.body.slice(0, 70));
-
-  ok('I2: the declared budgets appear with their caps, and one that nothing anchors to is still listed',
-    up.budgets.rows.map((r) => r.id).join() === 'health:ops,health:tech'
-      && up.budgets.rows.find((r) => r.id === 'health:tech').cap === '20%'
-      && up.budgets.rows.find((r) => r.id === 'health:ops').total === 0,
-    JSON.stringify(up.budgets.rows.map((r) => [r.id, r.cap, r.total])));
-
-  ok('I3: the anchored count is per product and totalled — a count, never a verdict',
-    up.budgets.rows.find((r) => r.id === 'health:tech').total === 2
-      && up.budgets.rows.find((r) => r.id === 'health:tech').anchored[0].product === 'w1',
-    JSON.stringify(up.budgets.rows.find((r) => r.id === 'health:tech').anchored));
-
-  ok('I4: the caveat says the ratio is NOT the cap test, and names the missing quarterly denominator',
-    up.budgets.caveat === focus.BUDGET_CAVEAT && /QUARTER/.test(up.budgets.caveat)
-      && /NOT the cap test/.test(up.budgets.caveat), up.budgets.caveat.slice(0, 90));
-
-  ok('I5: NO percentage, share or ratio field exists on a budget row — a percentage implies a test that was never run',
-    up.budgets.rows.every((r) => !Object.keys(r).some((k) => /pct|percent|share|ratio|over_?cap/i.test(k))),
-    Object.keys(up.budgets.rows[0]).join(','));
-
-  const noReg = focus.buildFocus({ products: [{ id: 'w1', board: board([]), needs: needsOk([]), spine: spineOk() }] }).upkeep;
-  ok('I6: with no registry supplied, no cap is shown and the absence is stated rather than guessed',
-    noReg.budgets.state === 'not-read' && noReg.budgets.rows.every((r) => r.cap === null)
-      && noReg.budgets.note.includes('were not supplied to this call'), noReg.budgets.note.slice(0, 80));
-
-  // ── J · delegated ─────────────────────────────────────────────────────────────────────────────
-  ok('J1: skill paths are pulled out of the engine\'s own `next` text, both roots, deduped',
-    focus.skillPathsIn('score the build against the rubric (build-skills/evaluator.skill), then append')
-      .join() === 'build-skills/evaluator.skill'
-      && focus.skillPathsIn('write skills/core/prd.skill and skills/core/eval-rubric.skill').length === 2
-      && focus.skillPathsIn('the PM names one thing verified BY HAND').length === 0,
-    JSON.stringify(focus.skillPathsIn('write skills/core/prd.skill and skills/core/eval-rubric.skill')));
-
-  const specRow = row('needs-prd', [step('spec', 'blocked', 'no prd_path', 'write the PRD with skills/core/prd.skill and the rubric with skills/core/eval-rubric.skill')]);
-  const withIndex = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([specRow]), needs: needsOk([]), spine: spineOk(),
-    skills: ['skills/core/prd.skill', 'build-skills/evaluator.skill'],
-  });
-  ok('J2: a ▶ delegate is offered ONLY for the skill path that exists in the supplied index',
-    withIndex.delegated.starts.length === 1 && withIndex.delegated.starts[0].skill === 'skills/core/prd.skill'
-      && withIndex.delegated.starts[0].initiative === 'needs-prd',
-    JSON.stringify(withIndex.delegated.starts.map((s) => s.skill)));
-
-  ok('J3: the start carries an initialInput naming the initiative AND the skill — no invented agent',
-    withIndex.delegated.starts[0].initialInput.includes('skills/core/prd.skill')
-      && withIndex.delegated.starts[0].initialInput.includes('needs-prd'),
-    withIndex.delegated.starts[0].initialInput.slice(0, 80));
-
-  const noIndex = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }], board: board([specRow]), needs: needsOk([]), spine: spineOk(),
-  });
-  ok('J4: with NO on-disk index, no start is offered at all, and the reason is stated',
-    noIndex.delegated.starts.length === 0 && noIndex.delegated.starts_state === 'not-resolved'
-      && noIndex.delegated.starts_note.includes('worse than no offer'),
-    noIndex.delegated.starts_note.slice(0, 80));
-
-  ok('J5: …and what WOULD have been offered is still visible as a candidate, never as a button',
-    noIndex.delegated.candidates.length === 2 && noIndex.delegated.starts.length === 0,
-    JSON.stringify(noIndex.delegated.candidates.map((c) => c.skill)));
-
-  const pmStepWithSkill = focus.buildFocus({
-    products: [{ id: 'w1', name: 'pmos' }],
-    board: board([row('gate', [step('contract', 'blocked', 'e', 'agree with the PM, see skills/core/prd.skill')])]),
-    needs: needsOk([]), spine: spineOk(), skills: ['skills/core/prd.skill'],
-  });
-  ok('J6: a step the PM owns NEVER gets a delegate button, whatever its `next` text happens to say',
-    pmStepWithSkill.delegated.starts.length === 0 && pmStepWithSkill.queue.length === 1,
-    JSON.stringify(pmStepWithSkill.delegated.starts));
-
-  ok('J7: the skill index is honoured as a set — a path not on disk is silently not offered',
-    focus.buildFocus({
-      products: [{ id: 'w1' }], board: board([specRow]), needs: needsOk([]), spine: spineOk(), skills: [],
-    }).delegated.starts.length === 0, 'an empty index offers nothing');
-
-  // The six sections are always present, in order, however empty the inputs are.
-  const SECTIONS = ['objectives', 'queue', 'handoffs', 'delegated', 'upkeep'];
-  ok('J8: every call returns the six section keys plus a derived count — none is omitted when empty',
-    [healthy, brokenNeeds, unsupplied, focus.buildFocus({})].every((f) =>
-      SECTIONS.every((k) => f[k] != null) && typeof f.count === 'number' && typeof f.intro === 'string'),
-    SECTIONS.concat('count').join(','));
-
-  ok('J9: the intro line is the contract, printed — it is what the membership rule is accountable to',
-    healthy.intro === 'This list holds only items where you are the blocker. Everything else is running on an agent or waiting on another team.',
-    healthy.intro);
-
-  // ── K · empty, absent and malformed inputs ────────────────────────────────────────────────────
-  const nothing = focus.buildFocus();
-  ok('K1: no argument at all returns the full shape rather than throwing',
-    nothing.count === 0 && Array.isArray(nothing.queue) && Array.isArray(nothing.objectives)
-      && nothing.handoffs.connected === false, JSON.stringify({ count: nothing.count }));
-
-  ok('K2: …and it claims nothing — every read is `not read`, so the badge is not a calm zero',
-    nothing.reads.every((r) => r.state === 'not-read') && nothing.badge.exact === false
-      && nothing.badge.text !== 'nothing needs you', nothing.badge.text);
-
-  const junk = focus.buildFocus({
-    products: [{ id: 'w1', name: 'x', board: 'not an object', needs: 42, spine: [], sessions: 'nope', ladders: 7 }],
-    skills: 'not a list',
-  });
-  ok('K3: malformed reads are ERRORS with a stated shape complaint, never treated as empty',
-    junk.reads.every((r) => r.state === 'error') && junk.badge.text === 'needs unreadable'
-      && junk.queue.length === 3,
-    JSON.stringify(junk.reads.map((r) => r.source + ':' + r.state)));
-
-  ok('K4: a board whose ok flag is missing entirely is refused as an unrecognised shape',
-    focus.readBoard({ data: { live: [] } }).state === 'error'
-      && focus.readBoard({ data: { live: [] } }).error.includes('unrecognised shape'),
-    focus.readBoard({ data: { live: [] } }).error);
-
-  ok('K5: an EMPTY board (a repo with no records) is calm, not red — a successful read of nothing',
-    focus.readBoard({ ok: true, empty: true, source: 'file-mode', as_of: AS_OF }).state === 'empty',
-    'empty board is calm');
-
-  ok('K6: rows and steps that are not objects are skipped without throwing',
-    focus.buildFocus({
-      products: [{ id: 'w1', board: board([null, 'x', row('a', [null, 'y', step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([null, 'z']), spine: spineOk() }],
-    }).queue.length === 1, 'one real item survives the junk');
-
-  ok('K7: an on-demand ladder overrides the board row for the same id — it is never the older read',
-    (() => {
-      const f = focus.buildFocus({
-        products: [{
-          id: 'w1',
-          board: board([row('a', [step('contract', 'blocked', 'stale evidence', 'n')])]),
-          ladders: [{ ok: true, empty: false, row: row('a', [step('contract', 'done', 'PM-approved pre_run_contract on run r9')]) }],
-          needs: needsOk([]), spine: spineOk(),
-        }],
-      });
-      return f.queue.length === 0;
-    })(), 'the fresher ladder clears the blocker the cached board still shows');
-
-  ok('K8: a ladder read that FAILED files a tier-1 unreadable-record item with its own reason',
-    (() => {
-      const f = focus.buildFocus({
-        products: [{ id: 'w1', board: board([]), needs: needsOk([]), spine: spineOk(), ladders: { bad: { ok: false, id: 'bad', error: 'the record for bad could not be read' } } }],
-      });
-      return f.queue.length === 1 && f.queue[0].tier === '1' && f.queue[0].subject === 'bad'
-        && f.queue[0].detail === 'the record for bad could not be read';
-    })(), 'a failed ladder read is the same fact as an unreadable board row');
-
-  ok('K9: a top-level board is NOT shared across several products — one repo\'s ladder is never attributed to all',
-    focus.buildFocus({
-      products: [{ id: 'w1', name: 'a' }, { id: 'w2', name: 'b' }],
-      board: board([row('a', [step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([]), spine: spineOk(),
-    }).queue.length === 0, 'the convenience form applies only to a single product');
-
-  ok('K10: sessions ARE partitioned across products, because sessionList rows carry `ws`',
-    (() => {
-      const f = focus.buildFocus({
-        products: [
-          { id: 'w1', name: 'a', board: board([]), needs: needsOk([]), spine: spineOk() },
-          { id: 'w2', name: 'b', board: board([]), needs: needsOk([]), spine: spineOk() },
-        ],
-        sessions: [session('s1', 'needs', { ws: 'w1' }), session('s2', 'needs', { ws: 'w2' })],
-      });
-      return f.queue.length === 2 && f.queue[0].product === 'w1' && f.queue[1].product === 'w2';
-    })(), 'a session lands on its own product');
-
-  // ── L · purity + the grep ─────────────────────────────────────────────────────────────────────
-  const input = {
-    products: [{ id: 'w1', name: 'pmos', board: board([row('a', [step('contract', 'blocked', 'e', 'n')])]), needs: needsOk([{ run_id: 'r', kind: 'accept', derived: true }]), spine: spineOk({ objectives: [{ id: 'O1', name: 'x' }] }), sessions: [session('s', 'needs')] }],
-    skills: ['skills/core/prd.skill'], budgetRegistry: [{ id: 'health:tech', cap: '20%' }],
-  };
-  const frozen = JSON.stringify(input);
-  const one = focus.buildFocus(input);
-  const twoRuns = focus.buildFocus(input);
-  let same = true;
-  try { assert.deepStrictEqual(one, twoRuns); } catch { same = false; }
-  ok('L1: two calls over one input return an identical shape — no clock, no counter, no order drift', same);
-
-  ok('L2: the input object is not mutated — the caller\'s reads are still their own afterwards',
-    JSON.stringify(input) === frozen, 'input unchanged');
-
-  const src = fs.readFileSync(path.join(__dirname, 'lib', 'focus.js'), 'utf8');
-  ok('L3: the module reads no clock — no Date.now, no new Date, no hrtime anywhere in it',
-    !/Date\.now\s*\(/.test(src) && !/new\s+Date\s*\(/.test(src) && !/hrtime/.test(src), 'no clock');
-
-  ok('L4: the module does no I/O — it requires no fs, path, child_process or http',
-    !/require\(['"](fs|path|child_process|http|https|net)['"]\)/.test(src), 'no I/O requires');
-
-  // Cheap, and it pins the one thing a future edit is most likely to "improve" (PRD Test method).
-  ok('L5: the module names NO external tracker — the handoffs section can only ever be not-connected',
-    !/jira|confluence|slack|gworkspace|google\s*workspace/i.test(src),
-    (src.match(/jira|confluence|slack|gworkspace/i) || ['none'])[0]);
-
-  ok('L6: nor does it reference a sync, a story count or a connection status it cannot read',
-    !/synced|last[_ ]?sync|stories?\s*done|connected\s*:\s*true/i.test(src),
-    (src.match(/synced|stories? done|connected\s*:\s*true/i) || ['none'])[0]);
-
-  ok('L7: `count` has no persisted twin — the only assignment to it is the queue length',
-    (src.match(/^\s*const count = queue\.length;/m) || []).length === 1
-      && !/cachedCount|storedCount|lastCount|countCache/.test(src), 'derived in one place');
-} catch (e) {
-  ok('no exceptions during suite', false, e && e.stack ? e.stack.split('\n').slice(0, 3).join(' @ ') : String(e));
-} finally {
-  const failed = results.filter((r) => !r.cond);
-  console.log(`\n${results.length - failed.length}/${results.length} passed${failed.length ? ' — FAILURES: ' + failed.map((f) => f.name).join('; ') : ''}`);
-  process.exit(failed.length ? 1 : 0);
-}