create-claude-cabinet 0.45.0 → 0.46.0

package/templates/scripts/__tests__/ring3-dedup.test.mjs

@@ -0,0 +1,387 @@
+// Ring 3 dedup lane (act:23eb5897, absorbing act:ce7d1700 + act:ec508dbe):
+// resolution-aware + thread-aware extraction dedup, and completion-review
+// emit guards.
+//
+//   1. listItems — the shared non-pending queue reader (filters, corrupt skip)
+//   2-4. isDuplicate corpora — resolved (3-token), dismissed (2-token,
+//        stricter), and the 90d recency cap via resolutionCorpus
+//   5-6. threadCursorLines — cursor prose corpus (v2 + legacy v1 schema),
+//        and suppression of a title restating a cursor via the prose pass
+//   7. completionReviewEmitGuard — emit-time pib.db status re-check
+//      (skip non-open/in-progress; FAIL-OPEN on a throwing statement)
+//   8. completionReviewEmitGuard — per-fid dedup vs pending and <=14d
+//      resolved/dismissed completion-review items
+//   9. Subprocess smoke — the entry guard didn't go dark: spawning the file
+//      directly still fires main() (precedent: qa-handoff-aging spawns ring2)
+//
+// Fixtures are hermetic: WATCHTOWER_DIR points at a temp dir and is set
+// BEFORE the dynamic imports (both the queue lib and ring3-close read it
+// into module consts at load) — a static import would target the LIVE inbox.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const RING3 = join(here, '..', 'watchtower-ring3-close.mjs');
+
+const root = mkdtempSync(join(tmpdir(), 'ring3-dedup-'));
+process.env.WATCHTOWER_DIR = root;
+mkdirSync(join(root, 'queue', 'items'), { recursive: true });
+mkdirSync(join(root, 'state', 'threads'), { recursive: true });
+
+const q = await import('../watchtower-queue.mjs');
+const lib = await import('../watchtower-lib.mjs');
+const r3 = await import('../watchtower-ring3-close.mjs');
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+const DAY = 24 * 60 * 60 * 1000;
+const itemFile = (id) => join(root, 'queue', 'items', `${id}.json`);
+const readBack = (id) => JSON.parse(readFileSync(itemFile(id), 'utf8'));
+
+function makeItem(overrides = {}) {
+  return q.createItem({
+    project: 'test-proj',
+    project_path: '/tmp/test-proj',
+    category: 'knowledge-extraction',
+    title: 'fixture item',
+    summary: 'fixture',
+    context_anchor: 'test',
+    ...overrides,
+  });
+}
+
+// Rewrite an item's timestamps in place (backdating fixtures).
+function backdate(id, { filedDays = null, resolvedDays = null }) {
+  const j = readBack(id);
+  if (filedDays != null) j.filed_at = new Date(Date.now() - filedDays * DAY).toISOString();
+  if (resolvedDays != null) j.resolved_at = new Date(Date.now() - resolvedDays * DAY).toISOString();
+  writeFileSync(itemFile(id), JSON.stringify(j, null, 2) + '\n');
+}
+
+function captureErrors(fn) {
+  const lines = [];
+  const orig = console.error;
+  console.error = (...args) => lines.push(args.join(' '));
+  try { fn(); } finally { console.error = orig; }
+  return lines;
+}
+
+// --- 1. listItems ---
+
+test('listItems returns all statuses, honors statuses/since/project/category filters, skips corrupt JSON', () => {
+  const pendingId = makeItem({ project: 'li-proj', title: 'pending one' });
+  const resolvedId = makeItem({ project: 'li-proj', title: 'resolved one' });
+  q.resolveItem(resolvedId, { resolution: 'done' });
+  const dismissedId = makeItem({ project: 'li-proj', title: 'dismissed one' });
+  q.dismissItem(dismissedId, { notes: 'noise' });
+  makeItem({ project: 'other-proj', title: 'other project item' });
+  makeItem({ project: 'li-proj', category: 'completion-review', title: 'cr item' });
+  writeFileSync(join(root, 'queue', 'items', 'corrupt.json'), '{not json at all');
+
+  const all = q.listItems({ project: 'li-proj' });
+  assert.equal(all.length, 4, 'all statuses for the project, corrupt file skipped');
+
+  const closed = q.listItems({ project: 'li-proj', statuses: ['resolved', 'dismissed'] });
+  assert.deepEqual(
+    closed.map(i => i.id).sort(),
+    [resolvedId, dismissedId].sort(),
+  );
+
+  const resolvedOnly = q.listItems({ project: 'li-proj', statuses: ['resolved'] });
+  assert.deepEqual(resolvedOnly.map(i => i.id), [resolvedId]);
+
+  const byCategory = q.listItems({ project: 'li-proj', category: 'completion-review' });
+  assert.equal(byCategory.length, 1);
+  assert.equal(byCategory[0].title, 'cr item');
+
+  // since: resolved_at || filed_at >= since
+  const past = new Date(Date.now() - DAY).toISOString();
+  const future = new Date(Date.now() + DAY).toISOString();
+  assert.equal(q.listItems({ project: 'li-proj', since: past }).length, 4);
+  assert.equal(q.listItems({ project: 'li-proj', since: future }).length, 0);
+
+  // pending items must never leak into a closed-statuses query
+  assert.ok(!closed.some(i => i.id === pendingId));
+});
+
+// --- 2. resolved corpus: 3-token threshold ---
+
+test('isDuplicate suppresses on 3-token overlap with a resolved title, not on 2', () => {
+  const title = 'watchtower dedup resolution corpus'; // 4 tokens
+  const threeShared = ['watchtower dedup resolution improvements'];
+  const twoShared = ['watchtower dedup improvements planned'];
+
+  const hit = r3.isDuplicate(title, '', [], [], { resolvedTitles: threeShared });
+  assert.ok(hit, 'three shared tokens suppress');
+  assert.equal(hit.corpus, 'resolved');
+  assert.equal(hit.match, threeShared[0]);
+
+  assert.equal(
+    r3.isDuplicate(title, '', [], [], { resolvedTitles: twoShared }),
+    false,
+    'two shared tokens do NOT suppress via the resolved corpus',
+  );
+});
+
+// --- 3. dismissed corpus: stricter 2-token threshold ---
+
+test('isDuplicate suppresses on 2-token overlap with a dismissed title (stricter path)', () => {
+  const title = 'watchtower dedup resolution corpus';
+  const twoShared = ['watchtower dedup planning notes'];
+
+  const hit = r3.isDuplicate(title, '', [], [], { dismissedTitles: twoShared });
+  assert.ok(hit, 'two shared tokens suppress when the user dismissed');
+  assert.equal(hit.corpus, 'dismissed');
+
+  // Backward compatibility: empty corpora = the pre-change behavior.
+  assert.equal(r3.isDuplicate(title, '', [], []), false);
+  assert.equal(r3.isDuplicate(title, '', [], [], {}), false);
+});
+
+// --- 4. 90d recency cap via resolutionCorpus ---
+
+test('a 91-day-old dismissal falls out of the resolution corpus; a recent one stays', () => {
+  const project = 'recency-proj';
+  // Token-disjoint titles: the aged-out probe must not accidentally overlap
+  // the recent dismissal (2 shared tokens would legitimately suppress it).
+  const oldId = makeItem({ project, title: 'ancient gadget calibration quirk' });
+  q.dismissItem(oldId, { notes: 'old noise' });
+  backdate(oldId, { filedDays: 92, resolvedDays: 91 });
+
+  const freshId = makeItem({ project, title: 'recent dismissed widget behavior' });
+  q.dismissItem(freshId, { notes: 'recent noise' });
+  backdate(freshId, { filedDays: 6, resolvedDays: 5 });
+
+  const resolvedId = makeItem({ project, title: 'fresh resolved decision capture' });
+  q.resolveItem(resolvedId, { resolution: 'routed to memory' });
+
+  const corpus = r3.resolutionCorpus(project);
+  assert.ok(!corpus.dismissedTitles.includes('ancient gadget calibration quirk'),
+    '91-day-old dismissal is outside the corpus');
+  assert.ok(corpus.dismissedTitles.includes('recent dismissed widget behavior'));
+  assert.ok(corpus.resolvedTitles.includes('fresh resolved decision capture'));
+  assert.ok(!corpus.resolvedTitles.includes('recent dismissed widget behavior'),
+    'dismissed titles are not double-counted as resolved');
+
+  // End-to-end: the aged-out dismissal no longer suppresses.
+  assert.equal(
+    r3.isDuplicate('lesson: ancient gadget calibration quirk', '', [], [], corpus),
+    false,
+  );
+  assert.ok(r3.isDuplicate('lesson: recent dismissed widget find', '', [], [], corpus));
+});
+
+// --- 5. threadCursorLines ---
+
+const threadsDir = join(root, 'state', 'threads');
+const projectSlug = 'dedupslugproj';
+
+test('threadCursorLines extracts cursor prose from v2 and legacy v1 threads, skipping non-matching and inactive ones', () => {
+  // v2 schema: cursor_history append-only, current = last entry.
+  writeFileSync(join(threadsDir, 'ring3-dedup.json'), JSON.stringify({
+    schema_version: 2,
+    thread: 'ring3-dedup',
+    display_name: 'Ring 3 Dedup Line',
+    status: 'active',
+    sessions: [{ id: 's1', project: projectSlug }],
+    cursor_history: [
+      { date: '2026-06-01', cursor: { what: 'stale earlier cursor framing' } },
+      {
+        date: '2026-06-10',
+        cursor: {
+          what: 'Building resolution corpus dedup',
+          where_left_off: 'Threshold constants named and wired',
+          open_questions: ['Should dismissed window shrink later'],
+        },
+      },
+    ],
+  }, null, 2));
+
+  // Legacy v1 schema: bare `cursor` field — currentCursor falls back to it.
+  writeFileSync(join(threadsDir, 'legacy-thread.json'), JSON.stringify({
+    schema_version: 1,
+    thread: 'legacy-thread',
+    display_name: 'Legacy Cursor Thread',
+    status: 'active',
+    sessions: [{ id: 's2', project: projectSlug }],
+    cursor: { what: 'legacy cursor what line', open_questions: ['legacy open question entry'] },
+  }, null, 2));
+
+  // Non-matching project — must be excluded.
+  writeFileSync(join(threadsDir, 'unrelated.json'), JSON.stringify({
+    schema_version: 2,
+    thread: 'unrelated-initiative',
+    display_name: 'Unrelated Initiative',
+    status: 'active',
+    sessions: [{ id: 's3', project: 'someoneelse' }],
+    cursor_history: [{ cursor: { what: 'unrelated project cursor text' } }],
+  }, null, 2));
+
+  // Dormant — must be excluded even with matching membership.
+  writeFileSync(join(threadsDir, 'dormant.json'), JSON.stringify({
+    schema_version: 2,
+    thread: 'dormant-line',
+    status: 'dormant',
+    sessions: [{ id: 's4', project: projectSlug }],
+    cursor_history: [{ cursor: { what: 'dormant thread cursor text' } }],
+  }, null, 2));
+
+  // Unparseable — must be skipped, not thrown.
+  writeFileSync(join(threadsDir, 'broken.json'), '{nope');
+
+  const lines = r3.threadCursorLines(threadsDir, projectSlug);
+  assert.ok(lines.includes('building resolution corpus dedup'));
+  assert.ok(lines.includes('threshold constants named and wired'));
+  assert.ok(lines.includes('should dismissed window shrink later'));
+  assert.ok(lines.includes('ring 3 dedup line'), 'display_name included');
+  assert.ok(lines.includes('legacy cursor what line'), 'legacy v1 cursor read');
+  assert.ok(lines.includes('legacy open question entry'));
+  assert.ok(!lines.includes('stale earlier cursor framing'),
+    'only the CURRENT cursor counts, not history');
+  assert.ok(!lines.some(l => l.includes('unrelated project cursor')));
+  assert.ok(!lines.some(l => l.includes('dormant thread cursor')));
+});
+
+// --- 6. cursor restatement suppressed via the prose (memoryLines) pass ---
+
+test('an extraction restating a cursor line is suppressed through the memory-lines pass', () => {
+  const lines = r3.threadCursorLines(threadsDir, projectSlug);
+  const hit = r3.isDuplicate(
+    'decision: threshold constants named wired', '', lines, []);
+  assert.ok(hit, 'restated cursor suppresses');
+  assert.equal(hit.corpus, 'memory');
+  assert.ok(hit.match.includes('threshold constants'));
+
+  assert.equal(
+    r3.isDuplicate('decision: completely orthogonal subject matter', '', lines, []),
+    false,
+    'unrelated extraction passes through',
+  );
+});
+
+// --- 7. emit guard: status re-check + fail-open ---
+
+test('completionReviewEmitGuard skips non-open statuses, passes open/in-progress, and FAILS OPEN on a throwing re-check', () => {
+  const Database = lib.loadBetterSqlite3(join(here, '..', '..', '..'));
+  assert.ok(Database, 'better-sqlite3 must resolve (repo dependency)');
+  const db = new Database(join(root, 'fixture-pib.db'));
+  db.exec('CREATE TABLE actions (fid TEXT PRIMARY KEY, text TEXT, status TEXT, deleted_at TEXT)');
+  const ins = db.prepare('INSERT INTO actions (fid, text, status, deleted_at) VALUES (?, ?, ?, ?)');
+  ins.run('act:open0001', 'x', 'open', null);
+  ins.run('act:prog0001', 'x', 'in-progress', null);
+  ins.run('act:done0001', 'x', 'done', null);
+  ins.run('act:defr0001', 'x', 'deferred', null);
+  ins.run('act:dele0001', 'x', 'open', '2026-01-01T00:00:00Z');
+  const statusStmt = db.prepare(
+    'SELECT status FROM actions WHERE fid = ? AND deleted_at IS NULL');
+
+  assert.deepEqual(r3.completionReviewEmitGuard('act:open0001', { statusStmt }), { emit: true });
+  assert.deepEqual(r3.completionReviewEmitGuard('act:prog0001', { statusStmt }), { emit: true });
+
+  const done = r3.completionReviewEmitGuard('act:done0001', { statusStmt });
+  assert.equal(done.emit, false);
+  assert.match(done.reason, /status now 'done'/);
+
+  const deferred = r3.completionReviewEmitGuard('act:defr0001', { statusStmt });
+  assert.equal(deferred.emit, false);
+  assert.match(deferred.reason, /status now 'deferred'/);
+
+  const deleted = r3.completionReviewEmitGuard('act:dele0001', { statusStmt });
+  assert.equal(deleted.emit, false, 'soft-deleted action does not emit');
+
+  // FAIL-OPEN: a throwing statement (e.g. lock contention) emits anyway,
+  // with a distinct logError — never silent wholesale suppression.
+  const throwing = { get() { throw new Error('database is locked'); } };
+  let out;
+  const errs = captureErrors(() => {
+    out = r3.completionReviewEmitGuard('act:open0001', { statusStmt: throwing });
+  });
+  assert.deepEqual(out, { emit: true }, 'throwing re-check fails OPEN');
+  assert.ok(errs.some(l => l.includes('failing open') && l.includes('act:open0001')),
+    `distinct logError fired (got: ${JSON.stringify(errs)})`);
+
+  db.close();
+});
+
+// --- 8. emit guard: per-fid dedup window ---
+
+test('per-fid dedup: pending suppresses; dismissed 3d ago suppresses; dismissed 20d ago does not', () => {
+  const project = 'cr-proj';
+  const mkCR = (plan_fid, evidence = {}) => makeItem({
+    project,
+    category: 'completion-review',
+    title: `Review completion of: ${plan_fid || evidence.fid}`,
+    plan_fid,
+    evidence,
+  });
+
+  mkCR('act:aaa11111'); // pending
+  const recentDismissed = mkCR('act:bbb22222');
+  q.dismissItem(recentDismissed, { notes: 'not done' });
+  backdate(recentDismissed, { filedDays: 4, resolvedDays: 3 });
+  const oldDismissed = mkCR('act:ccc33333');
+  q.dismissItem(oldDismissed, { notes: 'not done' });
+  backdate(oldDismissed, { filedDays: 21, resolvedDays: 20 });
+  mkCR(null, { fid: 'act:ddd44444' }); // pending, fid only in evidence
+
+  // Build existingItems exactly the way Phase 2c does: pending ∪
+  // resolved/dismissed within the 14-day window.
+  const since = new Date(Date.now() - 14 * DAY).toISOString();
+  const existingItems = [
+    ...q.listPending({ project, category: 'completion-review' }),
+    ...q.listItems({
+      project, category: 'completion-review',
+      statuses: ['resolved', 'dismissed'], since,
+    }),
+  ];
+
+  const pendingHit = r3.completionReviewEmitGuard('act:aaa11111', { existingItems });
+  assert.equal(pendingHit.emit, false, 'pending completion-review suppresses');
+  assert.match(pendingHit.reason, /existing completion-review item/);
+
+  assert.equal(
+    r3.completionReviewEmitGuard('act:bbb22222', { existingItems }).emit,
+    false, 'dismissed 3 days ago suppresses',
+  );
+  assert.equal(
+    r3.completionReviewEmitGuard('act:ccc33333', { existingItems }).emit,
+    true, 'dismissed 20 days ago does NOT suppress',
+  );
+  assert.equal(
+    r3.completionReviewEmitGuard('act:ddd44444', { existingItems }).emit,
+    false, 'evidence.fid matches too (legacy items without plan_fid)',
+  );
+  assert.equal(
+    r3.completionReviewEmitGuard('act:fff66666', { existingItems }).emit,
+    true, 'unknown fid emits',
+  );
+});
+
+// --- 9. subprocess smoke: the entry guard did not go dark ---
+
+test('spawning watchtower-ring3-close.mjs directly still fires main()', () => {
+  const env = { ...process.env, WATCHTOWER_DIR: root };
+  delete env.ANTHROPIC_API_KEY; // never reach a live API from the smoke
+
+  // No args: main() prints usage and exits 2 — output proves it ran.
+  const r1 = spawnSync(process.execPath, [RING3], { env, encoding: 'utf8', timeout: 30_000 });
+  assert.equal(r1.status, 2, `expected usage exit 2 (stderr: ${r1.stderr})`);
+  assert.match(r1.stderr, /Usage: watchtower-ring3-close\.mjs/);
+
+  // Garbage transcript: main() logs its startup line, then errors out.
+  const r2 = spawnSync(process.execPath, [
+    RING3,
+    '--session-id', 'ring3-dedup-smoke',
+    '--transcript', join(root, 'no-such-transcript.jsonl'),
+    '--cwd', root,
+  ], { env, encoding: 'utf8', timeout: 30_000 });
+  assert.equal(r2.status, 1, `expected transcript-missing exit 1 (stderr: ${r2.stderr})`);
+  assert.match(r2.stdout, /Starting Ring 3 close for session ring3-dedup-smoke/);
+  assert.match(r2.stderr, /Transcript not found/);
+});