create-claude-cabinet 0.51.0 → 0.52.0

package/templates/rules/memory-capture.md

@@ -17,12 +17,12 @@ write it to memory without asking whether to save it.
 `/cc-remember` ensures:
 - The new memory lands at `~/.claude/projects/<slug>/memory/<slug>.md`
 - `MEMORY.md` gets a new entry in the "Curated entries (hand-authored)"
-  section, so next session's `/orient` can find the memory
+  section, so the next session can find the memory
 - Filename collisions are handled (suffix with date if needed)
 - The write is atomic (temp + rename — safe under concurrent sessions)
 
 Direct flat-`.md` writes work but skip the indexing step. The memory
-becomes invisible to `/orient` until you manually update `MEMORY.md`.
+becomes invisible to the next session until you manually update `MEMORY.md`.
 The `memory-index-guard` PostToolUse hook will flag this when it
 happens, but it's better to avoid the issue: **use `/cc-remember`**.
 

package/templates/scripts/__tests__/absorption-no-prune.test.mjs

@@ -0,0 +1,89 @@
+// absorbThreadSessions (act:6f93a1f1, N4 of grp:retro-remeaning) — the
+// age-only session-record pruning gate (ABSORPTION_SESSION_AGE_DAYS = 90)
+// is RETIRED. Structural contract under test:
+// A1: an active thread's session record survives a slow-tier run, even when
+//     the session is far older than the old 90-day cutoff (the deleted
+//     constant no longer exists to prune it).
+// A2: dormant-marking is UNCHANGED — a thread untouched for 30+ days still
+//     flips to 'dormant'.
+// A3: the retired constant is gone from the module's exports/source.
+//
+// Hermetic per qa-handoff-gate.test.mjs: WATCHTOWER_DIR points at a temp dir,
+// set BEFORE the dynamic import. No Anthropic calls — absorbThreadSessions
+// touches only the filesystem.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'absorption-no-prune-'));
+process.env.WATCHTOWER_DIR = root;
+
+const ring2 = await import('../watchtower-ring2.mjs');
+const { absorbThreadSessions, DORMANT_THREAD_AGE_DAYS } = ring2;
+
+test.after(() => rmSync(root, { recursive: true, force: true }));
+
+function isoDaysAgo(days) {
+  return new Date(Date.now() - days * 86400000).toISOString();
+}
+
+test('A1: an active thread carrying a >90-day-old session record survives a slow-tier run', async () => {
+  const threadsDir = join(root, 'state', 'threads');
+  mkdirSync(threadsDir, { recursive: true });
+
+  const thread = {
+    schema_version: 2,
+    thread: 'fixture-thread',
+    display_name: 'Fixture thread',
+    cursor_history: [{ date: isoDaysAgo(2), session_id: 'sess-recent', cursor: { what: 'x', where_left_off: 'y', open_questions: [] } }],
+    // Fixture must pin active + recent last_updated, or this hits the
+    // dormant branch and the survival assertion is vacuous.
+    sessions: [{ id: 'sess-old', project: 'fixture-proj', date: isoDaysAgo(200) }],
+    related_fids: [],
+    last_updated: isoDaysAgo(2),
+    status: 'active',
+  };
+  writeFileSync(join(threadsDir, 'fixture-thread.json'), JSON.stringify(thread, null, 2));
+
+  const sessionsDir = join(root, 'state', 'projects', 'fixture-proj', 'sessions');
+  mkdirSync(sessionsDir, { recursive: true });
+  const sessionFilePath = join(sessionsDir, `${isoDaysAgo(200).slice(0, 10)}-sess-old.md`);
+  writeFileSync(sessionFilePath, '# Session sess-old\n\nDate: ' + isoDaysAgo(200) + '\n\n- did a thing\n');
+
+  await absorbThreadSessions();
+
+  assert.ok(existsSync(sessionFilePath), 'the 200-day-old session record must survive — age-only pruning is retired');
+  const stored = JSON.parse(readFileSync(join(threadsDir, 'fixture-thread.json'), 'utf8'));
+  assert.equal(stored.status, 'active', 'a recently-updated thread must stay active, not be pruned into dormant');
+});
+
+test('A2: dormant-marking is unchanged — a thread untouched 30+ days flips to dormant', async () => {
+  const threadsDir = join(root, 'state', 'threads');
+  mkdirSync(threadsDir, { recursive: true });
+
+  const thread = {
+    schema_version: 2,
+    thread: 'stale-thread',
+    display_name: 'Stale thread',
+    cursor_history: [],
+    sessions: [],
+    related_fids: [],
+    last_updated: isoDaysAgo(DORMANT_THREAD_AGE_DAYS + 5),
+    status: 'active',
+  };
+  writeFileSync(join(threadsDir, 'stale-thread.json'), JSON.stringify(thread, null, 2));
+
+  await absorbThreadSessions();
+
+  const stored = JSON.parse(readFileSync(join(threadsDir, 'stale-thread.json'), 'utf8'));
+  assert.equal(stored.status, 'dormant');
+});
+
+test('A3: the retired ABSORPTION_SESSION_AGE_DAYS constant is gone', () => {
+  assert.equal(ring2.ABSORPTION_SESSION_AGE_DAYS, undefined);
+  const src = readFileSync(new URL('../watchtower-ring2.mjs', import.meta.url), 'utf8');
+  assert.ok(!src.includes('ABSORPTION_SESSION_AGE_DAYS'));
+});

package/templates/scripts/__tests__/assessment-recalibration.test.mjs

@@ -373,9 +373,7 @@ test('R8: the draft-sweep sidecar has a reader — assessRingsAlive surfaces its
     last_run: daysAgo(2),
     projects_scanned: 3,
     items_scanned: 41,
-    freshness_annotated: 2,
     fold_annotated: 4,
-    skipped_projects: [],
     unscanned_items: 0,
     errors: 0,
   }));

package/templates/scripts/__tests__/batch-disposition.test.mjs

@@ -213,22 +213,20 @@ test('S8: partitionForBatchSignoff tolerates non-array input', () => {
 });
 
 test('S8b: surfacing annotations demote to individual — by semantic value, never field presence', () => {
-  // An overtaken draft (cites since-closed work) is not a clean sign-off.
-  assert.equal(q.isHighConfidenceSignoff(signoffItem({
-    evidence: { freshness: { overtaken: true, cited: [{ fid: 'act:12345678', closed_at: '2026-07-10' }] } },
-  })), false);
   // A fold candidate wants the human to review the pair together.
   assert.equal(q.isHighConfidenceSignoff(signoffItem({
     evidence: { possible_duplicate_of: ['dec-aaaa1111'] },
   })), false);
-  // Presence alone must NOT demote: a benign "checked, still fresh" stamp or
-  // an empty fold list keeps the item batch-eligible.
-  assert.equal(q.isHighConfidenceSignoff(signoffItem({
-    evidence: { freshness: { overtaken: false, cited: [] } },
-  })), true);
+  // Presence alone must NOT demote: an empty fold list keeps the item
+  // batch-eligible. (The sibling freshness/overtaken demotion was RETIRED —
+  // act:471dd701, N2 of grp:retro-remeaning — see draft-surfacing.test.mjs.)
   assert.equal(q.isHighConfidenceSignoff(signoffItem({
     evidence: { possible_duplicate_of: [] },
   })), true);
+  // A held item (holdItem) is deliberate retention, not a batch nod.
+  assert.equal(q.isHighConfidenceSignoff(signoffItem({
+    evidence: { held: { reason: 'specimen', held_at: '2026-07-20T00:00:00.000Z' } },
+  })), false);
 });
 
 test('S9: the batch set feeds applyBatch cleanly — real queued sign-off items resolve in one call', () => {

package/templates/scripts/__tests__/draft-surfacing.test.mjs

@@ -1,19 +1,13 @@
-// Draft surfacing intelligence — freshness + fold proposals (act:00051dca,
-// Lane C of grp:wt-noise-immunity).
+// Draft surfacing intelligence — fold proposals (act:00051dca, Lane C of
+// grp:wt-noise-immunity).
 //
 // Contract under test:
-//   F1: the fold recipe (unigram Jaccard >= FOLD_SIMILARITY_THRESHOLD over
-//       stopworded alphanumeric-run tokens of title+draft) surfaces EXACTLY
-//       the 2026-07-12 live fold candidates and nothing else.
+//   F1: the fold recipe (overlap coefficient >= FOLD_SIMILARITY_THRESHOLD,
+//       dual-scored over title-alone AND title+draft, stopworded
+//       alphanumeric-run tokens) surfaces EXACTLY the live fold candidates
+//       and nothing else.
 //   F2: the Ring 2 sweep annotates every surfaced pair RECIPROCALLY (the
 //       self-validating criterion) and never auto-dismisses anything.
-//   F3: freshness — a pending draft citing an action that is CLOSED in the
-//       item's project pib-db gets evidence.freshness {overtaken, cited} and
-//       is excluded from the high-confidence sign-off batch. The done
-//       predicate covers both close paths (completed=1 and the ungated
-//       status='done'). Tri-state discipline: fid-not-found, open action,
-//       soft-deleted action, and missing/unreadable db all mean UNKNOWN —
-//       no annotation, the draft stays batch-eligible.
 //   F4: annotateItemEvidence write discipline — pending fence checked at
 //       WRITE time (a sweep can never resurrect a resolved item), deep-equal
 //       values skip the write (idempotent re-sweeps), schema_version rides
@@ -22,16 +16,34 @@
 //   F5: the sweep writes its positive-confirmation sidecar — "ran with zero
 //       annotations" is distinguishable from "never ran".
 //
+// The sibling F3 freshness suite (a draft citing a since-closed act: fid,
+// demoted as "possibly overtaken") was RETIRED alongside the feature
+// (act:471dd701, N2 of grp:retro-remeaning) — measured against the
+// 2026-07-14 read-pass answer key, it fired on 62-of-66 TRUE drafts and
+// 70-of-84 flags were false by construction. extractCitedActFids (its sole
+// caller) was deleted with it.
+//
 // FIXTURE PROVENANCE: the five draft texts below are sanitized copies of the
 // live resolved items the 2026-07-12 full inbox read surfaced as real fold
 // candidates — the Boolean#cast trio (dec-5f850429 / dec-b2dc5070 /
 // dec-f3446e84) and the testimonials pair (dec-eb6dcdb4 / dec-dd944a5b).
 // Sanitization is a 1:1 token rename (the client name → "Acme"), which
-// preserves unigram-Jaccard values EXACTLY, verified against the live items
-// at authoring time: 5f8↔b2d 0.246, 5f8↔f34 0.311, b2d↔f34 0.218 (below
-// threshold — the trio connects through its hub), eb6↔dd9 0.600, all
-// cross-topic pairs ≤ 0.02. Verbatim drafts are deliberately NOT committed:
-// templates/scripts/__tests__/ ships in the public npm tarball.
+// preserves similarity values EXACTLY under any token-overlap metric.
+//
+// unigram-Jaccard values (act:00051dca calibration): 5f8↔b2d 0.246,
+// 5f8↔f34 0.311, b2d↔f34 0.218 (below the 0.22 threshold — the trio
+// connected only through its hub), eb6↔dd9 0.600, all cross-topic pairs
+// ≤0.02.
+//
+// overlap-coefficient values, dual-scored (act:421a8ab2, N5 of
+// grp:retro-remeaning — computed at authoring time over these exact fixture
+// strings): 5f8↔b2d title 0.333 / combined 0.483, 5f8↔f34 title 0.636 /
+// combined 0.500, b2d↔f34 title 0.455 / combined 0.414 (BOTH now above
+// threshold — the trio is a fully connected triangle, not hub-only; this is
+// the intended effect of the fix, not a regression), eb6↔dd9 title 0.600 /
+// combined 0.857, all cross-topic pairs ≤0.048 (the noise ceiling holds
+// under the new metric too). Verbatim drafts are deliberately NOT
+// committed: templates/scripts/__tests__/ ships in the public npm tarball.
 //
 // Hermetic: WATCHTOWER_DIR points at a temp dir set BEFORE the dynamic
 // imports (the queue lib reads it into a module const at load).
@@ -43,9 +55,6 @@ import {
 } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
 
 const root = mkdtempSync(join(tmpdir(), 'draft-surfacing-'));
 process.env.WATCHTOWER_DIR = root;
@@ -127,20 +136,25 @@ function readStored(id) {
 
 // --- F1: the fold recipe surfaces exactly the live pairs ---------------------
 
-test('F1: proposeFolds surfaces exactly the 2026-07-12 pairs — trio hub links + testimonials pair', () => {
+test('F1: proposeFolds surfaces the FULL trio triangle (not just the hub) plus the testimonials pair', () => {
   const items = FIXTURES.map((f) => ({ id: f.ref, title: f.title, draft_artifact: f.draft }));
   const pairs = q.proposeFolds(items);
   const keys = pairs.map((p) => [p.a, p.b].sort().join('|')).sort();
+  // Under Jaccard (act:00051dca), b2d↔f34 sat just under threshold (0.218)
+  // and the trio connected only through its hub. The overlap-coefficient +
+  // dual-scoring fix (act:421a8ab2) surfaces it too — a fully connected
+  // triangle, the fix's intended effect, not a regression.
   assert.deepEqual(keys, [
     'dec-5f850429|dec-b2dc5070',
     'dec-5f850429|dec-f3446e84',
+    'dec-b2dc5070|dec-f3446e84',
     'dec-dd944a5b|dec-eb6dcdb4',
   ]);
   for (const p of pairs) assert.ok(p.similarity >= q.FOLD_SIMILARITY_THRESHOLD);
-  // Below-threshold direction: the b2d↔f34 wording sits just under the line
-  // (0.218) and cross-topic pairs are noise-level — none of them surface.
-  assert.ok(!keys.includes('dec-b2dc5070|dec-f3446e84'));
+  // Cross-topic pairs stay below threshold under the new metric too (noise
+  // ceiling ≤0.048 — see the fixture-provenance header for the full table).
   assert.ok(!keys.some((k) => k.includes('dec-eb6dcdb4') && k.includes('dec-5f850429')));
+  assert.ok(!keys.some((k) => k.includes('dec-dd944a5b') && k.includes('dec-b2dc5070')));
 });
 
 test('F1b: short-text floor and empty inputs never propose folds (no NaN, no boilerplate match)', () => {
@@ -169,11 +183,12 @@ test('F2: sweep annotates every surfaced pair reciprocally; nothing is dismissed
     { watchtowerDir: root },
   );
 
-  // All five ride the fold graph: the trio through its hub, the pair directly.
+  // All five ride the fold graph: the trio is now a fully connected triangle
+  // (act:421a8ab2), the pair directly.
   const expectPartners = {
     [ids[TRIO_A.ref]]: [ids[TRIO_B.ref], ids[TRIO_C.ref]].sort(),
-    [ids[TRIO_B.ref]]: [ids[TRIO_A.ref]],
-    [ids[TRIO_C.ref]]: [ids[TRIO_A.ref]],
+    [ids[TRIO_B.ref]]: [ids[TRIO_A.ref], ids[TRIO_C.ref]].sort(),
+    [ids[TRIO_C.ref]]: [ids[TRIO_A.ref], ids[TRIO_B.ref]].sort(),
     [ids[PAIR_A.ref]]: [ids[PAIR_B.ref]],
     [ids[PAIR_B.ref]]: [ids[PAIR_A.ref]],
   };
@@ -189,9 +204,6 @@ test('F2: sweep annotates every surfaced pair reciprocally; nothing is dismissed
     }
   }
   assert.equal(summary.fold_annotated, 5);
-  // No pib-db for this project — freshness skipped LOUDLY, not silently.
-  assert.deepEqual(summary.skipped_projects, [project]);
-  assert.equal(summary.freshness_annotated, 0);
 
   // Fold-annotated items are excluded from the sign-off batch.
   const { signoff, individual } = q.partitionForBatchSignoff(
@@ -216,138 +228,10 @@ test('F2b: a second sweep over already-annotated items performs zero writes (ide
   }
 });
 
-// --- F3: freshness against a fixture pib-db ----------------------------------
-
-function makeProjectDb(dir, { withDeletedAt = true } = {}) {
-  mkdirSync(dir, { recursive: true });
-  const Database = require('better-sqlite3');
-  const db = new Database(join(dir, 'pib.db'));
-  db.exec(`CREATE TABLE actions (
-    fid TEXT PRIMARY KEY, text TEXT, status TEXT DEFAULT 'open',
-    completed INTEGER DEFAULT 0, completed_at TEXT${withDeletedAt ? ', deleted_at TEXT' : ''}
-  )`);
-  return db;
-}
-
-const openFixtureDb = (projectPath) => {
-  const Database = require('better-sqlite3');
-  const p = join(projectPath, 'pib.db');
-  if (!existsSync(p)) return null;
-  return new Database(p, { readonly: true });
-};
-
-test('F3: a draft citing a since-closed action is annotated and leaves the sign-off batch', () => {
-  const project = 'fresh-proj';
-  const projDir = join(root, 'projects', project);
-  const db = makeProjectDb(projDir);
-  db.prepare("INSERT INTO actions (fid, status, completed, completed_at) VALUES ('act:11112222', 'done', 1, '2026-07-10')").run();
-  db.prepare("INSERT INTO actions (fid, status, completed) VALUES ('act:33334444', 'open', 0)").run();
-  db.close();
-
-  const overtaken = queueDraft(project, {
-    title: 'lesson: the cross-ring reader still exits nonzero on an empty portfolio',
-    draft: 'The reader exits 1 when config has no projects — tracked as act:11112222; workaround is a guard in the caller until that action lands.',
-  }, { project_path: projDir });
-  const freshOpen = queueDraft(project, {
-    title: 'lesson: keep the parity test binding when adding join keys',
-    draft: 'Join keys must stay parity-tested against the resolver — see act:33334444 for the open follow-up work.',
-  }, { project_path: projDir });
-  const noCitations = queueDraft(project, {
-    title: 'lesson: plain drafts with no citations ride the batch untouched',
-    draft: 'A lesson body citing no work items at all.',
-  }, { project_path: projDir });
-  const unknownFid = queueDraft(project, {
-    title: 'lesson: a citation the db has never heard of stays unknown',
-    draft: 'References act:99990000 which exists in no actions table anywhere.',
-  }, { project_path: projDir });
-
-  const summary = r2.runDraftAnnotationSweep(
-    { projects: { [project]: { path: projDir } } },
-    { watchtowerDir: root, openDb: openFixtureDb },
-  );
-  assert.equal(summary.freshness_annotated, 1);
-  assert.deepEqual(summary.skipped_projects, []);
-
-  const stored = readStored(overtaken);
-  assert.equal(stored.status, 'pending', 'never auto-dismissed');
-  assert.deepEqual(stored.evidence.freshness, {
-    overtaken: true,
-    cited: [{ fid: 'act:11112222', closed_at: '2026-07-10' }],
-  });
-  // Tri-state: open action, no citations, unknown fid ⇒ NO annotation.
-  for (const id of [freshOpen, noCitations, unknownFid]) {
-    assert.equal(readStored(id).evidence.freshness, undefined, `no annotation on ${id}`);
-  }
-
-  const { signoff, individual } = q.partitionForBatchSignoff(q.listPending({ project }));
-  assert.ok(individual.some((i) => i.id === overtaken), 'overtaken draft demoted to individual');
-  assert.deepEqual(signoff.map((i) => i.id).sort(), [freshOpen, noCitations, unknownFid].sort(),
-    'unannotated drafts stay batch-eligible');
-});
-
-test('F3b: the ungated close path (status=done, completed=0) still reads as closed', () => {
-  const project = 'ungated-proj';
-  const projDir = join(root, 'projects', project);
-  const db = makeProjectDb(projDir);
-  db.prepare("INSERT INTO actions (fid, status, completed) VALUES ('act:55556666', 'done', 0)").run();
-  db.close();
-  const id = queueDraft(project, {
-    title: 'lesson: cites work closed through the ungated status flip',
-    draft: 'That behavior changed under act:55556666 and this draft may be overtaken by it.',
-  }, { project_path: projDir });
-  r2.runDraftAnnotationSweep(
-    { projects: { [project]: { path: projDir } } },
-    { watchtowerDir: root, openDb: openFixtureDb },
-  );
-  const fresh = readStored(id).evidence.freshness;
-  assert.equal(fresh.overtaken, true);
-  assert.deepEqual(fresh.cited, [{ fid: 'act:55556666', closed_at: null }]);
-});
-
-test('F3c: a soft-deleted action is unknown, not closed; an old schema without deleted_at still works', () => {
-  // deleted_at set ⇒ no annotation.
-  const pA = 'deleted-proj';
-  const dirA = join(root, 'projects', pA);
-  const dbA = makeProjectDb(dirA);
-  dbA.prepare("INSERT INTO actions (fid, status, completed, completed_at, deleted_at) VALUES ('act:77778888', 'done', 1, '2026-07-01', '2026-07-02')").run();
-  dbA.close();
-  const idA = queueDraft(pA, {
-    title: 'lesson: cites a soft-deleted action',
-    draft: 'Cites act:77778888 which was closed and then deleted.',
-  }, { project_path: dirA });
-
-  // Older consumer schema without the deleted_at column ⇒ fallback query runs.
-  const pB = 'oldschema-proj';
-  const dirB = join(root, 'projects', pB);
-  const dbB = makeProjectDb(dirB, { withDeletedAt: false });
-  dbB.prepare("INSERT INTO actions (fid, status, completed, completed_at) VALUES ('act:aaaa1111', 'done', 1, '2026-06-30')").run();
-  dbB.close();
-  const idB = queueDraft(pB, {
-    title: 'lesson: cites closed work in an old-schema db',
-    draft: 'Cites act:aaaa1111 living in a db predating soft deletion.',
-  }, { project_path: dirB });
-
-  const summary = r2.runDraftAnnotationSweep(
-    { projects: { [pA]: { path: dirA }, [pB]: { path: dirB } } },
-    { watchtowerDir: root, openDb: openFixtureDb },
-  );
-  assert.equal(readStored(idA).evidence.freshness, undefined, 'soft-deleted ⇒ unknown');
-  assert.equal(readStored(idB).evidence.freshness.overtaken, true, 'old schema ⇒ fallback query');
-  assert.equal(summary.freshness_annotated, 1);
-});
-
-test('F3d: extractCitedActFids — unique, ordered, capped, shape-validated', () => {
-  assert.deepEqual(q.extractCitedActFids('see act:12345678 and act:12345678 then act:90abcdef'),
-    ['act:12345678', 'act:90abcdef']);
-  // Malformed fids never match: non-hex, too short, and too long (\b after
-  // {8} rejects a 9th hex char) all yield nothing — the regex IS the shape
-  // validation for everything that later reaches a SQL parameter.
-  assert.deepEqual(q.extractCitedActFids('act:XYZ act:1234 act:123456789 react:12345678'), []);
-  assert.deepEqual(q.extractCitedActFids(''), []);
-  assert.deepEqual(q.extractCitedActFids(null), []);
-  const many = Array.from({ length: 80 }, (_, i) => `act:${String(10000000 + i)}`).join(' ');
-  assert.equal(q.extractCitedActFids(many).length, 50, 'capped at 50 per draft');
-});
+// F3 (freshness against a fixture pib-db) and F3d (extractCitedActFids) were
+// RETIRED alongside the feature — act:471dd701, N2 of grp:retro-remeaning.
+// See templates/scripts/__tests__/extraction-classification.test.mjs for
+// their replacement (derivable/subject/unclassifiable).
 
 // --- F4: annotate write discipline -------------------------------------------
 

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

@@ -0,0 +1,219 @@
+// Extraction classification (act:471dd701, N2 of grp:retro-remeaning) — break
+// the type⇒durability weld, add derivable/subject, delete the broken
+// freshness flag, unify the four-axis vocabulary.
+//
+// Contract under test:
+// C1: the extraction prompt carries no "lessons don't decay" axiom.
+// C2: the prompt's JSON schema literal matches the exported
+//     KNOWLEDGE_EXTRACTION_TYPES / KNOWLEDGE_EXTRACTION_HOMES arrays —
+//     one source of truth, not a re-spelled doc.
+// C3: a derivable item (the "prod is at commit X" / "the census run
+//     already executed" shape) is routed to home:'derivation', never
+//     written to memory, and is ALWAYS filed — never dropped.
+// C4: a durable lesson (no derivable claim) is routed to home:'memory'
+//     with a draft_artifact, unaffected by the derivable path.
+// C5: an unclassifiable item is filed with its required reason — model
+//     uncertainty is visible, never a forced type/home guess, and it is
+//     never silently dropped either.
+// 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.
+//
+// Hermetic: WATCHTOWER_DIR points at a temp dir, set BEFORE the dynamic
+// imports. No live Anthropic calls — callFn is injected throughout.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const root = mkdtempSync(join(tmpdir(), 'extraction-classification-'));
+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 itemFiles = () => readdirSync(join(root, 'queue', 'items')).filter((f) => f.endsWith('.json'));
+const readItems = () => itemFiles().map((f) => JSON.parse(readFileSync(join(root, 'queue', 'items', f), 'utf8')));
+const clearQueue = () => { for (const f of itemFiles()) rmSync(join(root, 'queue', 'items', f)); };
+const project = () => ({ name: 'classify-proj', path: join(tmpdir(), 'no-such-proj'), slug: 'classify-proj' });
+
+function capturingCall(response) {
+  let capturedSystemPrompt = null;
+  const callFn = async (systemPrompt) => {
+    capturedSystemPrompt = systemPrompt;
+    return JSON.stringify(response);
+  };
+  return { callFn, getPrompt: () => capturedSystemPrompt };
+}
+
+// --- C1/C2: the prompt itself ---
+
+test('C1: the extraction prompt carries no "lessons don\'t decay" axiom', async () => {
+  clearQueue();
+  const { callFn, getPrompt } = capturingCall([]);
+  await r3.decisionExtraction('transcript', project(), 'sess-prompt', '/t/x.jsonl', [], { callFn });
+  const prompt = getPrompt();
+  assert.ok(prompt, 'systemPrompt was captured');
+  assert.ok(!/does not decay/i.test(prompt), 'the retired axiom must be gone');
+  assert.ok(!/durable knowledge — their value/i.test(prompt));
+});
+
+test('C2: the prompt\'s JSON schema literal matches the exported four-axis vocabulary', async () => {
+  clearQueue();
+  const { callFn, getPrompt } = capturingCall([]);
+  await r3.decisionExtraction('transcript', project(), 'sess-schema', '/t/x.jsonl', [], { callFn });
+  const prompt = getPrompt();
+  const typesLiteral = lib.KNOWLEDGE_EXTRACTION_TYPES.join('|');
+  const homesLiteral = lib.KNOWLEDGE_EXTRACTION_HOMES.join('|');
+  assert.ok(prompt.includes(`"type":"${typesLiteral}"`),
+    `prompt type schema must read exactly "${typesLiteral}"`);
+  assert.ok(prompt.includes(`"home":"${homesLiteral}"`),
+    `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(/SUBJECT/.test(prompt));
+  assert.ok(/UNCLASSIFIABLE/.test(prompt));
+});
+
+// --- C3: derivable facts — the two deploy-shaped drafts ---
+
+test('C3: two derivable ("deploy state") drafts are both routed to derivation, never memory, never dropped', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([
+    {
+      type: 'lesson', home: 'derivation', urgency: 'normal',
+      title: 'prod is at commit 35a5d15', content: 'Prod was observed at 35a5d15 during this session.',
+      derivable: true, derivation: 'git log --oneline -1 on the deploy remote, or check the deploy log',
+      subject: 'classify-proj', covered_by: 'none',
+    },
+    {
+      type: 'lesson', home: 'derivation', urgency: 'normal',
+      title: 'the census run already executed', content: 'The arb-forum census run was confirmed complete this session.',
+      derivable: true, derivation: "check the run's pib-db action status or the run log",
+      subject: 'classify-proj', covered_by: 'none',
+    },
+  ]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-derivable', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 2, 'both derivable items are ALWAYS filed — never dropped');
+
+  const items = readItems();
+  assert.equal(items.length, 2);
+  for (const item of items) {
+    assert.equal(item.evidence.home, 'derivation', 'routed to derivation, not memory');
+    assert.equal(item.evidence.derivable, true);
+    assert.ok(typeof item.evidence.derivation === 'string' && item.evidence.derivation.trim().length > 0);
+    assert.equal(item.draft_artifact, null, 'a derivable fact is never written as a memory draft');
+    assert.ok(item.summary.includes('Derivation:'), 'the recomputation instruction is visible to the human');
+    assert.deepEqual(item.options.map((o) => o.key).sort(), ['acknowledge', 'dismiss']);
+  }
+});
+
+// --- C4: a durable lesson is unaffected ---
+
+test('C4: a durable lesson (no derivable claim) still routes to memory with a draft', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([{
+    type: 'lesson', home: 'memory', urgency: 'normal',
+    title: 'a partial JSONB update silently destroys omitted keys',
+    content: 'Updating a JSONB column with a partial payload replaces the whole value — keys omitted from the payload are destroyed, not merged. Always read-merge-write.',
+    subject: 'classify-proj', covered_by: 'none',
+  }]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-durable', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 1);
+  const [item] = readItems();
+  assert.equal(item.evidence.home, 'memory');
+  assert.equal(item.evidence.derivable, undefined);
+  assert.ok(item.draft_artifact && item.draft_artifact.includes('partial JSONB update'));
+  assert.deepEqual(item.options.map((o) => o.key), ['write', 'edit', 'dismiss']);
+});
+
+// --- C5: unclassifiable ---
+
+test('C5: an unclassifiable item is filed with its required reason — never a forced guess, never dropped', async () => {
+  clearQueue();
+  const callFn = async () => JSON.stringify([{
+    type: 'unclassifiable',
+    title: 'something worth flagging that fits no existing bucket',
+    content: 'A genuinely ambiguous observation the model cannot confidently type or home.',
+    unclassifiable_reason: 'not clearly a lesson, decision, or preference — and no home fits either',
+    covered_by: 'none',
+  }]);
+  const r = await r3.decisionExtraction('transcript', project(), 'sess-unclassifiable', '/t/x.jsonl', [], { callFn });
+  assert.equal(r.queued, 1, 'unclassifiable is filed, not dropped');
+  const [item] = readItems();
+  assert.equal(item.evidence.type, 'unclassifiable');
+  assert.equal(item.evidence.unclassifiable_reason, 'not clearly a lesson, decision, or preference — and no home fits either');
+  assert.equal(item.evidence.home, undefined, 'home is not forced for an unclassifiable item');
+  assert.deepEqual(item.options.map((o) => o.key).sort(), ['dismiss', 'triage']);
+});
+
+// --- C6: createItem boundary check ---
+
+test('C6: createItem rejects an illegal knowledge-extraction type or home', () => {
+  assert.throws(
+    () => q.createItem({
+      project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+      title: 'x', summary: 'x', context_anchor: 'x', evidence: { type: 'nonsense-type' },
+    }),
+    /illegal knowledge-extraction type/,
+  );
+  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: 'nonsense-home' },
+    }),
+    /illegal knowledge-extraction home/,
+  );
+});
+
+test('C6b: createItem rejects an unclassifiable item missing its reason', () => {
+  assert.throws(
+    () => q.createItem({
+      project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+      title: 'x', summary: 'x', context_anchor: 'x', evidence: { type: 'unclassifiable' },
+    }),
+    /unclassifiable_reason/,
+  );
+  assert.throws(
+    () => q.createItem({
+      project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+      title: 'x', summary: 'x', context_anchor: 'x', evidence: { type: 'unclassifiable', unclassifiable_reason: '   ' },
+    }),
+    /unclassifiable_reason/,
+  );
+});
+
+test('C6c: createItem rejects derivable:true without a derivation', () => {
+  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: 'derivation', derivable: true },
+    }),
+    /derivable:true requires evidence\.derivation/,
+  );
+});
+
+test('C6d: home is NOT validated for an unclassifiable item — the model is not asked to guess one', () => {
+  // Present-but-off-vocabulary home alongside unclassifiable must not throw:
+  // the boundary check skips home validation entirely in this branch.
+  assert.doesNotThrow(() => q.createItem({
+    project: 'boundary-proj', project_path: '/tmp/boundary-proj', category: 'knowledge-extraction',
+    title: 'x', summary: 'x', context_anchor: 'x',
+    evidence: { type: 'unclassifiable', unclassifiable_reason: 'genuinely unclear', home: 'whatever' },
+  }));
+});
+
+test('C6e: KNOWLEDGE_EXTRACTION_TYPES/HOMES are exported consistently from both queue and lib', () => {
+  assert.deepEqual(q.KNOWLEDGE_EXTRACTION_TYPES, lib.KNOWLEDGE_EXTRACTION_TYPES);
+  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'));
+});