create-claude-cabinet 0.52.0 → 0.53.0

package/templates/scripts/__tests__/ring2-roster-review.test.mjs

@@ -194,16 +194,23 @@ test('parseDormantSkills: extracts dead/stale, caps, computes hasFindings', () =
   assert.equal(parseDormantSkills({ dead: [], stale: [] }).hasFindings, false);
   assert.equal(parseDormantSkills(null).hasFindings, false);
 
-  // cap
+  // cap bounds the DISPLAY list, never the count (act:ea23b3a5). It used to be
+  // both, and the title was built from the sliced array — so every project ever
+  // measured reported exactly "12 dead", a saturated constant wearing the
+  // costume of a measurement.
   const many = { dead: Array.from({ length: 20 }, (_, i) => ({ skill: `d${i}` })), stale: [] };
-  assert.equal(parseDormantSkills(many, { cap: 5 }).dead.length, 5);
+  const capped = parseDormantSkills(many, { cap: 5 });
+  assert.equal(capped.dead.length, 5, 'names are bounded');
+  assert.equal(capped.dead_count, 20, 'the count is TRUE');
+  assert.equal(parseDormantSkills(reader).dead_count, 2);
+  assert.equal(parseDormantSkills(reader).stale_count, 1);
 });
 
 // =====================================================================
 // Orchestrator (injected deps — hermetic)
 // =====================================================================
 
-test('reviewCabinetRoster: files the three roster findings, stamps state, dedups, respects cadence', async () => {
+test('reviewCabinetRoster: only uncovered-tech FILES; dormant/briefing become ambient metrics (act:ea23b3a5)', async () => {
   clearQueue();
   rmSync(join(root, 'state', 'roster-review.json'), { force: true });
 
@@ -219,38 +226,85 @@ test('reviewCabinetRoster: files the three roster findings, stamps state, dedups
 
   await reviewCabinetRoster(config, deps);
 
+  // uncovered-tech PROPOSES A CABINET SEAT — a real decision, so it stays a
+  // queue item. The other two are measurements and belong in ambient state.
   const items = listQueue();
-  const kinds = items.map(i => i.evidence?.roster_kind).sort();
-  assert.deepEqual(kinds, ['dormant-skill', 'stale-briefing', 'uncovered-tech']);
-  // every finding is an ungated advisor-finding from ring2-slow
+  assert.deepEqual(items.map(i => i.evidence?.roster_kind).sort(), ['uncovered-tech']);
   for (const it of items) {
     assert.equal(it.category, 'advisor-finding');
     assert.equal(it.filed_by, 'ring2-slow');
     assert.equal(it.project, 'roster-proj');
   }
   assert.equal(calls.ask, 1, 'one coverage call');
-  assert.equal(calls.reader, 1, 'one reader call');
+  assert.equal(calls.reader, 1, 'one reader call — the measurement still happens');
 
-  // cadence stamped + project recorded
+  // cadence stamped + project recorded + metrics landed in the ONE trailing write
   const state = JSON.parse(readFileSync(join(root, 'state', 'roster-review.json'), 'utf8'));
   assert.ok(state.last_run);
   assert.ok(state.projects_checked['roster-proj']);
-
-  // 2nd run, same now → cadence gate blocks (no new calls, no new items)
+  const m = state.metrics['roster-proj'];
+  assert.ok(m, 'metrics must survive reviewCabinetRoster\'s wholesale state rewrite');
+  assert.equal(m.dormant.dead_count, 1);
+  assert.deepEqual(m.dormant.dead, ['dead-skill'], 'names, not just a count');
+  assert.equal(m.stale_briefings.length, 1);
+  assert.ok(m.measured_at);
+  assert.equal(m.previous, null, 'first measurement has no prior to compare against');
+
+  // 2nd run, same now → cadence gate blocks
   await reviewCabinetRoster(config, deps);
   assert.equal(calls.ask, 1, 'cadence gate prevents a second coverage call');
-  assert.equal(listQueue().length, 3, 'no duplicate items while cadence holds');
+  assert.equal(listQueue().length, 1, 'no duplicate items while cadence holds');
 
-  // 3rd run, now advanced past the interval, items still pending → dedup blocks
-  // re-filing (reference, not duplicate)
+  // 3rd run past the interval: the uncovered-tech dedup still holds, and the
+  // measurement carries its prior forward so Ring 1 can render on change.
   const later = {
     ...deps,
     now: deps.now + (ROSTER_REVIEW_INTERVAL_DAYS + 1) * DAY,
     ask: async () => { calls.ask++; return 'GAP: WebGL — still uncovered'; },
-    runSkillUsage: async () => { calls.reader++; return { days: 30, dead: [{ skill: 'dead-skill' }], stale: [] }; },
+    runSkillUsage: async () => { calls.reader++; return { days: 30, dead: [{ skill: 'dead-skill' }, { skill: 'another' }], stale: [] }; },
   };
   await reviewCabinetRoster(config, later);
-  assert.equal(listQueue().length, 3, 'dedup prevents duplicate roster findings');
+  assert.equal(listQueue().length, 1, 'dedup prevents duplicate roster findings');
+  const state2 = JSON.parse(readFileSync(join(root, 'state', 'roster-review.json'), 'utf8'));
+  assert.equal(state2.metrics['roster-proj'].dormant.dead_count, 2);
+  assert.deepEqual(state2.metrics['roster-proj'].previous, { dead_count: 1, stale_count: 0 });
+});
+
+test('reviewCabinetRoster retires pending dormant-skill / stale-briefing items once', async () => {
+  // The migration the change carries with it: fileRosterFinding and its dedup
+  // were the ONLY code that ever touched these items. Without this they would
+  // display a stale count for up to 30 days beside a live ambient line saying
+  // something else — dual existence.
+  clearQueue();
+  rmSync(join(root, 'state', 'roster-review.json'), { force: true });
+
+  const q = await import('../watchtower-queue.mjs');
+  const keep = q.createItem({
+    project: 'roster-proj', project_path: '/tmp/x', filed_by: 'ring2-slow',
+    category: 'advisor-finding', urgency: 'low', title: 'Roster coverage gap: roster-proj (3)',
+    summary: 's', evidence: { roster_kind: 'uncovered-tech' },
+  });
+  const retireA = q.createItem({
+    project: 'roster-proj', project_path: '/tmp/x', filed_by: 'ring2-slow',
+    category: 'advisor-finding', urgency: 'low', title: 'Dormant skills: roster-proj (12 dead, 11 stale)',
+    summary: 's', evidence: { roster_kind: 'dormant-skill' },
+  });
+  const retireB = q.createItem({
+    project: 'roster-proj', project_path: '/tmp/x', filed_by: 'ring2-slow',
+    category: 'advisor-finding', urgency: 'low', title: 'Stale cabinet briefings: roster-proj (2)',
+    summary: 's', evidence: { roster_kind: 'stale-briefing' },
+  });
+
+  const retired = ring2.retireRosterFindingItems();
+  assert.deepEqual(retired.sort(), [retireA, retireB].sort());
+
+  const statuses = Object.fromEntries(listQueue().map(i => [i.id, i.status]));
+  assert.equal(statuses[keep], 'pending', 'the decision item is untouched');
+  assert.equal(statuses[retireA], 'superseded');
+  assert.equal(statuses[retireB], 'superseded');
+
+  // Idempotent: a second pass finds nothing left pending.
+  assert.deepEqual(ring2.retireRosterFindingItems(), []);
 });
 
 test('reviewCabinetRoster: COVERAGE OK + no stale briefings + no dormant skills → no items', async () => {
@@ -307,5 +361,10 @@ test('reviewCabinetRoster: a thrown reader does not abort the other two checks',
   });
 
   const kinds = listQueue().map(i => i.evidence?.roster_kind).sort();
-  assert.deepEqual(kinds, ['stale-briefing', 'uncovered-tech'], 'reader failure isolated; coverage + briefing still filed');
+  assert.deepEqual(kinds, ['uncovered-tech'], 'reader failure isolated; the coverage decision still files');
+
+  // and the briefing measurement still lands in ambient state
+  const state = JSON.parse(readFileSync(join(root, 'state', 'roster-review.json'), 'utf8'));
+  assert.equal(state.metrics['partial-proj'].stale_briefings.length, 1);
+  assert.equal(state.metrics['partial-proj'].dormant, undefined, 'the thrown reader contributed nothing');
 });

package/templates/scripts/__tests__/ring3-completion-filter.test.mjs

@@ -1,22 +1,30 @@
-// Phase 2c create-vs-complete filter (act:9eebbac4, Lane B of
-// grp:wt-noise-immunity).
+// Phase 2c emit guard — the confidence inversion (act:ea23b3a5) that REPLACED
+// the create-vs-complete day-window filter (act:9eebbac4).
 //
-// The bug: the completion detector filed completion-review items for actions
-// whose only session evidence was their own CREATION — 12 of 66 live items
-// in the 2026-07-12 drain carried reasons like "created as a new action, not
-// completed". The filter extends completionReviewEmitGuard (act:23eb5897 /
-// ec508dbe — extend, don't fork) with a mechanical conjunct: the action
-// row's `created` date falls inside the session's window AND the model's
-// confidence is below 'high'. Every gap fails OPEN (emit): missing
-// sessionDate, missing created column, thrown lookup — suppression only on
-// positive mechanical evidence, per the never-wholesale-suppression
-// discipline.
+// What this file used to assert, and why it no longer does. act:9eebbac4 read
+// "an action created this session whose only evidence is its own creation is
+// not a completion candidate" and suppressed on it — but EXEMPTED
+// confidence: 'high', on the theory that high confidence means the transcript
+// shows the work itself done. A full-corpus measurement on 2026-07-26 (all 223
+// items the category had ever filed, each joined against the cited action's own
+// project db) inverted that theory:
+//
+//     high        12 acted-on / 28 dismissed-noise    30% precision
+//     medium+low  48 acted-on / 32 dismissed-noise    60% precision
+//
+//     same-day creation + medium/low  (the filter SUPPRESSED this)  74%
+//     same-day creation + high        (the filter EXEMPTED this)    33%
+//
+// Split at the filter's 2026-07-12 ship date, the category went 0-for-23 — zero
+// acted-on, 19 dismissed as noise. So the filter was deleted and the exempted
+// bucket is now the suppressed one. Twelve of the nineteen dismissals in the
+// 2026-07-26 tail triage were rated 'high'; that cohort is the fixture below.
 //
 // Hermetic: the guard takes a fake prepared statement; no sqlite, no model.
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -24,142 +32,123 @@ const root = mkdtempSync(join(tmpdir(), 'ring3-completion-filter-'));
 process.env.WATCHTOWER_DIR = root;
 mkdirSync(join(root, 'queue', 'items'), { recursive: true });
 
-const { completionReviewEmitGuard } = await import('../watchtower-ring3-close.mjs');
+const { completionReviewEmitGuard, verifyCompletionQuote, decodeTranscriptText, preprocessTranscript } =
+  await import('../watchtower-ring3-close.mjs');
 
 test.after(() => rmSync(root, { recursive: true, force: true }));
 
-const SESSION_DATE = '2026-07-10';
 const stmtReturning = (row) => ({ get: () => row });
-const OPEN_CREATED_IN_SESSION = { status: 'open', created: '2026-07-10' };
-const OPEN_CREATED_EARLIER = { status: 'open', created: '2026-07-01' };
+const OPEN = { status: 'open' };
 
 // ---------------------------------------------------------------------------
-// The filter fires — positive confirmation, not just green fallbacks
+// The confidence inversion fires — positive confirmation, not a green fallback
 // ---------------------------------------------------------------------------
 
-test('created this session + non-high confidence → suppressed with a distinct reason', () => {
+test("high confidence → suppressed, with a reason naming the calibration", () => {
   const guard = completionReviewEmitGuard('act:aaaa1111', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
+    statusStmt: stmtReturning(OPEN),
+    confidence: 'high',
   });
   assert.equal(guard.emit, false);
-  assert.match(guard.reason, /within this session's day window/, 'distinct reason names the filter');
-  assert.match(guard.reason, /creation is not completion/);
+  assert.match(guard.reason, /anti-predictive/);
+  assert.match(guard.reason, /calibration note/);
 });
 
-test('past-midnight spill (created the day after session start) → suppressed', () => {
-  const guard = completionReviewEmitGuard('act:aaaa1111', {
-    statusStmt: stmtReturning({ status: 'open', created: '2026-07-11' }),
-    sessionDate: SESSION_DATE,
-    confidence: 'low',
+test('confidence matching is case-insensitive — a deviant "High" is still suppressed', () => {
+  // Direction matters: this arm is deliberately fail-CLOSED (the one such arm
+  // in the guard), so a malformed spelling must not become an escape hatch.
+  const guard = completionReviewEmitGuard('act:aaaa2222', {
+    statusStmt: stmtReturning(OPEN),
+    confidence: 'High',
   });
   assert.equal(guard.emit, false);
 });
 
-test('reprocess safety: an action born in a LATER intervening session → emits', () => {
-  // An old transcript re-run must not suppress retroactive completion
-  // evidence for actions created days after that session.
-  const guard = completionReviewEmitGuard('act:aaaa1111', {
-    statusStmt: stmtReturning({ status: 'open', created: '2026-07-13' }),
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
-  });
-  assert.equal(guard.emit, true);
-});
-
-test('confidence matching is case-insensitive — a deviant "High" still rescues', () => {
-  const guard = completionReviewEmitGuard('act:aaaa1111', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    sessionDate: SESSION_DATE,
-    confidence: 'High',
-  });
-  assert.equal(guard.emit, true, 'malformed spelling must not flip fail-open into fail-closed');
+test('the 2026-07-26 tail cohort: 12 of 19 dismissals were high → at most 7 still emit', () => {
+  // The calibration corpus itself, as the fixture. Confidences taken from the
+  // 19 items dismissed noise on 2026-07-26 (queue items, resolution_type
+  // 'noise', category completion-review): 12 high, 4 medium, 3 low.
+  const cohort = [
+    ...Array(12).fill('high'),
+    ...Array(4).fill('medium'),
+    ...Array(3).fill('low'),
+  ];
+  const emitted = cohort.filter((confidence, i) =>
+    completionReviewEmitGuard(`act:cohort${String(i).padStart(2, '0')}`, {
+      statusStmt: stmtReturning(OPEN),
+      confidence,
+    }).emit).length;
+  assert.equal(emitted, 7, 'the high bucket is suppressed; the 7 medium/low still file');
 });
 
 // ---------------------------------------------------------------------------
-// The legitimate flows keep emitting
+// The cohort the deleted filter used to suppress now files — this is the point
 // ---------------------------------------------------------------------------
 
-test('created in a PRIOR session + completion evidence → emits', () => {
-  const guard = completionReviewEmitGuard('act:bbbb2222', {
-    statusStmt: stmtReturning(OPEN_CREATED_EARLIER),
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
-  });
-  assert.equal(guard.emit, true);
+test('an action created THIS session at medium/low confidence now EMITS (74% cohort restored)', () => {
+  // act:9eebbac4 suppressed exactly this. Measured at 20 acted-on / 7 noise —
+  // the highest-precision cell in the whole corpus.
+  for (const confidence of ['medium', 'low']) {
+    const guard = completionReviewEmitGuard('act:bbbb1111', {
+      statusStmt: stmtReturning({ status: 'open', created: '2026-07-10' }),
+      confidence,
+    });
+    assert.equal(guard.emit, true, `${confidence} must emit regardless of the created date`);
+  }
 });
 
-test('created this session but HIGH confidence (create-then-complete flow) → emits', () => {
-  const guard = completionReviewEmitGuard('act:cccc3333', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    sessionDate: SESSION_DATE,
-    confidence: 'high',
+test('the guard no longer reads a created date at all', () => {
+  // A row carrying no `created` column and a row created today are
+  // indistinguishable to the guard — proof the day-window logic is gone rather
+  // than merely unreachable.
+  const withCreated = completionReviewEmitGuard('act:bbbb2222', {
+    statusStmt: stmtReturning({ status: 'open', created: new Date().toISOString().slice(0, 10) }),
+    confidence: 'medium',
   });
-  assert.equal(guard.emit, true);
+  const without = completionReviewEmitGuard('act:bbbb2222', {
+    statusStmt: stmtReturning({ status: 'open' }),
+    confidence: 'medium',
+  });
+  assert.deepEqual(withCreated, without);
+  assert.equal(withCreated.emit, true);
 });
 
 // ---------------------------------------------------------------------------
-// Fail-open discipline — every gap emits
+// Fail-open discipline elsewhere in the guard is unchanged
 // ---------------------------------------------------------------------------
 
-test('garbage-but-truthy sessionDate (dayAfter unparseable) → emits, never lexical suppression', () => {
-  // An epoch-as-string sliced to 10 chars is truthy and lexically below any
-  // ISO date — without the required-windowEnd conjunct it would suppress
-  // EVERY below-high candidate for the run (fail-closed inversion).
-  const guard = completionReviewEmitGuard('act:9999ffff', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    sessionDate: '1752000000',
+test('thrown lookup → emits (fail-open, the status re-check discipline)', () => {
+  const guard = completionReviewEmitGuard('act:ffff6666', {
+    statusStmt: { get: () => { throw new Error('database is locked'); } },
     confidence: 'medium',
   });
   assert.equal(guard.emit, true);
 });
 
-test('no sessionDate (unparseable transcript) → emits', () => {
+test('no confidence supplied → the inversion self-skips and the item emits', () => {
   const guard = completionReviewEmitGuard('act:dddd4444', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    sessionDate: null,
-    confidence: 'medium',
-  });
-  assert.equal(guard.emit, true);
-});
-
-test('row without a created value (schema gap) → emits', () => {
-  const guard = completionReviewEmitGuard('act:eeee5555', {
-    statusStmt: stmtReturning({ status: 'open' }),
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
-  });
-  assert.equal(guard.emit, true);
-});
-
-test('thrown lookup → emits (fail-open, matching the status re-check discipline)', () => {
-  const guard = completionReviewEmitGuard('act:ffff6666', {
-    statusStmt: { get: () => { throw new Error('database is locked'); } },
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
+    statusStmt: stmtReturning(OPEN),
+    existingItems: [],
   });
   assert.equal(guard.emit, true);
 });
 
 // ---------------------------------------------------------------------------
-// Guard ordering and the original signature stay intact
+// Guard ordering
 // ---------------------------------------------------------------------------
 
-test('status re-check wins first: a done action reports status, not creation', () => {
+test('status re-check wins first: a done action reports status, not confidence', () => {
   const guard = completionReviewEmitGuard('act:1111aaaa', {
-    statusStmt: stmtReturning({ status: 'done', created: '2026-07-10' }),
-    sessionDate: SESSION_DATE,
-    confidence: 'medium',
+    statusStmt: stmtReturning({ status: 'done' }),
+    confidence: 'high',
   });
   assert.equal(guard.emit, false);
   assert.match(guard.reason, /status now 'done'/);
 });
 
-test('per-fid dedup still runs after the filter passes', () => {
+test('per-fid dedup still runs after the confidence gate passes', () => {
   const guard = completionReviewEmitGuard('act:2222bbbb', {
-    statusStmt: stmtReturning(OPEN_CREATED_EARLIER),
-    sessionDate: SESSION_DATE,
+    statusStmt: stmtReturning(OPEN),
     confidence: 'medium',
     existingItems: [{ id: 'dec-x1', status: 'pending', plan_fid: 'act:2222bbbb' }],
   });
@@ -167,10 +156,83 @@ test('per-fid dedup still runs after the filter passes', () => {
   assert.match(guard.reason, /existing completion-review item dec-x1/);
 });
 
-test('original two-param shape is untouched (no sessionDate → filter self-skips)', () => {
-  const guard = completionReviewEmitGuard('act:3333cccc', {
-    statusStmt: stmtReturning(OPEN_CREATED_IN_SESSION),
-    existingItems: [],
-  });
-  assert.equal(guard.emit, true);
+// ---------------------------------------------------------------------------
+// Quote verification — INSTRUMENTATION, and it must stay that way
+// ---------------------------------------------------------------------------
+//
+// The haystack is built by calling the REAL preprocessTranscript, not by
+// hand-writing plain prose. That is the whole point: its output is one
+// JSON.stringify'd message per line, so a hand-written fixture would test a
+// string the production code never sees.
+
+let fixtureSeq = 0;
+function realHaystack(messages) {
+  // preprocessTranscript reads a Claude Code transcript FILE, so the fixture is
+  // written to disk in the nested `{ type, message: { role, content } }` shape
+  // it normalizes — no shortcut around the production code path.
+  const path = join(root, `transcript-${fixtureSeq++}.jsonl`);
+  writeFileSync(path, messages.map((m) => JSON.stringify({ type: m.role, message: m })).join('\n'));
+  // preprocessTranscript returns { compressed, originalTokenEstimate,
+  // compressedTokenEstimate } — the haystack is the `compressed` field, which
+  // is what Phase 2c slices and hands the model.
+  return preprocessTranscript(path).compressed;
+}
+
+test('a multi-line prose quote verifies against a real preprocessed transcript', () => {
+  // The case a naive substring test against the raw JSONL would REJECT: the
+  // real newline inside this message is the two characters \ and n once
+  // serialized, which survives whitespace normalization and breaks containment.
+  const haystack = realHaystack([
+    { role: 'assistant', content: 'Implemented the guard and pushed.\n\nAll 32 tests pass, nothing left here.' },
+  ]);
+  const check = verifyCompletionQuote(
+    'Implemented the guard and pushed. All 32 tests pass, nothing left here.', haystack);
+  assert.equal(check.verified, true, 'decoding must happen before matching');
+  assert.equal(check.reason, 'found');
+});
+
+test('a quote absent from the transcript does not verify', () => {
+  const haystack = realHaystack([{ role: 'assistant', content: 'Still working through the migration.' }]);
+  const check = verifyCompletionQuote('Shipped it, everything is green and merged to main.', haystack);
+  assert.equal(check.verified, false);
+  assert.equal(check.reason, 'not-found');
+});
+
+test('an empty or trivially short quote reports absent rather than matching', () => {
+  const haystack = realHaystack([{ role: 'assistant', content: 'done' }]);
+  for (const q of ['', null, undefined, 'done']) {
+    assert.equal(verifyCompletionQuote(q, haystack).reason, 'absent-or-too-short');
+  }
+});
+
+test('a serialized tool-use argument is NOT quotable evidence', () => {
+  // Every TodoWrite call leaves its input_summary in the haystack. That blob is
+  // the single most quotable false positive in the corpus, so decodeTranscriptText
+  // drops tool_use blocks — a model quoting one gets no credit.
+  const haystack = realHaystack([{
+    role: 'assistant',
+    content: [{
+      type: 'tool_use',
+      name: 'TodoWrite',
+      input: { todos: [{ content: 'Wire the guard into Phase 2c', status: 'completed' }] },
+    }],
+  }]);
+  const check = verifyCompletionQuote('Wire the guard into Phase 2c', haystack);
+  assert.equal(check.verified, false, 'tool arguments must not read as completion evidence');
+});
+
+test('the quote NEVER changes the emit decision', () => {
+  // The load-bearing assertion of this whole section: instrumentation only.
+  const base = { statusStmt: stmtReturning(OPEN), confidence: 'medium' };
+  const withoutQuote = completionReviewEmitGuard('act:5555eeee', base);
+  const withQuote = completionReviewEmitGuard('act:5555eeee', { ...base, quote: 'anything at all' });
+  assert.deepEqual(withoutQuote, withQuote);
+  assert.equal(withQuote.emit, true);
+});
+
+test('decodeTranscriptText skips unparseable lines instead of raw-matching them', () => {
+  const decoded = decodeTranscriptText('{"content":"kept"}\nnot json at all\n{"content":"also kept"}');
+  assert.match(decoded, /kept/);
+  assert.match(decoded, /also kept/);
+  assert.doesNotMatch(decoded, /not json at all/);
 });

package/templates/scripts/__tests__/roster-ambient-render.test.mjs

@@ -0,0 +1,132 @@
+// Roster measurements as ambient state (act:ea23b3a5) — the Ring 1 render half.
+//
+// Ring 2 measures weekly into state/roster-review.json; Ring 1 renders into the
+// per-project state file's Standing Issues, because Ring 1 owns that file. Same
+// division as the recall canary (ring1: "the canary is Ring 2's, the render is
+// Ring 1's").
+//
+// Two rules the render must hold, both learned the hard way:
+//   - the COUNT is true and the NAMES are what the operator can act on. The old
+//     queue item reported a saturated display cap — every project read exactly
+//     "12 dead", forever.
+//   - render ON CHANGE only. An unchanging number in a file read at every
+//     briefing is furniture by the third read; the queue item at least had a
+//     dismiss verb, and ambient state has none.
+//
+// Pure function, no I/O.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'roster-ambient-'));
+process.env.WATCHTOWER_DIR = root;
+mkdirSync(join(root, 'state'), { recursive: true });
+
+const { renderRosterEntries, assembleProjectState } = await import('../watchtower-ring1.mjs');
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+const MEASURED = '2026-07-21T10:00:00.000Z';
+
+test('a first measurement renders, with true counts and the skill names', () => {
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 14, stale_count: 11, dead: ['audit', 'retire-me', 'verify-learn'], stale: [], days: 30 },
+    previous: null,
+  });
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /dormant skills: 14 never invoked/);
+  assert.match(lines[0], /11 stale >30d/);
+  assert.match(lines[0], /audit, retire-me, verify-learn/, 'names are the actionable half');
+  assert.match(lines[0], /measured 2026-07-21/, 'as-of stamp — this is a weekly measurement, not live');
+});
+
+test('an UNCHANGED count renders nothing', () => {
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 12, stale_count: 4, dead: ['a'], stale: [], days: 30 },
+    previous: { dead_count: 12, stale_count: 4 },
+  });
+  assert.deepEqual(lines, [], 'a number that never moves never needs a human');
+});
+
+test('a CHANGED count renders and shows the movement', () => {
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 14, stale_count: 4, dead: ['a'], stale: [], days: 30 },
+    previous: { dead_count: 11, stale_count: 4 },
+  });
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /14 never invoked \(was 11\)/);
+});
+
+test('a change in only the stale count still renders', () => {
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 12, stale_count: 9, dead: ['a'], stale: [], days: 30 },
+    previous: { dead_count: 12, stale_count: 4 },
+  });
+  assert.equal(lines.length, 1);
+});
+
+test('zero dormant skills render nothing at all', () => {
+  assert.deepEqual(renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 0, stale_count: 0, dead: [], stale: [], days: 30 },
+    previous: null,
+  }), []);
+});
+
+test('the name list is capped but the count is not', () => {
+  const dead = Array.from({ length: 20 }, (_, i) => `skill-${i}`);
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    dormant: { dead_count: 20, stale_count: 0, dead, stale: [], days: 30 },
+    previous: null,
+  }, 3);
+  assert.match(lines[0], /dormant skills: 20 never invoked/, 'the count is true');
+  assert.match(lines[0], /skill-0, skill-1, skill-2, \+17 more/, 'the enumeration is bounded');
+});
+
+test('stale briefings render their own line with the oldest age', () => {
+  const lines = renderRosterEntries({
+    measured_at: MEASURED,
+    stale_briefings: [
+      { name: '_briefing-architecture.md', ageDaysBehind: 63 },
+      { name: '_briefing-cabinet.md', ageDaysBehind: 12 },
+    ],
+  });
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /stale cabinet briefings: 2, oldest ~63d behind/);
+});
+
+test('absent, empty, or malformed metrics render nothing rather than throwing', () => {
+  for (const input of [null, undefined, {}, 'nonsense', 42, { dormant: null }, { stale_briefings: [] }]) {
+    assert.deepEqual(renderRosterEntries(input), [], `input ${JSON.stringify(input)}`);
+  }
+});
+
+test('the lines reach Standing Issues in the assembled project state', () => {
+  const state = assembleProjectState({
+    name: 'proj', path: '/tmp/proj',
+    pib: { openActions: 3, flaggedCount: 0 },
+    roster: {
+      measured_at: MEASURED,
+      dormant: { dead_count: 14, stale_count: 2, dead: ['audit'], stale: [], days: 30 },
+      previous: { dead_count: 11, stale_count: 2 },
+    },
+  });
+  assert.match(state, /## Standing Issues/);
+  assert.match(state, /- dormant skills: 14 never invoked \(was 11\)/);
+});
+
+test('a project with no roster entry renders no roster lines', () => {
+  const state = assembleProjectState({
+    name: 'proj', path: '/tmp/proj', pib: { openActions: 0, flaggedCount: 0 }, roster: null,
+  });
+  assert.doesNotMatch(state, /dormant skills/);
+  assert.match(state, /## Standing Issues/);
+});