@gcunharodrigues/wrxn 0.11.0 → 0.12.0

package/lib/install.cjs

@@ -86,6 +86,9 @@ function init(opts) {
   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');
+  // the memory-synth gemini fallback reads GEMINI_API_KEY from `.env` — ignore it so the secret is
+  // never committed (the synth's doc-comment calls it the install's gitignored `.env`).
+  ensureGitignoreLine(target, '.env');
 
   writeReceipt(target, { version, profile, laid, skipped, merged, brownfield });
 

package/manifest.json

@@ -73,6 +73,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/hooks/memory-synth-spawn.cjs",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/hooks/recall-surface.cjs",
       "class": "managed",
@@ -143,11 +148,6 @@
       "class": "managed",
       "profile": "project"
     },
-    {
-      "path": ".claude/skills/handoff/SKILL.md",
-      "class": "managed",
-      "profile": "project"
-    },
     {
       "path": ".claude/skills/harvest/SKILL.md",
       "class": "managed",
@@ -488,6 +488,16 @@
       "class": "state",
       "profile": "project"
     },
+    {
+      "path": ".wrxn/memory-synth.cjs",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".wrxn/memory.config.json",
+      "class": "seeded",
+      "profile": "project"
+    },
     {
       "path": ".wrxn/sync.cjs",
       "class": "managed",

package/migrations/007-auto-memory-transition.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 007 — transition existing installs onto auto-memory (auto-memory-05).
+ *
+ * The auto-memory release makes memory automatic: a SessionEnd hook (memory-synth-spawn.cjs) spawns a
+ * background synth that writes the continuity baton and consolidates dream pages — so the manual
+ * `handoff` skill is removed (the synth is the sole baton writer) and the stale `_slots/current-focus`
+ * slot + its `set-focus` op are dropped. The new payload stops shipping the handoff skill and now wires
+ * SessionEnd + ships a seeded `memory.config.json`. But `wrxn update` overwrites managed files in place —
+ * it never PRUNES a removed one — and a seeded file already present is preserved, so a pre-0.12.0 install
+ * still carries the old `handoff` skill files and the stale focus slot, and may lack the new wiring/seed
+ * (e.g. a hand-edited settings.json the managed overwrite left alone, or an install that never had a
+ * config). up() transitions it.
+ *
+ * Steps: (1) remove the install's `handoff` skill dir; (2) wire SessionEnd → memory-synth-spawn.cjs into
+ * the install settings.json IDEMPOTENTLY (add only if absent — if update's managed overwrite already laid
+ * it, this is a safe no-op); a corrupt settings.json is left untouched; (3) seed `memory.config.json` if
+ * absent (the slice-02 default shape); (4) remove the stale `_slots/current-focus.md` focus slot;
+ * (5) backfill the install `.gitignore` for the `.env` secret and the continuity runtime temps the synth/
+ * dream now write (`.wrxn/continuity/.pending`, `.pending-handoff`, the baton `.tmp`, `.dream.*.tmp`) —
+ * slice-02 added `.env` for NEW installs; this closes the gap for OLD ones (slice-04 reviewer F1).
+ *
+ * Defensive like 004: every step is existence-guarded and best-effort (force-rm ignores a missing file),
+ * a missing/clean target is a no-op, a corrupt settings.json is left untouched (never clobber a hand-
+ * edited file — the other steps still run), and the gitignore backfill adds each line at most once.
+ * Idempotent (a second run finds nothing to do) and never throws on an already-clean install. `version`
+ * 0.12.0 = the auto-memory release that carries the transition (the same release whose payload stops
+ * shipping the handoff skill and starts wiring the SessionEnd synth).
+ */
+
+// The .gitignore lines auto-memory needs an install to carry: the `.env` secret (slice-02 added it for
+// NEW installs — backfilled here for OLD ones) + the continuity runtime markers/temps the synth and dream
+// write and clean in a finally, which a SIGKILL could leave behind UNTRACKED (slice-04 reviewer F1). The
+// tracked baton `latest.md` is deliberately NOT ignored — only its dot-prefixed `.tmp` is.
+const GITIGNORE_LINES = [
+  '.env',
+  '.wrxn/continuity/.pending*', // the .pending + .pending-handoff synth markers
+  '.wrxn/continuity/.dream.*.tmp', // dream's per-call blob/batch/stage/approved temps
+  '.wrxn/continuity/.latest.md.*.tmp', // the atomic baton-write temp (rename-over target)
+];
+
+/** Append `line` to `<target>/.gitignore` (create if absent) exactly once — mirrors install.cjs. */
+function ensureGitignoreLine(target, line) {
+  const giPath = path.join(target, '.gitignore');
+  let body = '';
+  try {
+    body = fs.readFileSync(giPath, 'utf8');
+  } catch {
+    body = '';
+  }
+  if (body.split('\n').some((l) => l.trim() === line)) return; // already ignored
+  const prefix = body.length && !body.endsWith('\n') ? '\n' : '';
+  fs.writeFileSync(giPath, body + prefix + line + '\n');
+}
+
+// The SessionEnd spawn hook the auto-memory payload wires (must match payload/.claude/settings.json).
+const SPAWN_HOOK_BASENAME = 'memory-synth-spawn.cjs';
+const SPAWN_HOOK_COMMAND = 'node "$CLAUDE_PROJECT_DIR/.claude/hooks/memory-synth-spawn.cjs"';
+
+// Idempotently wire SessionEnd → the spawn hook into a parsed settings config. Adds the hook ONLY if no
+// existing hook command across any event already references it — so a config the managed overwrite already
+// laid (or a prior run) is a safe no-op. Returns true iff the config changed. Preserves every other event.
+function wireSessionEndSpawn(cfg) {
+  if (!cfg || typeof cfg !== 'object') return false;
+  cfg.hooks = cfg.hooks && typeof cfg.hooks === 'object' ? cfg.hooks : {};
+  // already wired anywhere? (mirror unwireHook's whole-config scan) → no-op.
+  for (const groups of Object.values(cfg.hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (!group || !Array.isArray(group.hooks)) continue;
+      if (group.hooks.some((h) => h && typeof h.command === 'string' && h.command.includes(SPAWN_HOOK_BASENAME))) {
+        return false;
+      }
+    }
+  }
+  const event = Array.isArray(cfg.hooks.SessionEnd) ? cfg.hooks.SessionEnd : [];
+  event.push({ hooks: [{ type: 'command', command: SPAWN_HOOK_COMMAND }] });
+  cfg.hooks.SessionEnd = event;
+  return true;
+}
+
+module.exports = {
+  id: '007',
+  version: '0.12.0',
+  up(ctx) {
+    const target = ctx.target;
+
+    // 1. remove the retired `handoff` skill dir (the synth is the sole baton writer now). recursive +
+    //    force = an absent dir is a no-op.
+    fs.rmSync(path.join(target, '.claude', 'skills', 'handoff'), { recursive: true, force: true });
+
+    // 2. wire SessionEnd → memory-synth-spawn.cjs into the install settings.json, idempotently. A corrupt
+    //    file is left untouched (never clobber a hand-edited config); an absent file is left absent (the
+    //    managed overwrite lays the wired settings — the migration only backfills a hand-edited one).
+    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' && wireSessionEndSpawn(cfg)) {
+        fs.writeFileSync(settingsPath, JSON.stringify(cfg, null, 2) + '\n');
+      }
+    }
+
+    // 3. seed memory.config.json if absent (the slice-02 default). Copied from THIS package's payload so
+    //    the seeded shape can never drift from what a fresh install ships. Already present ⇒ preserved
+    //    (it is a seeded, operator-owned file). A missing payload source is swallowed (best-effort).
+    const cfgPath = path.join(target, '.wrxn', 'memory.config.json');
+    if (!fs.existsSync(cfgPath)) {
+      const seedSrc = path.join(__dirname, '..', 'payload', '.wrxn', 'memory.config.json');
+      try {
+        const seed = fs.readFileSync(seedSrc, 'utf8');
+        fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+        fs.writeFileSync(cfgPath, seed);
+      } catch {
+        // no payload seed reachable → skip (the managed/seeded update path lays it anyway)
+      }
+    }
+
+    // 4. remove the stale `_slots/current-focus.md` focus slot (the slot + its set-focus op are dropped).
+    //    Only the slot PAGE goes — the empty `_slots` tier dir + its gitkeep stay (the tier is retained).
+    //    force = an absent slot is a no-op.
+    fs.rmSync(path.join(target, '.wrxn', 'wiki', '_slots', 'current-focus.md'), { force: true });
+
+    // 5. gitignore backfill — add the `.env` secret + continuity runtime-temp lines (each at most once).
+    //    Closes the gap for installs created before slice-02 added `.env` / before the synth wrote temps.
+    for (const line of GITIGNORE_LINES) ensureGitignoreLine(target, line);
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcunharodrigues/wrxn",
-  "version": "0.11.0",
+  "version": "0.12.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/memory-synth-spawn.cjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+'use strict';
+
+// WRXN memory-synth-spawn — the SessionEnd hook that launches the background synthesizer (auto-memory-03).
+// SessionEnd is otherwise unwired, so this is its sole hook. Its ONLY job: return {} immediately and
+// spawn memory-synth.cjs DETACHED, so closing a session is NEVER blocked by summarization (PRD story 16).
+//
+// Recursion guard (PRD story 17): the synth runs `claude -p`, whose own session fires SessionEnd again —
+// a SessionEnd→claude→SessionEnd fork-bomb. The synth sets WRXN_MEMORY_SYNTH=1 on every engine spawn;
+// this hook no-ops (spawns nothing, writes no markers) when it sees that sentinel set.
+//
+// Before launching, it stashes the SessionEnd payload as the `.pending` marker and writes a
+// `.pending-handoff` marker under .wrxn/continuity/ — both so SessionStart can detect an in-flight synth
+// (and hold on the handoff marker) even before the detached child has done anything. The synth clears
+// them on exit (memory-synth.cjs), so the markers describe "a synth is running for this session".
+//
+// Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
+// Fail-open: any fault emits {} (no spawn) — the hook NEVER blocks a session closing.
+//
+// Contract: SessionEnd event JSON on stdin → {} on stdout (exit 0).
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const SENTINEL = 'WRXN_MEMORY_SYNTH'; // recursion guard (mirrors memory-synth.cjs's SENTINEL).
+
+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;
+}
+
+/**
+ * The testable core. Given the SessionEnd payload, the install root, the env (for the recursion guard),
+ * and an injectable `spawn`, it stashes the payload + writes the pending markers and launches the synth
+ * detached — returning {} immediately. With the recursion sentinel set it no-ops (spawns nothing, writes
+ * no markers). Fail-open: any fault → {} (session close is never blocked).
+ * @param {{ payload:object, root:string, env:object, spawn:Function }} opts
+ * @returns {object} the hook envelope — always {}
+ */
+function run({ payload, root, env = process.env, spawn: spawnFn = spawn }) {
+  try {
+    if (env && env[SENTINEL]) return {}; // inside a synth-spawned session — do not recurse.
+    if (!root) return {};
+
+    const dir = path.join(root, '.wrxn', 'continuity');
+    fs.mkdirSync(dir, { recursive: true });
+
+    // Stash the payload as .pending (the synth reads it for transcript_path) and raise the handoff gate.
+    fs.writeFileSync(path.join(dir, '.pending'), JSON.stringify(payload || {}));
+    fs.writeFileSync(path.join(dir, '.pending-handoff'), String(Date.now()));
+
+    // Launch the synth detached: stdio ignored + unref() so the parent's event loop never waits on it.
+    const synth = path.join(root, '.wrxn', 'memory-synth.cjs');
+    const child = spawnFn('node', [synth, '--from-spawn', '--root', root], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...env, [SENTINEL]: '1' },
+    });
+    if (child && typeof child.unref === 'function') child.unref();
+  } catch {
+    // fail-open: never block session close.
+  }
+  return {};
+}
+
+function main() {
+  let consumed = '';
+  try {
+    consumed = fs.readFileSync(0, 'utf8');
+  } catch {
+    /* no stdin → nothing to synthesize */
+  }
+  let payload = {};
+  try {
+    payload = consumed.trim() ? JSON.parse(consumed) : {};
+  } catch {
+    payload = {};
+  }
+  const root = findInstallRoot(payload && payload.cwd);
+  const out = run({ payload, root, env: process.env, spawn });
+  process.stdout.write(JSON.stringify(out));
+  process.exit(0);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch {
+    process.stdout.write('{}');
+    process.exit(0);
+  }
+}
+
+module.exports = { run };

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

@@ -3,9 +3,10 @@
 
 // WRXN session-start hook — the orientation surface (wrxn-kernel-10).
 // SessionStart. Injects identity + resume as additionalContext so every new session opens
-// 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.)
+// oriented. The resume surfaces the handoff baton at .wrxn/continuity/latest.md (single writer =
+// the memory synth `memory-synth.cjs`, which writes the baton automatically on SessionEnd); 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.
@@ -57,11 +58,76 @@ function identityLine(root) {
 }
 
 // The deliberate handoff baton — the intent-carrying continuity slot. Single writer: the
-// handoff skill. Read-only here; its presence takes precedence over the episodic record.
+// auto-handoff synth (memory-synth.cjs, auto-memory-03). Read-only here; its presence is the resume.
 function readBaton(root) {
   return readFileOr(path.join(root, '.wrxn', 'continuity', 'latest.md'), null);
 }
 
+// ── the SessionEnd-synth hold (auto-memory-03) ──────────────────────────────────
+// When a session ends, memory-synth-spawn.cjs raises a `.pending-handoff` marker and launches the synth
+// detached; the synth writes the baton then clears the marker. So a back-to-back /clear could start
+// BEFORE the fresh baton exists. We hold: poll the marker until it clears (synth done), bounded by a
+// crash safety-cap so a SIGKILLed synth (marker never cleared) can never hang start forever. The
+// poll-decision is pure and the loop takes an injected clock, so it is unit-tested with no wall sleep.
+const HANDOFF_MARKER_REL = ['.wrxn', 'continuity', '.pending-handoff'];
+const HOLD_CAP_MS = 60000; // crash safety-cap: never wait past this for an in-flight synth.
+const HOLD_POLL_MS = 250; // poll cadence (the real sleep step; tests inject their own).
+
+// A synchronous sleep for the real poll loop (the hook must finish before it emits; tests inject their
+// own sleep and never reach this). Atomics.wait blocks the thread without a busy-spin (node stdlib).
+function sleepMs() {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HOLD_POLL_MS);
+  } catch {
+    /* SharedArrayBuffer unavailable → degrade to no wait (the loop's wall-cap still bounds it) */
+  }
+}
+
+/**
+ * Pure poll-decision: wait vs proceed, from the marker's presence + age + the cap. No marker → proceed
+ * (no synth in flight). Marker present and younger than the cap → wait. Marker at/over the cap → proceed
+ * anyway (a crashed synth must not hang start). PURE.
+ * @param {{ markerExists:boolean, markerAgeMs:number, capMs:number }} s
+ * @returns {'wait'|'proceed'}
+ */
+function holdDecision({ markerExists, markerAgeMs, capMs }) {
+  if (!markerExists) return 'proceed';
+  return markerAgeMs >= capMs ? 'proceed' : 'wait';
+}
+
+/** Age (ms) of the handoff marker per the injected clock; Infinity if it is absent/unreadable. */
+function markerAgeMs(root, now) {
+  try {
+    const st = fs.statSync(path.join(root, ...HANDOFF_MARKER_REL));
+    return Math.max(0, now() - st.mtimeMs);
+  } catch {
+    return Infinity; // absent → treated as "no marker" by the caller.
+  }
+}
+
+/**
+ * Hold until the in-flight synth clears the handoff marker, or the safety-cap elapses. The clock is
+ * injected (now()/sleep()) so the loop is deterministic in tests — NO wall-clock sleep here. Returns
+ * 'cleared' (marker gone → fresh baton ready) or 'capped' (gave up at the cap). Never throws.
+ * @param {{ root:string, capMs?:number, now?:Function, sleep?:Function }} opts
+ * @returns {'cleared'|'capped'}
+ */
+function holdForHandoff({ root, capMs = HOLD_CAP_MS, now = Date.now, sleep } = {}) {
+  const marker = path.join(root, ...HANDOFF_MARKER_REL);
+  const wait = sleep || (() => {}); // with no injected waiter the loop takes a single pass then caps (line below).
+  const started = now();
+  for (;;) {
+    const exists = fs.existsSync(marker);
+    if (!exists) return 'cleared';
+    const age = markerAgeMs(root, now);
+    if (holdDecision({ markerExists: true, markerAgeMs: age, capMs }) === 'proceed') return 'capped';
+    // also cap on wall-elapsed-since-entry, so a marker with a future/odd mtime still can't hang us.
+    if (now() - started >= capMs) return 'capped';
+    wait();
+    if (!sleep) return 'capped'; // no real waiter injected → don't spin; proceed.
+  }
+}
+
 function main() {
   let consumed = '';
   try {
@@ -74,6 +140,14 @@ function main() {
   const root = findInstallRoot();
   if (!root) emit({});
 
+  // Hold for an in-flight SessionEnd synth (auto-memory-03) so a back-to-back /clear resumes on the
+  // FRESH baton, bounded by the crash safety-cap. Fail-open: any fault here must not block orientation.
+  try {
+    holdForHandoff({ root, sleep: sleepMs });
+  } catch {
+    /* never block the session opening on the hold */
+  }
+
   const parts = [identityLine(root)];
 
   const baton = readBaton(root);
@@ -91,8 +165,12 @@ function main() {
   });
 }
 
-try {
-  main();
-} catch {
-  emit({}); // fail-open: never block a session opening
+if (require.main === module) {
+  try {
+    main();
+  } catch {
+    emit({}); // fail-open: never block a session opening
+  }
 }
+
+module.exports = { holdDecision, holdForHandoff };

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

@@ -287,9 +287,8 @@ function handoffDirective(consumed, pct, hasDebt) {
     '[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.',
+    '  2. Tell the operator to /clear and open a fresh session. No manual step: the continuity baton writes automatically when this session ends (the memory synth) and injects on resume.',
+    '  Suggestion (optional): the session also auto-consolidates its durable learnings into wiki memory on close (auto-dream); to consolidate explicitly or mid-session, invoke the dream skill — a suggestion only, never required.',
   ];
   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.');

package/payload/.claude/settings.json

@@ -7,6 +7,13 @@
         ]
       }
     ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          { "type": "command", "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/memory-synth-spawn.cjs\"" }
+        ]
+      }
+    ],
     "UserPromptSubmit": [
       {
         "hooks": [

package/payload/.claude/skills/dream/SKILL.md

@@ -162,40 +162,11 @@ recalls them automatically next session. Spot-check with a wiki query:
 node .wrxn/wiki.cjs query "<a phrase from a page you just wrote>"
 ```
 
-## Refreshing the focus slot
-
-`_slots/current-focus.md` is the project's **durable standing focus** — a short statement of what the
-project is centered on right now, recall-surfaced like any other page. It is the **lone updatable wiki
-page**: every knowledge page is additive + dedup-skip, but the focus slot may be **overwritten in
-place**.
-
-This is **not** the knowledge-proposal loop — do not run a focus update through `check` / `stage` /
-`commit` (those are for evidence-backed concept/decision/gotcha/rule pages). The slot has its **own op**:
-
-1. Draft a short standing-focus statement (a few lines of markdown, body starting with `# `).
-2. **Present it to the operator and wait for confirmation** — like every dream write.
-3. On approval, write it via the dedicated op — it overwrites the slot in place:
-
-```bash
-node .wrxn/dream.cjs set-focus /tmp/dream-focus.json   # { "title": "Current focus", "body": "# Current focus\n\n…" }
-```
-
-The focus slot is **gated** too: `set-focus` runs the anti-superstition negative filters and the
-credential secret-scan over the focus body and **refuses** (writing nothing) if either fires. Redact
-secrets and pin durable standing context, not a transient note.
-
-**Continuity doctrine — do not cross these wires.** The focus slot is **disjoint** from the handoff
-**baton** (`.wrxn/continuity/latest.md`): different path, different writer. `set-focus` NEVER reads or
-writes the baton, and the **handoff** skill remains its sole writer. The baton is ephemeral cross-session
-resume; the focus slot is durable standing context. Keeping their paths and writers separate is the
-structural fix that stops a deliberate handoff from being clobbered.
-
 ## Boundaries
 
 - **Current session only.** No transcript mining, no cross-session backlog.
-- **Additive only, save one slot.** dream creates net-new knowledge pages; merging or refreshing an
-  existing page is out of scope (that is harvest, a later phase). The **lone exception** is the focus
-  slot `_slots/current-focus.md`, which `set-focus` overwrites in place (see *Refreshing the focus slot*).
+- **Additive only.** dream creates net-new knowledge pages; merging or refreshing an existing page is
+  out of scope (that is harvest, a later phase).
 - **Never autonomous.** dream is a deliberate, attended, operator-confirmed skill — never a background
   run, never a write without confirmation.
 - **`_rules` ≠ SYNAPSE.** A `rule` page is *recalled knowledge* — the Brain surfaces it like a concept

package/payload/.claude/skills/synapse/SKILL.md

@@ -62,9 +62,10 @@ marker records what was dropped. One budget, applied flat. See
 
 When real consumed context reaches the handoff threshold (`HANDOFF_PCT`, default 0.40; override
 `WRXN_HANDOFF_PCT`) of the model window, SYNAPSE appends a **non-blocking** `[HANDOFF REQUIRED]`
-directive: finish the current request, run the handoff skill to write the baton, then `/clear` and
-resume in a fresh session. It never refuses work. The math runs on real token usage (resident tokens
-from the transcript ÷ the resolved model window), not an assumed window. See
+directive: finish the current request, then `/clear` and resume in a fresh session — the continuity
+baton writes automatically on session end (the memory synth) and injects on resume, so there is no
+manual step. It never refuses work. The math runs on real token usage (resident tokens from the
+transcript ÷ the resolved model window), not an assumed window. See
 [token budget & handoff](references/brackets.md).
 
 ## Output shape
@@ -89,8 +90,7 @@ Article I — Agent Authority (NON-NEGOTIABLE)
 [HANDOFF REQUIRED]
   Context is at ~42% of the model window (>= the 40% 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.
+  2. Tell the operator to /clear and open a fresh session. No manual step: the continuity baton writes automatically when this session ends (the memory synth) and injects on resume.
 
 </synapse-rules>
 ```

package/payload/.claude/skills/synapse/references/brackets.md

@@ -30,8 +30,7 @@ When the real consumed context reaches the handoff threshold, SYNAPSE appends a
 [HANDOFF REQUIRED]
   Context is at ~42% of the model window (>= the 40% 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.
+  2. Tell the operator to /clear and open a fresh session. No manual step: the continuity baton writes automatically when this session ends (the memory synth) and injects on resume.
 ```
 
 Like the constitution, the handoff directive is outside the budget — it is never trimmed.

package/payload/.claude/skills/synapse/references/layers.md

@@ -79,8 +79,7 @@ Article I — Agent Authority (NON-NEGOTIABLE)
 [HANDOFF REQUIRED]
   Context is at ~42% of the model window (>= the 40% 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.
+  2. Tell the operator to /clear and open a fresh session. No manual step: the continuity baton writes automatically when this session ends (the memory synth) and injects on resume.
 
 </synapse-rules>
 ```