create-claude-cabinet 0.52.0 → 0.53.0

package/templates/scripts/__tests__/category-expiry.test.mjs

@@ -0,0 +1,130 @@
+// Per-category expiry (act:ea23b3a5).
+//
+// Two engines expire queue items: Ring 2's `escalateQueueItems` (the 5-minute
+// cron) and `runExpiry` (called by /inbox and /briefing). Each used to hardcode
+// 30 days and inline its own qa-handoff carve-out, so a per-category policy set
+// in one would be silently violated by whichever engine reached an item first.
+// The table now lives in watchtower-queue and both delegate.
+//
+// The qa-handoff exemption is STRUCTURAL, not a preference: `expireItem` throws
+// on a qa-handoff by the recipient-gate contract, so expiryDaysFor returning
+// anything but null for it would crash the caller's loop.
+//
+// Hermetic: WATCHTOWER_DIR points at a temp dir before the dynamic import
+// (the house pattern), plus a read-only source scan for the wiring assertions.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const root = mkdtempSync(join(tmpdir(), 'category-expiry-'));
+process.env.WATCHTOWER_DIR = root;
+mkdirSync(join(root, 'queue', 'items'), { recursive: true });
+
+const q = await import('../watchtower-queue.mjs');
+const scriptsDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+// ---------------------------------------------------------------------------
+// The table
+// ---------------------------------------------------------------------------
+
+test('completion-review expires at 14 days, everything else at the 30-day default', () => {
+  assert.equal(q.expiryDaysFor('completion-review'), 14);
+  assert.equal(q.expiryDaysFor('knowledge-extraction'), 30);
+  assert.equal(q.expiryDaysFor('doc-drift'), 30);
+  assert.equal(q.expiryDaysFor('routine'), 30);
+  assert.equal(q.DEFAULT_EXPIRE_DAYS, 30);
+});
+
+test('qa-handoff never expires — null, because expireItem THROWS on it', () => {
+  assert.equal(q.expiryDaysFor('qa-handoff'), null);
+  assert.equal(q.categoryNeverExpires('qa-handoff'), true);
+  assert.equal(q.categoryNeverExpires('completion-review'), false);
+});
+
+test('an unknown category falls back to the default rather than never-expiring', () => {
+  // Fail direction: a category nobody registered should still age out, not
+  // accumulate forever behind a silent null.
+  assert.equal(q.expiryDaysFor('some-future-category'), 30);
+  assert.equal(q.expiryDaysFor(undefined), 30);
+});
+
+// ---------------------------------------------------------------------------
+// runExpiry honours the table
+// ---------------------------------------------------------------------------
+
+function writeItem({ id, category, ageDays }) {
+  const filed = new Date(Date.now() - ageDays * 24 * 60 * 60 * 1000).toISOString();
+  writeFileSync(join(root, 'queue', 'items', `${id}.json`), JSON.stringify({
+    schema_version: 1, id, project: 'p', project_path: '/tmp/p',
+    filed_at: filed, filed_by: 'test', status: 'pending',
+    category, urgency: 'normal', title: `t-${id}`, summary: 's',
+  }, null, 2) + '\n');
+}
+
+test('runExpiry expires a 20-day completion-review but not a 20-day knowledge-extraction', () => {
+  writeItem({ id: 'dec-cr20', category: 'completion-review', ageDays: 20 });
+  writeItem({ id: 'dec-ke20', category: 'knowledge-extraction', ageDays: 20 });
+  const { expired } = q.runExpiry();
+  const ids = expired.map((i) => i.id);
+  assert.ok(ids.includes('dec-cr20'), 'completion-review past 14d expires');
+  assert.ok(!ids.includes('dec-ke20'), 'knowledge-extraction at 20d is still inside its 30d policy');
+  assert.match(
+    expired.find((i) => i.id === 'dec-cr20').resolution_notes, /after 14 days/,
+    'the note states the policy that actually applied, not the default');
+});
+
+test('runExpiry never expires a qa-handoff, however old', () => {
+  writeItem({ id: 'dec-qa99', category: 'qa-handoff', ageDays: 99 });
+  const { expired, warned } = q.runExpiry();
+  assert.ok(!expired.some((i) => i.id === 'dec-qa99'));
+  assert.ok(warned.some((i) => i.id === 'dec-qa99'), 'it warns instead — QA debt stays surfaced');
+});
+
+// ---------------------------------------------------------------------------
+// Wiring — a correct table nobody calls is not a fix
+// ---------------------------------------------------------------------------
+//
+// Read-only source scan, the house precedent (detector-registry.test.mjs, the
+// suppression-ledger wiring assertion). `escalateQueueItems` is module-private
+// in ring2, so behaviour cannot be exercised directly from here.
+
+test('Ring 2 escalation delegates to expiryDaysFor and keeps no local expire constant', () => {
+  const src = readFileSync(join(scriptsDir, 'watchtower-ring2.mjs'), 'utf8');
+  assert.match(src, /expiryDaysFor/, 'ring2 must call the shared helper');
+  assert.match(src, /import \{[^}]*expiryDaysFor[^}]*\} from '\.\/watchtower-queue\.mjs'/s,
+    'and import it from the queue, not redefine it');
+  assert.doesNotMatch(src, /const ESCALATION_EXPIRE_DAYS\s*=/,
+    'a local expire constant is the divergence this consolidation removed');
+  assert.doesNotMatch(src, /item\.category !== 'qa-handoff'/,
+    'the inlined carve-out belongs to categoryNeverExpires now');
+});
+
+test('runExpiry consults the per-category table, not just its expireDays argument', () => {
+  const src = readFileSync(join(scriptsDir, 'watchtower-queue.mjs'), 'utf8');
+  const body = src.slice(src.indexOf('export function runExpiry'));
+  assert.match(body.slice(0, 1500), /CATEGORY_EXPIRE_DAYS/,
+    'the /inbox and /briefing engine must honour overrides too');
+  assert.match(body.slice(0, 1500), /categoryNeverExpires/);
+});
+
+// ---------------------------------------------------------------------------
+// The coupling that makes the 14-day policy safe
+// ---------------------------------------------------------------------------
+
+test('Phase 2c dedup includes expired and superseded — or 14d expiry is a refile loop', () => {
+  // COMPLETION_REVIEW_DEDUP_DAYS is also 14, so an item leaves the dedup window
+  // at exactly the moment it expires. Without these two statuses the fid is in
+  // no corpus at all and the next session refiles it — forever (Detector
+  // Symmetry §2). This assertion is the guard on that coupling.
+  const src = readFileSync(join(scriptsDir, 'watchtower-ring3-close.mjs'), 'utf8');
+  const at = src.indexOf("category: 'completion-review',\n        statuses:");
+  const window = at >= 0 ? src.slice(at, at + 400) : src;
+  assert.match(window, /statuses: \[[^\]]*'expired'[^\]]*\]/s);
+  assert.match(window, /statuses: \[[^\]]*'superseded'[^\]]*\]/s);
+});

package/templates/scripts/__tests__/detector-registry.test.mjs

@@ -24,10 +24,16 @@ const lib = await import('../watchtower-lib.mjs');
 
 const here = dirname(fileURLToPath(import.meta.url));
 const scriptsDir = resolve(here, '..');
+// act:ea23b3a5 added ring4 and the routine engine. They were ring-filing
+// categories (`doc-drift`, `routine`) the census could not see, so the
+// contract's claim to map "every ring-filed category" was false — flagged in
+// act:c2f06955 item 5 and closed here, because this program edits both files.
 const RING_SCRIPTS = [
   'watchtower-ring1.mjs',
   'watchtower-ring2.mjs',
   'watchtower-ring3-close.mjs',
+  'watchtower-ring4.mjs',
+  'watchtower-routines.mjs',
 ];
 
 // Call openers that can own a `category:` property, matched as
@@ -99,18 +105,46 @@ test('every filing-site category is a statically parseable string literal', () =
 });
 
 test('parser sanity: a real filing-site census, not a vacuous pass', () => {
-  // 2026-07-13 census: 2 ring1 + 8 ring2 + 9 ring3 filing sites across 16
-  // distinct categories. Floors, not exact counts — categories may be added
-  // (with registry entries) without touching this test.
-  assert.ok(totalFilingSites >= 15,
-    `expected ≥15 createItem filing sites across the rings, parsed ${totalFilingSites}`);
-  assert.ok(allFiling.size >= 16,
-    `expected ≥16 distinct filed categories, parsed ${allFiling.size}`);
+  // 2026-07-26 census (act:ea23b3a5, after ring4 + routines joined the scan):
+  // 27 filing sites across 20 distinct categories, 20 registry entries.
+  // The prior census was 2026-07-13: 19 sites / 16 categories over three
+  // scripts. Floors, not exact counts — categories may be added (with registry
+  // entries) without touching this test.
+  assert.ok(totalFilingSites >= 25,
+    `expected ≥25 createItem filing sites across the rings, parsed ${totalFilingSites}`);
+  assert.ok(allFiling.size >= 20,
+    `expected ≥20 distinct filed categories, parsed ${allFiling.size}`);
   // Read filters exist and were NOT counted as filings (the conflation guard):
   assert.ok(allReads.size >= 3,
     `expected the known listPending/listItems category filters to classify as reads, parsed ${allReads.size}`);
 });
 
+test('the two categories ring4 and routines file are registered — the gap act:c2f06955 named', () => {
+  // Before act:ea23b3a5 the census scanned only ring1/2/3, so these two shipped
+  // outside the registry entirely and the contract's "maps every ring-filed
+  // category" claim was false.
+  for (const cat of ['doc-drift', 'routine']) {
+    assert.ok(allFiling.has(cat), `${cat} must be visible to the census`);
+    assert.ok(cat in lib.INBOX_DETECTOR_REGISTRY, `${cat} must be registered`);
+  }
+});
+
+test('watchtower-health declares a reconciler now that memory-budget retracts', () => {
+  // It was exempt ("recovery is visible in the sidecars") while three
+  // memory-budget alarms sat pending for days after the condition cleared.
+  assert.ok(lib.INBOX_DETECTOR_REGISTRY['watchtower-health']?.reconciler);
+  assert.match(lib.INBOX_DETECTOR_REGISTRY['watchtower-health'].reconciler,
+    /retractClearedMemoryBudgetItems/);
+});
+
+test('completion-review records the confidence inversion, not the deleted filter', () => {
+  const entry = lib.INBOX_DETECTOR_REGISTRY['completion-review']?.reconciler || '';
+  assert.match(entry, /anti-predictive/,
+    'the registry must carry the measurement, or the next round re-derives the wrong theory');
+  assert.match(entry, /expired/i);
+  assert.match(entry, /superseded/i);
+});
+
 test('every ring-filed category is registered with a reconciler or an explicit exemption', () => {
   const unregistered = [...allFiling.keys()]
     .filter(cat => !(cat in lib.INBOX_DETECTOR_REGISTRY));

package/templates/scripts/__tests__/extraction-classification.test.mjs

@@ -18,6 +18,12 @@
 // C6: createItem's boundary check rejects an illegal type/home token, an
 //     unclassifiable item missing its reason, and a derivable:true item
 //     missing its derivation — mirroring the merge_state precedent.
+// C7 (act:a69c21f8): a PERISHABLE item — true at a moment, will become
+//     false, NOT recomputable (the plan's anticipated single-valued-but-
+//     not-derivable specimen) — is routed to home:'session-record', never
+//     memory, ALWAYS filed, with its perishes_when visible; derivable WINS
+//     when both flags are set; perishable:true without perishes_when is
+//     rejected at the boundary.
 //
 // Hermetic: WATCHTOWER_DIR points at a temp dir, set BEFORE the dynamic
 // imports. No live Anthropic calls — callFn is injected throughout.
@@ -78,6 +84,7 @@ test('C2: the prompt\'s JSON schema literal matches the exported four-axis vocab
     `prompt home schema must read exactly "${homesLiteral}"`);
   // The taxonomy is present in prose too — not just the trailing JSON literal.
   assert.ok(/DERIVABLE/.test(prompt));
+  assert.ok(/PERISHABLE/.test(prompt));
   assert.ok(/SUBJECT/.test(prompt));
   assert.ok(/UNCLASSIFIABLE/.test(prompt));
 });
@@ -216,4 +223,84 @@ test('C6e: KNOWLEDGE_EXTRACTION_TYPES/HOMES are exported consistently from both
   assert.deepEqual(q.KNOWLEDGE_EXTRACTION_HOMES, lib.KNOWLEDGE_EXTRACTION_HOMES);
   assert.ok(q.KNOWLEDGE_EXTRACTION_TYPES.includes('unclassifiable'));
   assert.ok(q.KNOWLEDGE_EXTRACTION_HOMES.includes('derivation'));
+  assert.ok(q.KNOWLEDGE_EXTRACTION_HOMES.includes('session-record'));
+});
+
+// --- C7 (act:a69c21f8): perishable facts — true now, false soon, not recomputable ---
+
+test('C7: a perishable ("phase 7 hasn\'t started yet") draft routes to session-record, never memory, never dropped', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([{
+    type: 'lesson', home: 'session-record', urgency: 'normal',
+    title: "phase 7 hasn't started yet",
+    content: 'As of this session, phase 7 of the ed-message rollout has not begun.',
+    perishable: true, perishes_when: 'the day phase 7 work starts',
+    subject: 'classify-proj', covered_by: 'none',
+  }]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-perishable', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 1, 'a perishable item is ALWAYS filed — never dropped');
+
+  const [item] = readItems();
+  assert.equal(item.evidence.home, 'session-record', 'routed to the session record, not memory');
+  assert.equal(item.evidence.perishable, true);
+  assert.equal(item.evidence.perishes_when, 'the day phase 7 work starts');
+  assert.equal(item.evidence.derivable, undefined, 'the derivable shape is absent — the two never mix');
+  assert.equal(item.draft_artifact, null, 'a perishable fact is never written as a memory draft');
+  assert.ok(item.summary.includes('Perishes:'), 'what makes it false is visible to the human');
+  assert.deepEqual(item.options.map((o) => o.key).sort(), ['acknowledge', 'dismiss']);
+});
+
+test('C7b: derivable WINS when both flags are set — the derivation is the better record', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([{
+    type: 'lesson', home: 'derivation', urgency: 'normal',
+    title: 'prod is at commit 35a5d15',
+    content: 'A deploy SHA is both recomputable and destined to change.',
+    derivable: true, derivation: 'check the deploy log or git log on the remote',
+    perishable: true, perishes_when: 'the next deploy',
+    subject: 'classify-proj', covered_by: 'none',
+  }]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-both-flags', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 1);
+  const [item] = readItems();
+  assert.equal(item.evidence.home, 'derivation');
+  assert.equal(item.evidence.derivable, true);
+  assert.equal(item.evidence.perishable, undefined, 'the perishable shape yields to derivable');
+  assert.equal(item.evidence.perishes_when, undefined);
+  assert.ok(item.summary.includes('Derivation:'));
+});
+
+test('C7c: a durable lesson carries neither flag — unaffected by the perishable path', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([{
+    type: 'lesson', home: 'memory', urgency: 'normal',
+    title: "git never reads a worktree's own info/exclude",
+    content: 'Git never consults a linked worktree\'s worktrees/<name>/info/exclude — per-worktree excludes need extensions.worktreeConfig plus a worktree-scoped core.excludesFile.',
+    subject: 'classify-proj', covered_by: 'none',
+  }]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-durable-2', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 1);
+  const [item] = readItems();
+  assert.equal(item.evidence.home, 'memory');
+  assert.equal(item.evidence.perishable, undefined);
+  assert.ok(item.draft_artifact, 'a durable lesson still gets its memory draft');
+});
+
+test('C7d: createItem rejects perishable:true without perishes_when', () => {
+  assert.throws(
+    () => q.createItem({
+      project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+      title: 'x', summary: 'x', context_anchor: 'x',
+      evidence: { type: 'lesson', home: 'session-record', perishable: true },
+    }),
+    /perishable:true requires evidence\.perishes_when/,
+  );
+  assert.throws(
+    () => q.createItem({
+      project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+      title: 'x', summary: 'x', context_anchor: 'x',
+      evidence: { type: 'lesson', home: 'session-record', perishable: true, perishes_when: '   ' },
+    }),
+    /perishable:true requires evidence\.perishes_when/,
+  );
 });

package/templates/scripts/__tests__/friction-actionability.test.mjs

@@ -0,0 +1,180 @@
+// Friction actionability gate (act:ea23b3a5) — Phase 2g's three arms.
+//
+// Five of the 2026-07-26 dismissals were friction reports with no party who
+// could act on them: "Claude made iterative browser tweaks without writing to
+// file", "Agent spawn interrupted by credit limit mid-task". True observations,
+// addressed to nobody, aging in the queue for weeks.
+//
+// The gate copies Phase 2f's shape exactly — that lens files a methodology
+// capture only when the claimed artifact verifiably exists on disk, after 11 of
+// 11 unverified captures were dismissed over three weeks.
+//
+// The THIRD arm comes from the data rather than from theory: of the five
+// friction items the operator KEPT, four exited as `captured-to-memory` —
+// platform constraints with a durable workaround. Those have no upstream route
+// and never will, so a two-arm gate would have thrown away the useful half of
+// this lens.
+//
+// Hermetic: real queue in a temp WATCHTOWER_DIR, injected Claude call.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'friction-gate-'));
+process.env.WATCHTOWER_DIR = root;
+mkdirSync(join(root, 'queue', 'items'), { recursive: true });
+
+const r3 = await import('../watchtower-ring3-close.mjs');
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+function listQueue() {
+  const dir = join(root, 'queue', 'items');
+  let names = [];
+  try { names = readdirSync(dir).filter((f) => f.endsWith('.json')); } catch { return []; }
+  return names.map((f) => JSON.parse(readFileSync(join(dir, f), 'utf8')));
+}
+function clearQueue() {
+  rmSync(join(root, 'queue'), { recursive: true, force: true });
+  mkdirSync(join(root, 'queue', 'items'), { recursive: true });
+}
+
+const PROJECT = { name: 'proj', path: '/tmp/proj' };
+const run = (findings) => r3.upstreamFriction('transcript', PROJECT, [], {
+  callFn: async () => JSON.stringify(findings),
+});
+
+// ---------------------------------------------------------------------------
+// The predicate
+// ---------------------------------------------------------------------------
+
+test('a route is actionable only with a known type AND a non-empty detail', () => {
+  assert.equal(r3.frictionRouteIsActionable({ type: 'cc-feedback', detail: 'fix the skill' }), true);
+  assert.equal(r3.frictionRouteIsActionable({ type: 'project-tracker', detail: 'file an action' }), true);
+  assert.equal(r3.frictionRouteIsActionable({ type: 'config-change', detail: 'set the hook' }), true);
+
+  assert.equal(r3.frictionRouteIsActionable({ type: 'cc-feedback', detail: '   ' }), false,
+    'an empty detail is a route in name only');
+  assert.equal(r3.frictionRouteIsActionable({ type: 'cc-feedback' }), false);
+  assert.equal(r3.frictionRouteIsActionable({ type: 'somewhere-else', detail: 'x' }), false,
+    'the vocabulary is CLOSED — an invented route must not become an escape hatch');
+  assert.equal(r3.frictionRouteIsActionable(null), false);
+  assert.equal(r3.frictionRouteIsActionable(undefined), false);
+});
+
+// ---------------------------------------------------------------------------
+// Arm 1 — a named route files upstream-friction, as before
+// ---------------------------------------------------------------------------
+
+test('a routed finding files upstream-friction and carries the route', async () => {
+  clearQueue();
+  await run([{
+    title: 'qa-handoff skill omits the merge sha',
+    description: 'The skill text never asks for merged_commit.',
+    severity: 'high',
+    route: { type: 'cc-feedback', detail: 'add merged_commit to the qa-handoff SKILL.md prompt' },
+  }]);
+
+  const items = listQueue();
+  assert.equal(items.length, 1);
+  assert.equal(items[0].category, 'upstream-friction');
+  assert.equal(items[0].urgency, 'urgent', 'severity high still escalates');
+  assert.equal(items[0].evidence.route.type, 'cc-feedback');
+  assert.match(items[0].summary, /Route: cc-feedback/,
+    'the operator can see who acts without opening the evidence');
+});
+
+// ---------------------------------------------------------------------------
+// Arm 2 — a durable constraint with no route becomes knowledge
+// ---------------------------------------------------------------------------
+
+test('a durable no-route constraint files knowledge-extraction, not upstream-friction', async () => {
+  clearQueue();
+  await run([{
+    title: 'Claude-in-Chrome cannot connect while Claude Desktop is running',
+    description: 'Quit Desktop first; the extension then attaches on the next navigate.',
+    severity: 'medium',
+    route: null,
+    durable: true,
+  }]);
+
+  const items = listQueue();
+  assert.equal(items.length, 1);
+  assert.equal(items[0].category, 'knowledge-extraction',
+    'four of the five KEPT friction items became memory — that arm must exist');
+  assert.equal(items[0].evidence.type, 'constraint');
+  assert.equal(items[0].evidence.home, 'memory');
+  assert.equal(items[0].evidence.source, 'friction-lens');
+});
+
+// ---------------------------------------------------------------------------
+// Arm 3 — neither routed nor durable files nothing
+// ---------------------------------------------------------------------------
+
+test('a transient or behavioral observation files NOTHING', async () => {
+  clearQueue();
+  await run([
+    { title: 'Agent spawn interrupted by credit limit mid-task', description: 'x', severity: 'low', route: null, durable: false },
+    { title: 'Claude made iterative browser tweaks without writing to file', description: 'y', severity: 'medium', route: null, durable: false },
+    { title: 'Edit tool failed with a string mismatch after live DOM changes', description: 'z', severity: 'low' },
+  ]);
+  assert.deepEqual(listQueue(), [], 'these three are real 2026-07-26 dismissals');
+});
+
+test('an invented route type is dropped, not filed', async () => {
+  clearQueue();
+  await run([{
+    title: 'something annoying', description: 'x', severity: 'low',
+    route: { type: 'someone-should-fix-this', detail: 'please' },
+  }]);
+  assert.deepEqual(listQueue(), []);
+});
+
+test('a route with an empty detail is dropped, not filed', async () => {
+  clearQueue();
+  await run([{
+    title: 'vague', description: 'x', severity: 'low',
+    route: { type: 'cc-feedback', detail: '' },
+  }]);
+  assert.deepEqual(listQueue(), []);
+});
+
+// ---------------------------------------------------------------------------
+// Mixed batches and the counting contract
+// ---------------------------------------------------------------------------
+
+test('a mixed batch routes each finding independently', async () => {
+  clearQueue();
+  await run([
+    { title: 'a', description: 'a', severity: 'low', route: { type: 'config-change', detail: 'flip the flag' } },
+    { title: 'b', description: 'b', severity: 'low', route: null, durable: true },
+    { title: 'c', description: 'c', severity: 'low', route: null, durable: false },
+  ]);
+  const byCategory = listQueue().reduce((acc, i) => {
+    acc[i.category] = (acc[i.category] || 0) + 1; return acc;
+  }, {});
+  assert.deepEqual(byCategory, { 'upstream-friction': 1, 'knowledge-extraction': 1 });
+});
+
+test('an empty finding list and a malformed reply both file nothing and do not throw', async () => {
+  clearQueue();
+  await run([]);
+  await r3.upstreamFriction('transcript', PROJECT, [], { callFn: async () => 'not json at all' });
+  await r3.upstreamFriction('transcript', PROJECT, [], { callFn: async () => { throw new Error('api down'); } });
+  assert.deepEqual(listQueue(), []);
+});
+
+test('the drop count is observable — silence must not look like a lens that never ran', async () => {
+  // The log line carries all three counts. Capturing stdout is brittle, so
+  // assert the wiring instead: the counting branch exists and names all three.
+  const src = readFileSync(new URL('../watchtower-ring3-close.mjs', import.meta.url), 'utf8');
+  const at = src.indexOf('Phase 2g: friction —');
+  assert.ok(at > 0, 'the summary log line must exist');
+  const line = src.slice(at, at + 220);
+  assert.match(line, /routed/);
+  assert.match(line, /durable/);
+  assert.match(line, /dropped/);
+});