@gcunharodrigues/wrxn 0.5.0 → 0.7.0

package/lib/install.cjs

@@ -84,6 +84,8 @@ function init(opts) {
 
   // recon-wrxn writes its index into a fixed `.recon-wrxn/` dir — keep it out of version control.
   ensureGitignoreLine(target, '.recon-wrxn/');
+  // the recall-surface hook writes per-install access-recency state here (harvest-08) — runtime, not committed.
+  ensureGitignoreLine(target, '.wrxn/reinforce.json');
 
   writeReceipt(target, { version, profile, laid, skipped, merged, brownfield });
 

package/manifest.json

@@ -23,6 +23,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/hooks/drift-detect.cjs",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/hooks/enforce-managed-guard.cjs",
       "class": "managed",
@@ -58,16 +63,6 @@
       "class": "managed",
       "profile": "project"
     },
-    {
-      "path": ".claude/hooks/session-end.cjs",
-      "class": "managed",
-      "profile": "project"
-    },
-    {
-      "path": ".claude/hooks/session-history.cjs",
-      "class": "managed",
-      "profile": "project"
-    },
     {
       "path": ".claude/hooks/session-start.cjs",
       "class": "managed",
@@ -128,6 +123,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/harvest/SKILL.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/improve-codebase-architecture/DEEPENING.md",
       "class": "managed",
@@ -293,6 +293,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/sync/SKILL.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/tdd/SKILL.md",
       "class": "managed",
@@ -423,6 +428,21 @@
       "class": "state",
       "profile": "project"
     },
+    {
+      "path": ".wrxn/sync.cjs",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".wrxn/harvest.cjs",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".wrxn/harvest/.gitkeep",
+      "class": "state",
+      "profile": "project"
+    },
     {
       "path": ".wrxn/wiki.cjs",
       "class": "managed",
@@ -448,11 +468,6 @@
       "class": "state",
       "profile": "project"
     },
-    {
-      "path": ".wrxn/wiki/sessions/.gitkeep",
-      "class": "state",
-      "profile": "project"
-    },
     {
       "path": ".wrxn/wiki/_rules/.gitkeep",
       "class": "state",

package/migrations/004-retire-session-capture.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 004 — retire the session-capture subsystem (harvest-01).
+ *
+ * Phase 5 (harvest) drops the low-value mechanical session-capture layer: the `session-end` episodic
+ * breadcrumb writer, the `session-history` turn-trail recorder, and the `sessions` wiki tier they fed.
+ * The deliberate handoff (continuity baton) + dream consolidation are the close-out moment now — the
+ * automatic breadcrumb no longer earns its keep. The new payload no longer SHIPS the two hooks, but a
+ * pre-0.7.0 install still carries them: `wrxn update` overwrites a managed file in place, it never
+ * PRUNES one that was removed. So an existing install keeps the two hook files, a settings.json still
+ * wired for them, a populated `sessions` tier, and now-orphaned history scratch. up() sweeps all of it.
+ *
+ * Steps: (1) remove the two retired hook files; (2) unwire them from the install settings.json — drop
+ * the SessionEnd event whose only hook was session-end, and the session-history command from the
+ * UserPromptSubmit chain (synapse-engine + the rest are preserved); (3) remove the whole
+ * `.wrxn/wiki/sessions/` tier (dated pages + the gitkeep); (4) reap the now-orphaned
+ * `.wrxn/history/*.trail` (no writer/reader left) + `*.touched` markers. The `.wrxn/history/` dir
+ * itself STAYS — code-intel-push still writes `.touched` markers there.
+ *
+ * Defensive like 002/003: every step is existence-guarded and best-effort (force-rm ignores a missing
+ * file), a missing/clean target is a no-op, and a corrupt settings.json is left untouched (never
+ * clobber a hand-edited file — the other sweeps still run). Idempotent (a second run finds nothing to
+ * do) and never throws on an already-clean install. `version` 0.7.0 = the harvest release that carries
+ * the retirement (the same release whose payload stops shipping the two hooks).
+ */
+
+const RETIRED_HOOKS = ['session-end.cjs', 'session-history.cjs'];
+
+// Remove every hook command referencing `basename` across all settings events; drop any group left
+// with no hooks, and any event left with no groups. Returns true iff the config changed. Preserves
+// every other hook (synapse-engine, reference-detect, recall-surface, session-start, …).
+function unwireHook(cfg, basename) {
+  const hooks = cfg && cfg.hooks;
+  if (!hooks || typeof hooks !== 'object') return false;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const groups = hooks[event];
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (!group || !Array.isArray(group.hooks)) continue;
+      const before = group.hooks.length;
+      group.hooks = group.hooks.filter(
+        (h) => !(h && typeof h.command === 'string' && h.command.includes(basename)),
+      );
+      if (group.hooks.length !== before) changed = true;
+    }
+    const kept = groups.filter((g) => g && Array.isArray(g.hooks) && g.hooks.length > 0);
+    if (kept.length !== groups.length) {
+      changed = true;
+      if (kept.length === 0) delete hooks[event];
+      else hooks[event] = kept;
+    }
+  }
+  return changed;
+}
+
+module.exports = {
+  id: '004',
+  version: '0.7.0',
+  up(ctx) {
+    const target = ctx.target;
+
+    // 1. remove the two retired hook files (force = absent is a no-op)
+    for (const h of RETIRED_HOOKS) {
+      fs.rmSync(path.join(target, '.claude', 'hooks', h), { force: true });
+    }
+
+    // 2. unwire them from settings.json — only while still wired; a corrupt file is left untouched
+    const settingsPath = path.join(target, '.claude', 'settings.json');
+    if (fs.existsSync(settingsPath)) {
+      let cfg = null;
+      try {
+        cfg = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      } catch {
+        cfg = null; // hand-corrupted operator file → never clobber, never crash
+      }
+      if (cfg && typeof cfg === 'object') {
+        let changed = false;
+        for (const h of RETIRED_HOOKS) if (unwireHook(cfg, h)) changed = true;
+        if (changed) fs.writeFileSync(settingsPath, JSON.stringify(cfg, null, 2) + '\n');
+      }
+    }
+
+    // 3. sweep the retired `sessions` wiki tier (the whole dir: dated pages + the gitkeep)
+    fs.rmSync(path.join(target, '.wrxn', 'wiki', 'sessions'), { recursive: true, force: true });
+
+    // 4. reap orphaned history scratch — the *.trail (no writer/reader left) + *.touched markers.
+    //    The `.wrxn/history/` dir itself stays: code-intel-push still records .touched markers there.
+    const histDir = path.join(target, '.wrxn', 'history');
+    let names = [];
+    try {
+      names = fs.readdirSync(histDir);
+    } catch {
+      names = []; // no history dir → nothing to reap
+    }
+    for (const n of names) {
+      if (n.endsWith('.trail') || n.endsWith('.touched')) {
+        fs.rmSync(path.join(histDir, n), { force: true });
+      }
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcunharodrigues/wrxn",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "WRXN Kernel — installable AI operating system. Two profiles (project | workspace), pull-based updates, managed/seeded/state file classes.",
   "bin": {
     "wrxn": "bin/wrxn.cjs"
@@ -13,7 +13,7 @@
     "manifest.json"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test --require ./test/setup.cjs"
   },
   "dependencies": {
     "recon-wrxn": "6.0.0-wrxn.3"

package/payload/.claude/hooks/drift-detect.cjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN drift-detect hook — reactive provenance-drift nudge (sync-07).
+// PostToolUse (Edit|Write). When an edit touches a SOURCE file that downstream wiki docs declare
+// `derived_from:`, it injects a <drift> nudge naming the affected doc(s) — so drift surfaces the moment
+// the source moves, not only at the next batch `wrxn sync`.
+//
+// Self-contained: ships into installs, MUST NOT import the kernel lib OR recon (node stdlib only).
+// Mechanical: a pure fs + string frontmatter scan, NO LLM call. Independent of sync-01 — it never reads
+// a `synced_to:` watermark and never writes; detection NUDGE only.
+//
+// Fail-open: any fault (no install root, unreadable wiki, a corrupt page, a missing dir) emits {} and
+// NEVER blocks the edit.
+//
+// Contract: PostToolUse event JSON on stdin → envelope JSON on stdout (exit 0).
+
+const fs = require('fs');
+const path = require('path');
+
+function emit(envelope) {
+  process.stdout.write(JSON.stringify(envelope));
+  process.exit(0);
+}
+
+function findInstallRoot(startDir) {
+  let dir = startDir || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, 'wrxn.install.json'))) return dir;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+// Normalize a path-ish value to an install-root-relative POSIX path. Drops a `#symbol` anchor
+// (sync's `derived_from: path#symbol` form), then resolves relative/absolute/`./`-prefixed forms to
+// the same canonical key so same-path and relative-path declarations both match. Returns '' on empty.
+function relTo(root, p) {
+  const s = String(p == null ? '' : p).split('#')[0].trim();
+  if (!s) return '';
+  const abs = path.isAbsolute(s) ? s : path.resolve(root, s);
+  return path.relative(root, abs).split(path.sep).join('/');
+}
+
+function unquote(s) {
+  return String(s).trim().replace(/^["']|["']$/g, '').trim();
+}
+
+// Extract the frontmatter block (between the leading `---` fence and the next `---`). A page without a
+// closed fence yields '' — its provenance is unreadable, so it simply contributes no declaration.
+function frontmatter(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  return m ? m[1] : '';
+}
+
+// Parse the `derived_from:` declaration(s) from a page's frontmatter. Handles a scalar, an inline list
+// (`[a, b]`), and a block list (`- item` lines). Returns the raw value strings (anchors intact).
+function parseDerivedFrom(content) {
+  const fm = frontmatter(content);
+  if (!fm) return [];
+  const lines = fm.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^derived_from:\s*(.*)$/.exec(lines[i]);
+    if (!m) continue;
+    const val = m[1].trim();
+    if (val.startsWith('[')) {
+      // inline list: [a, b, c]
+      for (const part of val.replace(/^\[|\]$/g, '').split(',')) {
+        const v = unquote(part);
+        if (v) out.push(v);
+      }
+    } else if (val) {
+      out.push(unquote(val));
+    } else {
+      // block list: subsequent `  - item` lines until the first non-item line
+      for (let j = i + 1; j < lines.length; j++) {
+        const li = /^\s*-\s+(.*)$/.exec(lines[j]);
+        if (!li) break;
+        const v = unquote(li[1]);
+        if (v) out.push(v);
+      }
+    }
+  }
+  return out;
+}
+
+// Collect every .md page under <root>/.wrxn/wiki/ (recursively). A missing/unreadable dir yields [].
+function collectDocs(wikiDir, acc) {
+  let entries;
+  try {
+    entries = fs.readdirSync(wikiDir, { withFileTypes: true });
+  } catch {
+    return acc; // missing/unreadable tree → no docs
+  }
+  for (const e of entries) {
+    const full = path.join(wikiDir, e.name);
+    if (e.isDirectory()) collectDocs(full, acc);
+    else if (e.isFile() && e.name.endsWith('.md')) acc.push(full);
+  }
+  return acc;
+}
+
+// The set of doc relpaths whose frontmatter declares `derived_from:` the edited path.
+function affectedDocs(root, editedRel) {
+  const wikiDir = path.join(root, '.wrxn', 'wiki');
+  const hits = new Set();
+  for (const file of collectDocs(wikiDir, [])) {
+    let content;
+    try {
+      content = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue; // skip an unreadable page (fail-open per-file)
+    }
+    const docRel = path.relative(root, file).split(path.sep).join('/');
+    if (docRel === editedRel) continue; // never flag the edited file against itself
+    for (const raw of parseDerivedFrom(content)) {
+      if (relTo(root, raw) === editedRel) {
+        hits.add(docRel);
+        break;
+      }
+    }
+  }
+  return [...hits].sort();
+}
+
+function main() {
+  let event = {};
+  try {
+    const stdin = fs.readFileSync(0, 'utf8');
+    if (stdin.trim()) event = JSON.parse(stdin);
+  } catch {
+    emit({});
+  }
+
+  const root = findInstallRoot();
+  if (!root) emit({});
+
+  const filePath = event.tool_input && event.tool_input.file_path;
+  if (!filePath || typeof filePath !== 'string') emit({}); // not a file-touching tool
+
+  const editedRel = relTo(root, filePath);
+  if (!editedRel) emit({});
+
+  const docs = affectedDocs(root, editedRel);
+  if (docs.length === 0) emit({}); // no downstream provenance → silent
+
+  const ctx = [
+    '<drift>',
+    `Edited ${editedRel} — ${docs.length} downstream doc(s) declare derived_from it and may now be stale:`,
+    ...docs.map((d) => `  - ${d}`),
+    'Re-derive the affected doc(s), or run `wrxn sync` to confirm the drift set.',
+    '</drift>',
+  ].join('\n');
+
+  emit({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: ctx } });
+}
+
+try {
+  main();
+} catch {
+  emit({});
+}

package/payload/.claude/hooks/recall-surface.cjs

@@ -36,6 +36,8 @@ const SEMANTIC_FLOOR = 0.4;        // dense cosine floor (reused from P1.5)
 const PROSE_TYPES = new Set(['Page', 'Section']); // prose scope — drop code symbols
 const ENDPOINT_REL = path.join('.recon-wrxn', 'serve-endpoint.json');
 const FIND_PATH = '/api/tools/recon_find';
+const REINFORCE_REL = path.join('.wrxn', 'reinforce.json'); // coalesced access-recency sidecar (STATE)
+const WIKI_PREFIX = '.wrxn/wiki/'; // the wiki root — stripped to form the D1 join key
 
 function emit(envelope) {
   process.stdout.write(JSON.stringify(envelope));
@@ -122,14 +124,90 @@ function renderBlock(hits) {
   return block;
 }
 
+// PURE: the prose hits that clear the gate, capped at TOP_N — exactly the hits decideRecall renders
+// (and the pages reinforce stamps). Factored out so the IO shell can stamp the surfaced pages by path.
+function qualifyingHits(hits) {
+  const list = Array.isArray(hits) ? hits : [];
+  return list.filter((h) => isProse(h) && qualifies(h)).slice(0, TOP_N);
+}
+
 // PURE: prose-filter → gate → top-N → format. Returns the block string, or null (Abstain).
 function decideRecall(hits) {
-  const list = Array.isArray(hits) ? hits : [];
-  const qualified = list.filter((h) => isProse(h) && qualifies(h)).slice(0, TOP_N);
+  const qualified = qualifyingHits(hits);
   if (!qualified.length) return null;
   return renderBlock(qualified);
 }
 
+// ── reinforce: the coalesced access-recency sidecar (harvest-08 / D2) ─────────────────
+//
+// When Recall actually surfaces prose pages, stamp each page's "last used" day into
+// <root>/.wrxn/reinforce.json — a COMPACT MAP { "<wiki-rel-path>": "YYYY-MM-DD" }, NOT page frontmatter
+// (no churn) and NOT an append log (no growth). recon harvest-07/D1 reads this sidecar to compute
+// recency for decay-weighted retrieval; the join key MUST be the wiki-root-relative path on BOTH sides
+// (a slug-vs-path mismatch silently breaks recency). COALESCED to <= 1 write per page per day: when
+// every surfaced page already carries today's date the map is unchanged and NOTHING is written.
+// BEST-EFFORT + NON-BLOCKING: this is a pure side effect of recall — any fault (absent dir, malformed
+// existing sidecar, unwritable path) is swallowed so the surfacing always proceeds.
+
+// The wiki-root-relative join key for a prose hit's file: tolerate a leading './', normalize separators,
+// then strip the '.wrxn/wiki/' prefix → e.g. 'concepts/foo.md'. Returns null when the file is not under
+// the wiki root (no join key — never stamped).
+function wikiRelPath(file) {
+  const f = String(file || '').replace(/\\/g, '/').replace(/^\.\//, '');
+  const i = f.indexOf(WIKI_PREFIX);
+  if (i === -1) return null;
+  return f.slice(i + WIKI_PREFIX.length) || null;
+}
+
+// A day-granular UTC stamp (YYYY-MM-DD): the coalescing grain AND D1's recency value. Injectable clock
+// (`now` = a Date/ms/iso, default real time) so day-granularity is deterministic under test.
+function dayStamp(now) {
+  const d = now instanceof Date ? now : new Date(now == null ? Date.now() : now);
+  return d.toISOString().slice(0, 10);
+}
+
+// Stamp each surfaced prose hit's wiki-rel path → today into <root>/.wrxn/reinforce.json. Writes only
+// when the map actually changes (coalesced). Wholly best-effort: never throws, never blocks recall.
+function reinforce(root, hits, now) {
+  try {
+    const list = Array.isArray(hits) ? hits : [];
+    if (!root || !list.length) return;
+    const file = path.join(root, REINFORCE_REL);
+    let map = {};
+    let raw = null;
+    try {
+      raw = fs.readFileSync(file, 'utf8');
+    } catch {
+      raw = null; // absent → fresh map (normal, not a fault)
+    }
+    if (raw !== null) {
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return; // malformed existing sidecar → skip silently, leave it untouched (never clobber)
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return; // not a map → skip
+      map = parsed;
+    }
+    const day = dayStamp(now);
+    let changed = false;
+    for (const h of list) {
+      const key = wikiRelPath(h && h.file);
+      if (!key) continue; // not under the wiki root → no D1 join key
+      if (map[key] !== day) {
+        map[key] = day;
+        changed = true;
+      }
+    }
+    if (!changed) return; // coalesced no-op → file stays byte-identical (<= 1 write/page/day)
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(map, null, 2) + '\n');
+  } catch {
+    /* best-effort: a reinforce fault must NEVER alter or break the recall surfacing */
+  }
+}
+
 // ── the door (IO shell, injectable transport) ───────────────────────────────────────
 
 // A pid is alive unless process.kill(pid,0) throws ESRCH. EPERM means it exists (owned by another
@@ -233,7 +311,7 @@ function httpTransport({ port, path: reqPath, body, timeoutMs }) {
 // IO shell: discover the door, POST the prose query, gate the hits. Returns the block string or null.
 // `transport` is injected in tests; production uses httpTransport. Sends NO `type` (recon_find takes a
 // single NodeType, not an array) — prose scope is enforced by decideRecall's post-filter.
-async function recallFromDoor(root, prompt, { transport, timeoutMs } = {}) {
+async function recallFromDoor(root, prompt, { transport, timeoutMs, now } = {}) {
   const door = discoverEndpoint(root);
   if (!door) return null; // not warm → Abstain (silent)
   const query = String(prompt || '').trim().slice(0, MAX_QUERY_CHARS);
@@ -256,7 +334,11 @@ async function recallFromDoor(root, prompt, { transport, timeoutMs } = {}) {
   } catch {
     return null; // malformed body → silent
   }
-  return decideRecall(Array.isArray(parsed.hits) ? parsed.hits : []);
+  const hits = Array.isArray(parsed.hits) ? parsed.hits : [];
+  const block = decideRecall(hits);
+  // Side effect: stamp access-recency for the pages we actually surfaced (best-effort, never blocks).
+  if (block) reinforce(root, qualifyingHits(hits), now);
+  return block;
 }
 
 // ── entrypoint ──────────────────────────────────────────────────────────────────────
@@ -293,7 +375,11 @@ if (require.main === module) {
 
 module.exports = {
   decideRecall,
+  qualifyingHits,
   recallFromDoor,
+  reinforce,
+  wikiRelPath,
+  dayStamp,
   discoverEndpoint,
   httpTransport,
   pidAlive,

package/payload/.claude/hooks/session-start.cjs

@@ -3,9 +3,9 @@
 
 // WRXN session-start hook — the orientation surface (wrxn-kernel-10).
 // SessionStart. Injects identity + resume as additionalContext so every new session opens
-// oriented. The resume gives the DELIBERATE handoff baton precedence over the automatic
-// episodic record: a baton at .wrxn/continuity/latest.md (single writer = the handoff skill)
-// wins; otherwise the most-recent dated session page is surfaced as the resume pointer.
+// oriented. The resume surfaces the DELIBERATE handoff baton at .wrxn/continuity/latest.md (single
+// writer = the handoff skill); absent a baton there is no prior handoff to resume. (The automatic
+// episodic session-page fallback was retired with the session-capture subsystem in harvest-01.)
 //
 // Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
 // Fail-open: any fault emits {} (no orientation) — the hook NEVER blocks a session opening.
@@ -62,20 +62,6 @@ function readBaton(root) {
   return readFileOr(path.join(root, '.wrxn', 'continuity', 'latest.md'), null);
 }
 
-// The automatic episodic record: the most-recent dated session page (sessions tier).
-function latestSessionPage(root) {
-  const dir = path.join(root, '.wrxn', 'wiki', 'sessions');
-  let names;
-  try {
-    names = fs.readdirSync(dir).filter((n) => n.endsWith('.md'));
-  } catch {
-    return null;
-  }
-  if (names.length === 0) return null;
-  names.sort(); // dated `YYYY-MM-DD-…` slugs sort chronologically
-  return names[names.length - 1];
-}
-
 function main() {
   let consumed = '';
   try {
@@ -94,12 +80,7 @@ function main() {
   if (baton && baton.trim()) {
     parts.push('', 'Resume — deliberate handoff baton (.wrxn/continuity/latest.md):', baton.trim());
   } else {
-    const page = latestSessionPage(root);
-    if (page) {
-      parts.push('', `Resume — last session: .wrxn/wiki/sessions/${page}`);
-    } else {
-      parts.push('', 'Resume — fresh install, no prior session recorded.');
-    }
+    parts.push('', 'Resume — no prior handoff.');
   }
 
   emit({

package/payload/.claude/hooks/synapse-engine.cjs

@@ -247,18 +247,54 @@ function resolveHandoffPct(manifestText) {
   return Number.isFinite(m) && m > 0 ? m : 0.40;
 }
 
+// A CHEAP, fail-open presence-probe for curation debt — the debt-gate on the handoff harvest nudge
+// (harvest-05). It does NOT recompute health: no recon-door query, no scan of the knowledge tiers (that
+// is harvest.cjs `check`, an operator-invoked command far too heavy for a per-prompt hook). It reads ONLY
+// the single latest `.wrxn/harvest/<ts>.jsonl` report a prior `check` already wrote and asks "did the last
+// health-check find real debt?". Report filenames are timestamp-derived (ISO with `:`/`.` → `-`), so the
+// lexically-greatest name is the newest report. A real finding = any record EXCEPT the near_dup
+// "unavailable" marker (a cold-door "couldn't check", not debt); an empty report / only-unavailable / no
+// reports / missing dir all read as no-debt → silent. Any fault → false (never a spurious nudge, never a
+// throw). Only invoked when a handoff is actually firing, so the one extra file read is doubly bounded.
+function hasCurationDebt(root) {
+  try {
+    const dir = path.join(root, '.wrxn', 'harvest');
+    const reports = fs.readdirSync(dir).filter((n) => n.endsWith('.jsonl'));
+    if (!reports.length) return false;
+    const latest = reports.sort()[reports.length - 1];
+    const text = fs.readFileSync(path.join(dir, latest), 'utf8');
+    for (const line of text.split('\n')) {
+      const t = line.trim();
+      if (!t) continue;
+      let rec;
+      try { rec = JSON.parse(t); } catch { continue; } // a malformed line contributes nothing
+      if (rec && rec.type && rec.status !== 'unavailable') return true;
+    }
+    return false;
+  } catch {
+    return false; // missing dir / unreadable report / any fault → fail-open: no debt, no throw
+  }
+}
+
 // The NON-BLOCKING forced-handoff directive (never refuses work — orders the agent to wrap up cleanly).
-function handoffDirective(consumed, pct) {
+// `hasDebt` (harvest-05) appends a harvest curation nudge AFTER the dream line — emitted ONLY when the
+// latest health-check found curation debt, so a clean knowledge set never sees it. Ordered after dream:
+// dream consolidates the session first, then harvest curates the enlarged knowledge set.
+function handoffDirective(consumed, pct, hasDebt) {
   const now = Math.round(consumed * 100);
   const thresh = Math.round(pct * 100);
-  return [
+  const lines = [
     '[HANDOFF REQUIRED]',
     `  Context is at ~${now}% of the model window (>= the ${thresh}% handoff threshold). NON-BLOCKING — do NOT stop work:`,
     '  1. Finish the current request.',
     '  2. Run the handoff skill to write the baton (a compact handoff document).',
     '  3. Tell the operator to /clear and open a fresh session, where the baton injects on resume.',
     '  Suggestion (optional, before step 2): run the dream skill to consolidate this session\'s durable learnings into wiki memory — a suggestion only; dream never auto-runs, it acts only when you invoke it.',
-  ].join('\n');
+  ];
+  if (hasDebt) {
+    lines.push('  Then (optional, only because the last health-check found curation debt): run the harvest skill to review the flagged near-dups / decay-candidates / malformed pages — a suggestion only; harvest never auto-deletes, every change is proposed for your confirmation.');
+  }
+  return lines.join('\n');
 }
 
 // ── assembly ────────────────────────────────────────────────────────────────────
@@ -325,7 +361,7 @@ function compose(root, event) {
       const window = modelWindow(ev.cwd || root, process.env.HOME || os.homedir(), manifestText, ev.session_id, resident);
       const consumed = resident / window;
       const pct = resolveHandoffPct(manifestText);
-      if (consumed >= pct) out.push(handoffDirective(consumed, pct));
+      if (consumed >= pct) out.push(handoffDirective(consumed, pct, hasCurationDebt(root)));
     }
   }
 
@@ -375,5 +411,6 @@ module.exports = {
   readStatuslineWindow,
   modelWindow,
   resolveHandoffPct,
+  hasCurationDebt,
   handoffDirective,
 };

package/payload/.claude/settings.json

@@ -7,18 +7,10 @@
         ]
       }
     ],
-    "SessionEnd": [
-      {
-        "hooks": [
-          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-end.cjs\"" }
-        ]
-      }
-    ],
     "UserPromptSubmit": [
       {
         "hooks": [
           { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/synapse-engine.cjs\"" },
-          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-history.cjs\"" },
           { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/reference-detect.cjs\"" },
           { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/recall-surface.cjs\"" }
         ]
@@ -45,7 +37,8 @@
       {
         "matcher": "Edit|Write",
         "hooks": [
-          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/code-intel-push.cjs\"" }
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/code-intel-push.cjs\"" },
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/drift-detect.cjs\"" }
         ]
       }
     ],