@gcunharodrigues/wrxn 0.6.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

@@ -63,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",
@@ -133,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",
@@ -438,6 +433,16 @@
       "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",
@@ -463,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.6.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"

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\"" }
         ]