@gcunharodrigues/wrxn 0.13.2 → 0.14.0

package/payload/.claude/hooks/sidecar.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+// WRXN shared coalesced-sidecar helper (kernel #12 / S1). The common mechanism behind recall-surface's
+// runtime STATE sidecars (.wrxn/reinforce.json, .wrxn/surfaced.json): read a JSON object map → let the
+// caller mutate it → REWRITE (not append) the whole map back, but ONLY when it actually changed
+// (coalesced: <= 1 write per real change, the file never grows on a no-op).
+//
+// Self-contained: ships into installs alongside the hooks — node stdlib ONLY (fs / path), NO kernel-lib
+// or recon import. FAIL-OPEN SILENT: any fault (absent dir, malformed existing sidecar, unwritable path)
+// is swallowed so the caller's primary effect always proceeds and nothing ever throws.
+
+const fs = require('fs');
+const path = require('path');
+
+// secretScan — replicated here because each self-contained install-only module imports no shared
+// kernel-lib (node stdlib only), exactly as it is duplicated across dream.cjs / sync.cjs. CASE-SENSITIVE:
+// the token shapes are case-specific. A coalesced sidecar must never harden a credential onto disk.
+const SECRET_PATTERNS = [
+  /AKIA[0-9A-Z]{16}/,                    // AWS access key id
+  /gh[pousr]_[A-Za-z0-9]{36}/,           // GitHub token (ghp_/gho_/ghu_/ghs_/ghr_)
+  /npm_[A-Za-z0-9]{36}/,                 // npm automation token
+  /sk-[A-Za-z0-9]{20,}/,                 // OpenAI-style secret key
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/, // FULL PEM block (BEGIN…END) — MUST precede the header-only line so redaction consumes the body, not just the header
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/,  // PEM private-key header (fallback: a lone/truncated header with no END)
+  /Bearer\s+[A-Za-z0-9\-._~+/]{16,}=*/i, // HTTP bearer / Authorization token (case-insensitive scheme)
+  // password=/pwd= assignment (=, :, quoted JSON/YAML). The keyword is EITHER fully quoted ("password":)
+  // OR bare (password=) — never a lone trailing quote, so a path ending in "passwd" used as a JSON key
+  // (e.g. "../../etc/passwd": …) is NOT misread as an assignment (it would falsely refuse a sidecar write).
+  /(?:["'](?:password|passwd|pwd)["']|(?:password|passwd|pwd))\s*[:=]\s*["']?[^\s"',;)&}{]+/i,
+  /[a-z][a-z0-9+.\-]+:\/\/[^\s:/@]+:[^\s/@]+@\S+/i, // URI connection string with inline creds (scheme://user:pass@host)
+  /eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}/, // JWT: base64url header(eyJ…).payload.signature
+];
+
+function secretScan(text) {
+  const s = String(text || ''); // NOT lowercased — the token shapes are case-sensitive.
+  for (const re of SECRET_PATTERNS) if (re.test(s)) return 'contains_secret';
+  return null;
+}
+
+// redactSecrets — scrub known secret shapes OUT of free text before it is persisted, built on the SAME
+// SECRET_PATTERNS as secretScan (one source of truth: when a shape is added, both detection and redaction
+// follow). Every match is replaced with a fixed placeholder while the surrounding text is preserved
+// (metadata-grade redaction, not a whole-value drop) — so a persisted prompt stays useful for analysis
+// yet never hardens a credential onto disk. Global-flagged clones of the patterns so EVERY occurrence on a
+// line is scrubbed, not just the first; String#replace resets a global regex's lastIndex per call, so
+// reusing these module-level clones is safe. TOTAL: a non-string coerces (null/undefined → ''). The clone
+// PRESERVES each pattern's own flags (e.g. /i) and only ADDS the global flag — so a case-insensitive shape
+// scans and redacts identically (dropping the flags here would let detection and redaction diverge).
+const SECRET_PATTERNS_GLOBAL = SECRET_PATTERNS.map((re) => new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g'));
+const SECRET_PLACEHOLDER = '[redacted]';
+
+function redactSecrets(text) {
+  let s = String(text == null ? '' : text); // NOT lowercased — the token shapes are case-sensitive.
+  for (const re of SECRET_PATTERNS_GLOBAL) s = s.replace(re, SECRET_PLACEHOLDER);
+  return s;
+}
+
+// Read the JSON object map at `file`, hand it to `mutate(map)`, and rewrite the file iff mutate signals
+// a change (returns truthy). Returns true when a write happened, false otherwise (including every
+// fail-open path). `mutate` mutates the map in place and returns whether it changed it. The fully
+// serialized map is secret-scanned before the write: if any value would harden a credential onto disk,
+// the write is REFUSED (fail-open — the sidecar stays as it was, the caller proceeds).
+function coalesceSidecar(file, mutate) {
+  try {
+    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 false; // malformed existing sidecar → skip silently, leave it untouched (never clobber)
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false; // not a map → skip
+      map = parsed;
+    }
+    if (!mutate(map)) return false; // nothing changed → coalesced no-op, no write
+    const body = JSON.stringify(map, null, 2) + '\n';
+    if (secretScan(body)) return false; // never harden a credential onto disk → refuse the write
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, body);
+    return true;
+  } catch {
+    return false; // best-effort: a sidecar fault must never alter or break the caller
+  }
+}
+
+module.exports = { coalesceSidecar, secretScan, redactSecrets };

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

@@ -276,11 +276,47 @@ function hasCurationDebt(root) {
   }
 }
 
+// The starved-useful watchdog's EMISSION bar (kernel #15 / S4): the number of starved-useful pages at or
+// above which the handoff carries the canary line. Distinct from the watchdog's MATH thresholds (R_HIGH /
+// S_LOW live with the pure reward.starvedUseful) — this is the "how many before we bug the operator" bar.
+// A PLACEHOLDER pending the lift gate (recorded with the gate verdict, like the decay half-life); it just
+// keeps the canary quiet until a few pages have genuinely starved. Kept local so the engine never
+// HARD-requires the reward sibling at module load (a missing sibling must not break constitution injection).
+const STARVED_NUDGE_THRESHOLD = 3;
+
+// The starved-useful WATCHDOG probe (kernel #15 / S4) — the sibling of hasCurationDebt for the learning
+// moat. A CHEAP, fail-open, READ-ONLY read of the two STATE sidecars (.wrxn/reward.json per-page
+// Beta-Bernoulli counts + .wrxn/surfaced.json per-session surfaced-log) → the pure reward.starvedUseful
+// count (pages learned high-reward but rarely surfaced). The reward sibling is required LAZILY inside the
+// try/catch so a (theoretically) absent sibling can never break the engine's constitution injection. Any
+// fault (missing/corrupt sidecar, missing sibling) → 0 (no nudge, no throw). Only invoked when a handoff
+// is actually firing, so the two extra reads are doubly bounded. CANARY: reads only — it never mutates a
+// sidecar and never touches recall ranking or reward counts.
+function starvedUsefulSignal(root) {
+  try {
+    const { starvedUseful } = require('./reward.cjs');
+    const readMap = (rel) => {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(root, '.wrxn', rel), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+      } catch {
+        return {}; // absent / malformed → empty (fail-open)
+      }
+    };
+    return starvedUseful(readMap('reward.json'), readMap('surfaced.json')).count;
+  } catch {
+    return 0; // any fault (incl. a missing reward sibling) → no signal, never a throw
+  }
+}
+
 // The NON-BLOCKING forced-handoff directive (never refuses work — orders the agent to wrap up cleanly).
 // `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) {
+// dream consolidates the session first, then harvest curates the enlarged knowledge set. `starvedCount`
+// (S4) appends ONE canary line LAST — emitted ONLY when the starved-useful count >= STARVED_NUDGE_THRESHOLD
+// (below / omitted / garbage → silent, totality). The canary states the count and that it is (b)-pressure
+// (data toward graduating a recon reward term); it is informational only and changes no recall/reward state.
+function handoffDirective(consumed, pct, hasDebt, starvedCount) {
   const now = Math.round(consumed * 100);
   const thresh = Math.round(pct * 100);
   const lines = [
@@ -293,6 +329,10 @@ function handoffDirective(consumed, pct, hasDebt) {
   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.');
   }
+  const starved = Number(starvedCount);
+  if (Number.isFinite(starved) && starved >= STARVED_NUDGE_THRESHOLD) {
+    lines.push(`  Watchdog (canary, informational): ${starved} starved-useful page(s) — learned high-reward but rarely surfaced, sitting below recon's floor where the kernel-side re-rank can't lift them. This is (b)-pressure: data toward graduating a recon reward term (option b). Informational only — nothing auto-changes; no recall or reward state is touched.`);
+  }
   return lines.join('\n');
 }
 
@@ -360,7 +400,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, hasCurationDebt(root)));
+      if (consumed >= pct) out.push(handoffDirective(consumed, pct, hasCurationDebt(root), starvedUsefulSignal(root)));
     }
   }
 
@@ -411,5 +451,7 @@ module.exports = {
   modelWindow,
   resolveHandoffPct,
   hasCurationDebt,
+  starvedUsefulSignal,
   handoffDirective,
+  STARVED_NUDGE_THRESHOLD,
 };

package/payload/.claude/hooks/wiki-lint.cjs

@@ -50,8 +50,71 @@ function lintPage(text) {
   return null;
 }
 
+// A page's identity is its `name:` frontmatter slug — it is the wikilink target ([[name]]), the
+// filename, and the dedup key. Returns the slug, or null when the page has no readable name.
+function pageName(text) {
+  const m = /^name\s*:\s*(.+)$/m.exec(String(text || ''));
+  return m ? m[1].trim() : null;
+}
+
+// The body is everything after the frontmatter block (where prose [[wikilinks]] live).
+function pageBody(text) {
+  const src = String(text || '');
+  if (!src.startsWith('---')) return src;
+  const end = src.indexOf('\n---', 3);
+  return end < 0 ? '' : src.slice(end + 4);
+}
+
+// Wikilinks are written `[[slug]]` (Obsidian style), where slug equals a target page's `name:`. An
+// optional `|alias` or `#anchor` is stripped to the bare target slug. Returns the distinct slugs.
+// The inner class excludes BOTH `]` and `[`: a real `[[slug]]` target never contains `[`, and the
+// unbounded `[^\]]+` form backtracked O(n²) on runs of `[`, hanging this Stop hook on a `[`-heavy
+// page (ReDoS, S2 #29). Bounding the class is the root-cause fix — linear AND more correct.
+function wikilinkTargets(body) {
+  const out = new Set();
+  const re = /\[\[([^\]\[]+)\]\]/g;
+  let m;
+  while ((m = re.exec(String(body || '')))) {
+    const slug = m[1].split('|')[0].split('#')[0].trim();
+    if (slug) out.add(slug);
+  }
+  return [...out];
+}
+
+// Corpus-level checks (need every page, so they run over the swept corpus, not per-page).
+// `corpus` is an array of { ref, name, body }; `ref` is the human-readable `tier/file.md` label.
+// Returns dead-wikilink findings: a [[slug]] whose slug matches no existing page name.
+function deadLinkFindings(corpus) {
+  const names = new Set(corpus.map((p) => p.name).filter(Boolean));
+  const findings = [];
+  for (const page of corpus) {
+    for (const slug of wikilinkTargets(page.body)) {
+      if (!names.has(slug)) findings.push(`${page.ref} — dead wikilink [[${slug}]]`);
+    }
+  }
+  return findings;
+}
+
+// Duplicate page titles: two+ pages sharing the same `name:` identity slug — an identity collision
+// (write-page even refuses to overwrite by slug), the tell that the pages should have been merged.
+// One finding per colliding title, naming every page that claims it.
+function duplicateTitleFindings(corpus) {
+  const byName = new Map();
+  for (const page of corpus) {
+    if (!page.name) continue; // a name-less page is already caught by the malformed check
+    if (!byName.has(page.name)) byName.set(page.name, []);
+    byName.get(page.name).push(page.ref);
+  }
+  const findings = [];
+  for (const [name, refs] of byName) {
+    if (refs.length > 1) findings.push(`duplicate title "${name}" — ${refs.join(', ')}`);
+  }
+  return findings;
+}
+
 function sweep(root) {
   const flagged = [];
+  const corpus = [];
   for (const tier of TIERS) {
     const dir = path.join(root, '.wrxn', 'wiki', tier);
     let names;
@@ -67,6 +130,7 @@ function sweep(root) {
       } catch {
         continue;
       }
+      corpus.push({ ref: `${tier}/${name}`, name: pageName(text), body: pageBody(text) });
       const reason = lintPage(text);
       if (reason) {
         flagged.push(`${tier}/${name} — ${reason}`);
@@ -74,6 +138,11 @@ function sweep(root) {
       }
     }
   }
+  // Corpus-level checks run after every page is read (they need the full set of page names).
+  for (const f of [...deadLinkFindings(corpus), ...duplicateTitleFindings(corpus)]) {
+    flagged.push(f);
+    if (flagged.length >= MAX_FLAGGED) return flagged;
+  }
   return flagged;
 }
 
@@ -92,7 +161,7 @@ function main() {
 
   const ctx = [
     '<wiki-lint>',
-    `${flagged.length} malformed wiki page(s) — fix the frontmatter (name / description / tier):`,
+    `${flagged.length} wiki integrity issue(s) — malformed frontmatter, dead [[wikilinks]], or duplicate page titles:`,
     ...flagged.map((f) => `- ${f}`),
     '</wiki-lint>',
   ].join('\n');

package/payload/.claude/settings.json

@@ -10,7 +10,8 @@
     "SessionEnd": [
       {
         "hooks": [
-          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/memory-synth-spawn.cjs\"" }
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/memory-synth-spawn.cjs\"" },
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-end-reward.cjs\"" }
         ]
       }
     ],
@@ -19,7 +20,8 @@
         "hooks": [
           { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/synapse-engine.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\"" }
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/recall-surface.cjs\"" },
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/emit-event.cjs\"" }
         ]
       }
     ],
@@ -50,6 +52,11 @@
           { "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\"" }
         ]
+      },
+      {
+        "hooks": [
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/emit-event.cjs\"" }
+        ]
       }
     ],
     "Stop": [

package/payload/.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "recon-wrxn": {
       "command": "npx",
-      "args": ["-y", "recon-wrxn@6.0.0-wrxn.8", "serve"]
+      "args": ["-y", "recon-wrxn@6.0.0-wrxn.9", "serve"]
     }
   }
 }