create-claude-cabinet 0.52.0 → 0.53.0

package/templates/scripts/__tests__/memory-budget-debt.test.mjs

@@ -0,0 +1,264 @@
+// Memory-budget standing debt + validator-backed retraction (act:ea23b3a5).
+//
+// Two live defects, one pass:
+//   (a) the alarm re-filed as a fresh event every 7 days — the 2026-07-26
+//       triage found one maginnis budget violation restated three times across
+//       three categories;
+//   (b) it never retracted. Those alarms sat pending for days after MEMORY.md
+//       was fixed (verified 74 lines / 16.6 KB against a 200 / 25 KB budget),
+//       while Ring 2 slow was already running the validator that knew.
+//
+// Both halves now live in Ring 2 beside the verdict. Hermetic: every queue
+// dependency is injected, so no fixture queue and no subprocess.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'memory-budget-debt-'));
+process.env.WATCHTOWER_DIR = root;
+mkdirSync(join(root, 'queue', 'items'), { recursive: true });
+const stateDir = join(root, 'state');
+mkdirSync(stateDir, { recursive: true });
+
+const ring2 = await import('../watchtower-ring2.mjs');
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+// --- a tiny in-memory queue double, shaped like the real verbs -------------
+
+function makeQueue(seed = []) {
+  const items = [...seed];
+  let seq = 0;
+  return {
+    items,
+    listPending: ({ project, category }) => items.filter((i) =>
+      i.status === 'pending'
+      && (!project || i.project === project)
+      && (!category || i.category === category)),
+    // createItem returns the new item's id STRING, matching the real one.
+    createItem: (spec) => {
+      const id = `dec-new${seq++}`;
+      items.push({ ...spec, id, status: 'pending', filed_at: new Date().toISOString() });
+      return id;
+    },
+    annotateItemEvidence: (id, patch) => {
+      const item = items.find((i) => i.id === id);
+      if (!item || item.status !== 'pending') return null;
+      item.evidence = { ...(item.evidence || {}), ...patch };
+      return { item, changed: true };
+    },
+    supersedeItem: (id, { reason }) => {
+      const item = items.find((i) => i.id === id);
+      if (item) { item.status = 'superseded'; item.resolution_notes = reason; }
+      return item || null;
+    },
+  };
+}
+
+const VIOLATIONS = ['MEMORY.md is 293 lines (budget 200)', 'MEMORY.md is 43.6KB (budget 25KB)'];
+const violating = (project) => [{ project, violations: VIOLATIONS, status: 'violations' }];
+// Pre-seed the streak so the call under test is already at the
+// 3-consecutive-run gate (the gate itself is unchanged behaviour).
+function seedStreak(project, count) {
+  writeFileSync(join(stateDir, 'memory-violation-streaks.json'),
+    JSON.stringify({ [project]: { count, last_filed: null } }));
+}
+
+// ---------------------------------------------------------------------------
+// Aggregation
+// ---------------------------------------------------------------------------
+
+test('first violating run past the streak gate files exactly one item', () => {
+  const q = makeQueue();
+  seedStreak('proj-a', 2); // +1 this run = 3, the threshold
+  ring2.surfacePersistentViolations(violating('proj-a'), { 'proj-a': { path: '/tmp/a' } }, stateDir,
+    { ...q, today: '2026-07-26' });
+  assert.equal(q.items.length, 1);
+  const ev = q.items[0].evidence;
+  assert.equal(ev.debt_class, 'memory-budget');
+  assert.deepEqual(ev.days, ['2026-07-26']);
+  assert.equal(ev.session_count, 1);
+  assert.equal(ev.first_seen, '2026-07-26');
+  assert.deepEqual(ev.violations, VIOLATIONS);
+});
+
+test('a SECOND day APPENDS to the existing item — no second item', () => {
+  const q = makeQueue();
+  seedStreak('proj-b', 2);
+  ring2.surfacePersistentViolations(violating('proj-b'), {}, stateDir, { ...q, today: '2026-07-26' });
+  ring2.surfacePersistentViolations(violating('proj-b'), {}, stateDir, { ...q, today: '2026-07-27' });
+
+  assert.equal(q.items.filter((i) => i.status === 'pending').length, 1, 'still ONE pending item');
+  const ev = q.items[0].evidence;
+  assert.deepEqual(ev.days, ['2026-07-26', '2026-07-27']);
+  assert.equal(ev.session_count, 2, 'the spelling itemSessionWeight already reads');
+  assert.equal(ev.first_seen, '2026-07-26', 'first_seen holds the oldest occurrence');
+  assert.equal(ev.last_seen, '2026-07-27');
+});
+
+test('replay guard: a second run on the SAME day changes nothing', () => {
+  const q = makeQueue();
+  seedStreak('proj-c', 2);
+  ring2.surfacePersistentViolations(violating('proj-c'), {}, stateDir, { ...q, today: '2026-07-26' });
+  ring2.surfacePersistentViolations(violating('proj-c'), {}, stateDir, { ...q, today: '2026-07-26' });
+  ring2.surfacePersistentViolations(violating('proj-c'), {}, stateDir, { ...q, today: '2026-07-26' });
+  assert.equal(q.items.length, 1);
+  assert.deepEqual(q.items[0].evidence.days, ['2026-07-26']);
+  assert.equal(q.items[0].evidence.session_count, 1,
+    'Ring 2 slow runs ~48x/day — the day key is what keeps this from counting cron ticks');
+});
+
+test('a LEGACY item (no debt_class, evidence {violations, streak}) is found and appended to', () => {
+  // Every memory-budget item on disk when this shipped has this shape. A
+  // debt_class-only selector would silently miss the pile that motivated the fix.
+  const legacy = {
+    id: 'dec-legacy1', project: 'proj-d', category: 'watchtower-health', status: 'pending',
+    title: '[AGING] Memory budget violation: proj-d', filed_at: '2026-07-10T00:00:00Z',
+    evidence: { violations: ['old'], streak: 5 },
+  };
+  const q = makeQueue([legacy]);
+  seedStreak('proj-d', 2);
+  ring2.surfacePersistentViolations(violating('proj-d'), {}, stateDir, { ...q, today: '2026-07-26' });
+
+  assert.equal(q.items.filter((i) => i.status === 'pending').length, 1, 'no duplicate filed');
+  assert.equal(q.items[0].id, 'dec-legacy1');
+  assert.equal(q.items[0].evidence.debt_class, 'memory-budget', 'the legacy item is upgraded in place');
+});
+
+test('two pending items collapse: oldest accumulates, newer is superseded naming it', () => {
+  const older = {
+    id: 'dec-old', project: 'proj-e', category: 'watchtower-health', status: 'pending',
+    title: 'Memory budget violation: proj-e', filed_at: '2026-07-01T00:00:00Z', evidence: {},
+  };
+  const newer = {
+    id: 'dec-new', project: 'proj-e', category: 'watchtower-health', status: 'pending',
+    title: 'Memory budget violation: proj-e', filed_at: '2026-07-20T00:00:00Z', evidence: {},
+  };
+  const q = makeQueue([newer, older]); // deliberately out of order
+  seedStreak('proj-e', 2);
+  ring2.surfacePersistentViolations(violating('proj-e'), {}, stateDir, { ...q, today: '2026-07-26' });
+
+  assert.equal(q.items.find((i) => i.id === 'dec-old').status, 'pending');
+  assert.equal(q.items.find((i) => i.id === 'dec-new').status, 'superseded');
+  assert.match(q.items.find((i) => i.id === 'dec-new').resolution_notes, /dec-old/);
+});
+
+test('an unrelated watchtower-health item is never absorbed', () => {
+  const other = {
+    id: 'dec-other', project: 'proj-f', category: 'watchtower-health', status: 'pending',
+    title: 'Ring 3 has not run in 3 days', filed_at: '2026-07-01T00:00:00Z', evidence: {},
+  };
+  const q = makeQueue([other]);
+  seedStreak('proj-f', 2);
+  ring2.surfacePersistentViolations(violating('proj-f'), {}, stateDir, { ...q, today: '2026-07-26' });
+  assert.equal(q.items.find((i) => i.id === 'dec-other').status, 'pending',
+    'category alone must not decide absorption — that would eat a sibling detector');
+  assert.equal(q.items.filter((i) => i.status === 'pending').length, 2);
+});
+
+test('below the streak threshold nothing is filed at all', () => {
+  const q = makeQueue();
+  seedStreak('proj-g', 0);
+  ring2.surfacePersistentViolations(violating('proj-g'), {}, stateDir, { ...q, today: '2026-07-26' });
+  assert.equal(q.items.length, 0);
+});
+
+test('the selector matches both shapes and nothing else', () => {
+  assert.equal(ring2.isMemoryBudgetItem({
+    category: 'watchtower-health', evidence: { debt_class: 'memory-budget' } }), true);
+  assert.equal(ring2.isMemoryBudgetItem({
+    category: 'watchtower-health', title: 'Memory budget violation: x' }), true);
+  assert.equal(ring2.isMemoryBudgetItem({
+    category: 'watchtower-health', title: '[AGING] Memory budget violation: x' }), true,
+    'the [AGING] rewrite is exactly what broke the old startsWith check');
+  assert.equal(ring2.isMemoryBudgetItem({
+    category: 'watchtower-health', title: 'Ring 2 stalled' }), false);
+  assert.equal(ring2.isMemoryBudgetItem({
+    category: 'knowledge-extraction', evidence: { debt_class: 'memory-budget' } }), false);
+  assert.equal(ring2.isMemoryBudgetItem(null), false);
+});
+
+// ---------------------------------------------------------------------------
+// Retraction — fail toward KEEPING
+// ---------------------------------------------------------------------------
+
+function retractionQueue(items) {
+  const calls = [];
+  return {
+    calls,
+    listPending: ({ project, category }) => items.filter((i) =>
+      i.status === 'pending' && i.project === project && i.category === category),
+    autoReconcileItem: (id, opts) => { calls.push({ id, ...opts }); return { id }; },
+  };
+}
+
+const PENDING_ALARM = [{
+  id: 'dec-alarm', project: 'proj-x', category: 'watchtower-health', status: 'pending',
+  title: 'Memory budget violation: proj-x', filed_at: '2026-07-10T00:00:00Z',
+  evidence: { debt_class: 'memory-budget' },
+}];
+
+test('a passing project retracts its alarm as a machine act', () => {
+  const q = retractionQueue(PENDING_ALARM);
+  const n = ring2.retractClearedMemoryBudgetItems([{ project: 'proj-x', status: 'pass' }], q);
+  assert.equal(n, 1);
+  assert.equal(q.calls[0].id, 'dec-alarm');
+  assert.equal(q.calls[0].actor, 'ring2-slow', 'excluded from engagement buckets portfolio-wide');
+  assert.equal(q.calls[0].resolution, 'validator-passes');
+  assert.equal(q.calls[0].evidence.validator_status, 'pass');
+});
+
+test('a LEGACY-shaped alarm retracts too', () => {
+  const legacy = [{
+    id: 'dec-legacy2', project: 'proj-y', category: 'watchtower-health', status: 'pending',
+    title: '[AGING] Memory budget violation: proj-y', evidence: { violations: [], streak: 9 },
+  }];
+  const q = retractionQueue(legacy);
+  assert.equal(ring2.retractClearedMemoryBudgetItems([{ project: 'proj-y' }], q), 1,
+    'the three items that motivated this fix carry no debt_class');
+});
+
+test('violations, skipped, and an empty pass list retract nothing', () => {
+  for (const passList of [[], undefined, null]) {
+    const q = retractionQueue(PENDING_ALARM);
+    assert.equal(ring2.retractClearedMemoryBudgetItems(passList, q), 0);
+    assert.equal(q.calls.length, 0);
+  }
+});
+
+test('a throwing reconciler keeps the item — never a swallowed retraction', () => {
+  const q = {
+    listPending: () => PENDING_ALARM,
+    autoReconcileItem: () => { throw new Error('queue is locked'); },
+  };
+  assert.equal(ring2.retractClearedMemoryBudgetItems([{ project: 'proj-x' }], q), 0,
+    'fail toward KEEPING: an error is not evidence the condition cleared');
+});
+
+test('a race (item no longer pending) counts as not-retracted, not as an error', () => {
+  const q = { listPending: () => PENDING_ALARM, autoReconcileItem: () => null };
+  assert.equal(ring2.retractClearedMemoryBudgetItems([{ project: 'proj-x' }], q), 0);
+});
+
+test('the streak resets on a pass — the anti-oscillation floor', () => {
+  // Retract, then a violating run: the project must fail three consecutive
+  // runs again before anything refiles, so retract→refile cannot cycle every
+  // 30 minutes.
+  const q = makeQueue();
+  seedStreak('proj-z', 9);
+  ring2.surfacePersistentViolations([], {}, stateDir, { ...q, today: '2026-07-26' }); // now passing
+  const streaks = JSON.parse(readFileSync(join(stateDir, 'memory-violation-streaks.json'), 'utf8'));
+  assert.equal(streaks['proj-z'], undefined, 'streak cleared');
+
+  ring2.surfacePersistentViolations(violating('proj-z'), {}, stateDir, { ...q, today: '2026-07-27' });
+  assert.equal(q.items.length, 0, 'one violating run after a pass is not enough to refile');
+});
+
+test('the state file is always written, even with no violations', () => {
+  const q = makeQueue();
+  ring2.surfacePersistentViolations([], {}, stateDir, { ...q, today: '2026-07-26' });
+  assert.ok(existsSync(join(stateDir, 'memory-violation-streaks.json')));
+});

package/templates/scripts/__tests__/ring2-pattern-gate.test.mjs

@@ -0,0 +1,315 @@
+// Pattern-promotion emission-quality gate (act:09184ad7) — hermetic tests.
+//
+// Background: the 2026-07-26 consolidation of 144 pending pattern-promotion
+// items found 17 misfiled ledger/status fragments (wave tables, dependency
+// graphs, setup recipes, a raw transcript snippet) that ring2-slow had filed
+// as "patterns", plus 6 non-durable observations (no-gap positives,
+// truncated-transcript disclaimers). Three layers landed:
+//   1. patternHasRequiredShape — mechanical Evidence/Gap shape gate at the
+//      scanAuditPatterns filing site (calibrated: 120/120 legitimate bodies
+//      pass, 17/17 fragments fail).
+//   2. QUALITY_PATTERN_SYSTEM_PROMPT exclusions in Ring 3 Phase 2e — the
+//      classes that carry well-formed Evidence/Gap blocks and can only be
+//      filtered at generation time.
+//   3. runDraftAnnotationSweep pattern-promotion fold pass — near-duplicate
+//      variants arrive pre-annotated, grouped per target member.
+//
+// Hermetic per ring2-roster-review.test.mjs: WATCHTOWER_DIR points at a temp
+// dir set BEFORE the dynamic import; orchestrators are driven entirely
+// through injected deps — no Anthropic call, no real queue.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, utimesSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'ring2-pattern-gate-'));
+process.env.WATCHTOWER_DIR = root;
+
+const ring2 = await import('../watchtower-ring2.mjs');
+const {
+  patternHasRequiredShape,
+  parseAuditPatterns,
+  scanAuditPatterns,
+  runDraftAnnotationSweep,
+} = ring2;
+const { QUALITY_PATTERN_SYSTEM_PROMPT } = await import('../watchtower-ring3-close.mjs');
+
+// ---------------------------------------------------------------------------
+// Fixtures — representative of the five misfiled-fragment shapes dismissed in
+// the 2026-07-26 consolidation (dec-fd619cbf, dec-e965c928, dec-67a6a869,
+// dec-84eabbea, dec-67be0c26) and of legitimate pattern bodies.
+// ---------------------------------------------------------------------------
+
+const FRAGMENT_WAVE_TABLE = `| Wave | Actions | Status |
+|------|---------|--------|
+| 1 | 7 | DONE |
+| 2 | 12 | 10/12 done (2 remaining) |
+
+**Total:** 46 actions (17 done, 29 open)`;
+
+const FRAGMENT_DEP_GRAPH = `\`\`\`
+Wave 2 remaining:
+  act:862d8333 ---- independent
+  act:205551ba ---- independent (large)
+\`\`\``;
+
+const FRAGMENT_RECIPE = `1. Set action in-progress
+2. Build in worktree (docker-compose, no local Ruby)
+3. RSpec pre-check (\`bash -c\` wrapper)
+4. Merge to main`;
+
+const FRAGMENT_TRANSCRIPT = `- timelog.md: hours not yet logged (ask operator)
+</tool_response>
+
+<tool_call>
+{"name": "Bash", "input": {"command": "cat reviews/map.md"}}
+</tool_call>`;
+
+const FRAGMENT_FID_LIST = `- act:88fe16f4 — EmailTemplate key-vs-name
+- act:767ed43a — e-sign multi-campaign SigningEvent model`;
+
+const LEGIT_BODY = `**Evidence:** The assistant repeatedly makes concrete technical decisions
+before getting explicit approval, then presents them as fait accompli.
+
+**Gap:** The assistant conflates "I have a recommendation" with "I have a
+mandate." The session needed a cleaner checkpoint.`;
+
+// Carries well-formed blocks but is a transcript-artifact observation — the
+// shape gate deliberately PASSES it; the prompt exclusions own this class.
+const SESSION_SPECIFIC_BODY = `**Evidence:** The transcript cuts off mid-sentence — the session was still
+working when the record ended.
+
+**Gap:** Pattern analysis on a truncated transcript can only assess the
+portion observed.`;
+
+// ---------------------------------------------------------------------------
+// 1. The shape gate
+// ---------------------------------------------------------------------------
+
+test('patternHasRequiredShape: rejects every misfiled-fragment shape', () => {
+  for (const body of [
+    FRAGMENT_WAVE_TABLE, FRAGMENT_DEP_GRAPH, FRAGMENT_RECIPE,
+    FRAGMENT_TRANSCRIPT, FRAGMENT_FID_LIST,
+  ]) {
+    assert.equal(patternHasRequiredShape(body), false);
+  }
+});
+
+test('patternHasRequiredShape: accepts well-formed Evidence/Gap bodies', () => {
+  assert.equal(patternHasRequiredShape(LEGIT_BODY), true);
+  // The boundary is deliberate: well-formed session-specific observations
+  // pass the mechanical gate — the prompt exclusions are the layer for them.
+  assert.equal(patternHasRequiredShape(SESSION_SPECIFIC_BODY), true);
+});
+
+test('patternHasRequiredShape: requires BOTH blocks and a string body', () => {
+  assert.equal(patternHasRequiredShape('**Evidence:** something observed'), false);
+  assert.equal(patternHasRequiredShape('**Gap:** something missing'), false);
+  assert.equal(patternHasRequiredShape(''), false);
+  assert.equal(patternHasRequiredShape(undefined), false);
+  assert.equal(patternHasRequiredShape(null), false);
+});
+
+// ---------------------------------------------------------------------------
+// 2. Parse + gate integration over a realistic audit-patterns.md
+// ---------------------------------------------------------------------------
+
+const PATTERNS_MD = `# Quality Patterns
+
+### 2026-07-20
+
+## Unilateral Decisions Dressed as Consultation
+
+${LEGIT_BODY}
+
+---
+
+## Waves Overview
+
+${FRAGMENT_WAVE_TABLE}
+`;
+
+test('parseAuditPatterns + gate: only the well-formed section would file', () => {
+  const parsed = parseAuditPatterns(PATTERNS_MD);
+  assert.equal(parsed.length, 2);
+  const verdicts = parsed.map((p) => patternHasRequiredShape(p.body));
+  assert.deepEqual(verdicts, [true, false]);
+});
+
+// ---------------------------------------------------------------------------
+// 3. scanAuditPatterns — gate wired at the filing site
+// ---------------------------------------------------------------------------
+
+function makeScanFixture(name) {
+  const dir = join(root, name);
+  mkdirSync(join(dir, 'state'), { recursive: true });
+  writeFileSync(join(dir, 'state', 'audit-patterns.md'), PATTERNS_MD);
+  const member = {
+    name: 'process-therapist', description: 'skill ecosystem health',
+    project: 'alpha', project_path: '/tmp/alpha',
+  };
+  const calls = { routed: [], created: [] };
+  const deps = {
+    watchtowerDir: dir,
+    membersFn: () => [member],
+    routeFn: (pattern) => { calls.routed.push(pattern.title); return member; },
+    createItemFn: (payload) => { calls.created.push(payload); return 'dec-test0001'; },
+    listPendingFn: () => [],
+  };
+  return { dir, calls, deps };
+}
+
+test('scanAuditPatterns: files the well-formed pattern, rejects the fragment before routing', async () => {
+  const { dir, calls, deps } = makeScanFixture('scan-basic');
+  await scanAuditPatterns({ projects: {} }, deps);
+
+  // Only the legit section was routed and filed — the fragment never cost a
+  // routing call.
+  assert.deepEqual(calls.routed, ['Unilateral Decisions Dressed as Consultation']);
+  assert.equal(calls.created.length, 1);
+  assert.equal(calls.created[0].category, 'pattern-promotion');
+  assert.match(calls.created[0].title, /Unilateral Decisions/);
+
+  // Rejection is counted loudly in persisted state, and BOTH hashes are
+  // marked processed so the fragment is not retried every run.
+  const state = JSON.parse(readFileSync(join(dir, 'state', 'pattern-detection.json'), 'utf8'));
+  assert.equal(state.last_scan_rejected, 1);
+  assert.equal(state.rejected_malformed_total, 1);
+  assert.equal(state.processed_hashes.length, 2);
+});
+
+test('scanAuditPatterns: rejected fragments are not reprocessed; the total accumulates', async () => {
+  const { dir, calls, deps } = makeScanFixture('scan-accumulate');
+  await scanAuditPatterns({ projects: {} }, deps);
+  assert.equal(calls.created.length, 1);
+
+  // Unchanged file → mtime gate short-circuits, nothing new happens.
+  await scanAuditPatterns({ projects: {} }, deps);
+  assert.equal(calls.routed.length, 1);
+  assert.equal(calls.created.length, 1);
+
+  // A NEW malformed section arrives → rejected, total accumulates to 2,
+  // and the already-filed pattern is not re-filed.
+  const patternsPath = join(dir, 'state', 'audit-patterns.md');
+  writeFileSync(patternsPath, `${PATTERNS_MD}\n---\n\n## Gate Setup Recipe\n\n${FRAGMENT_RECIPE}\n`);
+  const future = new Date(Date.now() + 60_000);
+  utimesSync(patternsPath, future, future);
+  await scanAuditPatterns({ projects: {} }, deps);
+
+  assert.equal(calls.routed.length, 1);
+  assert.equal(calls.created.length, 1);
+  const state = JSON.parse(readFileSync(join(dir, 'state', 'pattern-detection.json'), 'utf8'));
+  assert.equal(state.last_scan_rejected, 1);
+  assert.equal(state.rejected_malformed_total, 2);
+  assert.equal(state.processed_hashes.length, 3);
+});
+
+// ---------------------------------------------------------------------------
+// 4. The Phase 2e prompt exclusions (guard against silent removal)
+// ---------------------------------------------------------------------------
+
+test('QUALITY_PATTERN_SYSTEM_PROMPT: names the format and all three exclusions', () => {
+  const p = QUALITY_PATTERN_SYSTEM_PROMPT;
+  // The mechanical half the shape gate depends on.
+  assert.ok(p.includes('**Evidence:**'));
+  assert.ok(p.includes('**Gap:**'));
+  assert.ok(p.includes('No recurring patterns detected'));
+  // The three prompt-only exclusions (act:09184ad7).
+  assert.match(p, /"no gap" observation is not a pattern/);
+  assert.match(p, /transcript artifact itself/);
+  assert.match(p, /not a document excerpt/);
+});
+
+// ---------------------------------------------------------------------------
+// 5. Pattern-promotion folds in the draft-annotation sweep
+// ---------------------------------------------------------------------------
+
+function patternItem(id, project, member, title) {
+  return {
+    id,
+    project,
+    category: 'pattern-promotion',
+    evidence: {
+      target_member: member,
+      pattern_title: title,
+      pattern_text: `**Evidence:** ${title} observed repeatedly.\n\n**Gap:** ${title} unaddressed.`,
+    },
+  };
+}
+
+test('runDraftAnnotationSweep: folds near-duplicate patterns within one member, never across members', () => {
+  const sweepDir = join(root, 'sweep');
+  mkdirSync(join(sweepDir, 'state'), { recursive: true });
+
+  // Two near-identical process-therapist variants (the live fold shape from
+  // the consolidation: "incomplete orientation before execution" filed
+  // twice), plus a THIRD item with the same title targeted at a DIFFERENT
+  // member — same lexical similarity, must not be treated as a duplicate.
+  const items = [
+    patternItem('dec-aaaa0001', 'alpha', 'process-therapist', 'Incomplete Orientation Before Execution'),
+    patternItem('dec-aaaa0002', 'alpha', 'process-therapist', 'Pattern 1: Incomplete Orientation Before Execution'),
+    patternItem('dec-aaaa0003', 'alpha', 'workflow-cop', 'Incomplete Orientation Before Execution'),
+  ];
+  const annotations = [];
+  const summary = runDraftAnnotationSweep(
+    { projects: { alpha: { path: '/tmp/alpha' } } },
+    {
+      watchtowerDir: sweepDir,
+      listPendingFn: ({ project, category } = {}) => {
+        if (category === 'pattern-promotion') {
+          return project ? items.filter((i) => i.project === project) : items;
+        }
+        return [];
+      },
+      annotateFn: (id, patch) => { annotations.push({ id, patch }); return { item: { id }, changed: true }; },
+    },
+  );
+
+  const annotatedIds = annotations.map((a) => a.id).sort();
+  assert.deepEqual(annotatedIds, ['dec-aaaa0001', 'dec-aaaa0002']);
+  const forFirst = annotations.find((a) => a.id === 'dec-aaaa0001');
+  assert.deepEqual(forFirst.patch.possible_duplicate_of, ['dec-aaaa0002']);
+
+  assert.equal(summary.pattern_items_scanned, 3);
+  assert.equal(summary.pattern_fold_annotated, 2);
+  assert.equal(summary.projects_scanned, 1);
+
+  // Positive-confirmation sidecar carries the new counters.
+  const sidecar = JSON.parse(readFileSync(join(sweepDir, 'state', 'draft-annotations-health.json'), 'utf8'));
+  assert.equal(sidecar.pattern_items_scanned, 3);
+  assert.equal(sidecar.pattern_fold_annotated, 2);
+});
+
+test('runDraftAnnotationSweep: patterns outside config are counted, never silently invisible', () => {
+  const sweepDir = join(root, 'sweep-unscanned');
+  mkdirSync(join(sweepDir, 'state'), { recursive: true });
+  const outside = patternItem('dec-bbbb0001', 'orphan-project', 'qa', 'Some Pattern Title Here');
+  const summary = runDraftAnnotationSweep(
+    { projects: { alpha: { path: '/tmp/alpha' } } },
+    {
+      watchtowerDir: sweepDir,
+      listPendingFn: ({ project, category } = {}) => {
+        if (category === 'pattern-promotion' && !project) return [outside];
+        return [];
+      },
+      annotateFn: () => { throw new Error('must not annotate anything'); },
+    },
+  );
+  assert.equal(summary.unscanned_pattern_items, 1);
+  assert.equal(summary.pattern_fold_annotated, 0);
+});
+
+test('runDraftAnnotationSweep: sidecar still written when there is nothing to sweep', () => {
+  const sweepDir = join(root, 'sweep-empty');
+  mkdirSync(join(sweepDir, 'state'), { recursive: true });
+  const summary = runDraftAnnotationSweep(
+    { projects: { alpha: { path: '/tmp/alpha' } } },
+    { watchtowerDir: sweepDir, listPendingFn: () => [], annotateFn: () => null },
+  );
+  assert.equal(summary.pattern_items_scanned, 0);
+  assert.ok(existsSync(join(sweepDir, 'state', 'draft-annotations-health.json')));
+});