@gcunharodrigues/wrxn 0.1.0 → 0.2.0

package/bin/wrxn.cjs

@@ -3,6 +3,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 const { init } = require('../lib/install.cjs');
 const { update } = require('../lib/update.cjs');
@@ -10,6 +11,7 @@ const worktree = require('../lib/worktree.cjs');
 const executor = require('../lib/executor.cjs');
 const onboard = require('../lib/onboard.cjs');
 const connect = require('../lib/connect.cjs');
+const statusline = require('../lib/statusline.cjs');
 
 const PKG_ROOT = path.join(__dirname, '..');
 
@@ -103,6 +105,13 @@ Usage:
       list                       print all registered connections (agent-readable JSON)
       get <name>                 print one connection by name
 
+  wrxn statusline [--inject [--path <script>]]
+                                 SYNAPSE live-window writer. With no flag: report whether a statusline
+                                 is configured (~/.claude/settings.json) + print the marker-bounded
+                                 sidecar block + how to enable. With --inject: append the block to the
+                                 resolved (or --path) statusline script, idempotently (append-only,
+                                 never overwrites). init NEVER touches your statusline.
+
   wrxn onboard [--root <dir>]    scaffold the Day-1 operator file set under context/ from a filled
                                  aios-intake.md (the deterministic half of the onboard skill;
                                  workspace installs only). Idempotent.
@@ -148,10 +157,19 @@ function main(argv) {
     for (const f of report.skipped) {
       process.stdout.write(`  skipped [${f.class}] ${f.path} (${f.collision ? 'collision — existing file preserved' : 'exists'})\n`);
     }
-    process.stdout.write(`${report.laid.length} laid, ${report.skipped.length} unchanged.\n`);
+    for (const f of report.merged || []) {
+      process.stdout.write(`  merged  [${f.class}] ${f.path} (recon-wrxn server added to your existing config)\n`);
+    }
+    process.stdout.write(`${report.laid.length} laid, ${report.skipped.length} unchanged${report.merged && report.merged.length ? `, ${report.merged.length} merged` : ''}.\n`);
     if (report.brownfield) {
       process.stdout.write(`brownfield install — ${report.collisions.length} existing file(s) preserved (never overwritten): ${report.collisions.map((c) => c.path).join(', ')}\n`);
     }
+    if (report.adoptHint) {
+      process.stdout.write(`${report.adoptHint}\n`);
+    }
+    if (report.statuslineHint) {
+      process.stdout.write(`${report.statuslineHint}\n`);
+    }
     return 0;
   }
 
@@ -335,6 +353,46 @@ function main(argv) {
     }
   }
 
+  if (cmd === 'statusline') {
+    const home = process.env.HOME || os.homedir();
+    const detection = statusline.detectStatusLine(home);
+
+    // --inject: append the sidecar block to the resolved (or --path) statusline script, idempotently.
+    if (args.flags.inject) {
+      const target = args.flags.path || detection.scriptPath;
+      if (!target) {
+        process.stderr.write('wrxn: no statusline script to inject into — pass --path <script>, or configure statusLine in ~/.claude/settings.json first\n');
+        return 2;
+      }
+      try {
+        const r = statusline.injectSnippet(target);
+        process.stdout.write(r.injected
+          ? `wrxn sidecar appended to ${r.path}\n`
+          : `wrxn sidecar already present in ${r.path} — no change\n`);
+        return 0;
+      } catch (err) {
+        process.stderr.write(`wrxn: ${err.message}\n`);
+        return 2;
+      }
+    }
+
+    // Default: report detection + print the snippet + how to enable.
+    if (detection.configured) {
+      process.stdout.write(`statusline detected: ${detection.command}\n`);
+      process.stdout.write(detection.scriptPath
+        ? `  script: ${detection.scriptPath}\n`
+        : '  (not a bash <path> command — cannot auto-resolve a script to inject into)\n');
+    } else {
+      process.stdout.write('no statusline configured in ~/.claude/settings.json\n');
+    }
+    process.stdout.write('\nThe SYNAPSE live-window block (host statusline must read stdin into $input and set $session_id):\n\n');
+    process.stdout.write(statusline.snippet() + '\n');
+    process.stdout.write(detection.scriptPath
+      ? `Enable: wrxn statusline --inject   (appends idempotently to ${detection.scriptPath})\n`
+      : 'Enable: wrxn statusline --inject --path <your-statusline-script>\n');
+    return 0;
+  }
+
   process.stderr.write(`wrxn: unknown command "${cmd}"\n\n${USAGE}\n`);
   return 2;
 }

package/lib/install.cjs

@@ -4,8 +4,10 @@ const fs = require('fs');
 const path = require('path');
 
 const { loadManifest, inProfile } = require('./manifest.cjs');
+const { STATUSLINE_HINT } = require('./statusline.cjs');
 
 const RECEIPT = 'wrxn.install.json';
+const MCP_PATH = '.mcp.json';
 
 /**
  * Lay the kernel payload into a target root, governed by the file-class manifest.
@@ -33,8 +35,13 @@ function init(opts) {
 
   const laid = [];
   const skipped = [];
+  const merged = [];
 
   const version = packageVersion(pkgRoot);
+  // Did the target hold project content BEFORE we laid anything? Drives the adopt-hint: a non-empty
+  // repo has existing code worth priming the recon-wrxn index over now (.git and our own receipt
+  // don't count). Captured up front so a re-init's own laid files don't read as "pre-existing".
+  const wasNonEmpty = dirHasContent(target);
   // What a PRIOR wrxn install laid here — used to tell a re-init skip (wrxn's own file) apart from a
   // BROWNFIELD collision (a pre-existing PROJECT file that happens to clash with a payload path).
   const priorPaths = priorReceiptPaths(target);
@@ -55,6 +62,14 @@ function init(opts) {
       // A collision = the file existed but was NOT laid by a prior wrxn install (it is the operator's
       // own pre-existing project file). A re-init skip of wrxn's own file is `exists`, not a collision.
       const collision = !priorPaths.has(entry.path);
+      // .mcp.json is the one payload file we MERGE rather than preserve on a brownfield collision: the
+      // operator's other MCP servers must survive while gaining the recon-wrxn server. A re-init
+      // (not a collision) is left as a plain `exists` skip. A malformed operator file is preserved
+      // untouched (we never clobber or crash) and reported as an ordinary collision.
+      if (entry.path === MCP_PATH && collision && mergeMcpServer(src, dest)) {
+        merged.push({ path: entry.path, class: entry.class });
+        continue;
+      }
       skipped.push({ path: entry.path, class: entry.class, reason: collision ? 'collision' : 'exists', collision });
       continue;
     }
@@ -67,9 +82,65 @@ function init(opts) {
   const collisions = skipped.filter((s) => s.collision);
   const brownfield = collisions.length > 0;
 
-  writeReceipt(target, { version, profile, laid, skipped, brownfield });
+  // recon-wrxn writes its index into a fixed `.recon-wrxn/` dir — keep it out of version control.
+  ensureGitignoreLine(target, '.recon-wrxn/');
 
-  return { profile, laid, skipped, collisions, brownfield, receipt: path.join(target, RECEIPT) };
+  writeReceipt(target, { version, profile, laid, skipped, merged, brownfield });
+
+  // No synchronous index here (AC-5): `recon-wrxn serve` auto-indexes lazily on first use. On a
+  // non-empty repo we only HINT that the operator can prime it now with `recon-wrxn index`.
+  const adoptHint = wasNonEmpty
+    ? 'recon-wrxn indexes lazily on first use — run `recon-wrxn index` to prime it over your existing code now.'
+    : null;
+
+  // init NEVER touches a statusline (that would risk overwriting the operator's). It only surfaces
+  // the opt-in path so installs discover the SYNAPSE live-window writer.
+  return { profile, laid, skipped, merged, collisions, brownfield, adoptHint, statuslineHint: STATUSLINE_HINT, receipt: path.join(target, RECEIPT) };
+}
+
+/** Does the target hold content other than `.git` and wrxn's own receipt? (Missing dir → empty.) */
+function dirHasContent(target) {
+  let entries;
+  try {
+    entries = fs.readdirSync(target);
+  } catch {
+    return false;
+  }
+  return entries.some((e) => e !== '.git' && e !== RECEIPT);
+}
+
+/** Append `line` to `<target>/.gitignore` (create if absent), exactly once — idempotent. */
+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');
+}
+
+/**
+ * Merge the recon-wrxn server key from the payload `.mcp.json` into an operator's existing one.
+ * Returns true on a successful merge, false when the operator file is not parseable JSON (in which
+ * case the caller preserves it untouched — wrxn never clobbers or crashes on a hand-written config).
+ */
+function mergeMcpServer(src, dest) {
+  let operator;
+  try {
+    operator = JSON.parse(fs.readFileSync(dest, 'utf8'));
+  } catch {
+    return false; // unparseable operator file → preserve as a plain collision, don't merge
+  }
+  if (!operator || typeof operator !== 'object') return false;
+  const payload = JSON.parse(fs.readFileSync(src, 'utf8'));
+  operator.mcpServers = operator.mcpServers || {};
+  operator.mcpServers['recon-wrxn'] = payload.mcpServers['recon-wrxn'];
+  fs.writeFileSync(dest, JSON.stringify(operator, null, 2) + '\n');
+  return true;
 }
 
 /** Paths a prior wrxn install recorded in the receipt (empty when there is no prior install). */
@@ -97,9 +168,9 @@ function writeReceipt(target, data) {
   existing.kernelVersion = data.version;
   existing.profile = data.profile;
   existing.brownfield = !!data.brownfield;
-  existing.files = [...data.laid, ...data.skipped].map((f) => ({ path: f.path, class: f.class }));
-  existing.installs.push({ laidCount: data.laid.length, skippedCount: data.skipped.length });
+  existing.files = [...data.laid, ...data.skipped, ...(data.merged || [])].map((f) => ({ path: f.path, class: f.class }));
+  existing.installs.push({ laidCount: data.laid.length, skippedCount: data.skipped.length, mergedCount: (data.merged || []).length });
   fs.writeFileSync(receiptPath, JSON.stringify(existing, null, 2) + '\n');
 }
 
-module.exports = { init, RECEIPT, packageVersion };
+module.exports = { init, RECEIPT, MCP_PATH, packageVersion, mergeMcpServer };

package/lib/statusline.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// The sidecar block is marker-bounded so injection is idempotent: the START marker's presence in a
+// host statusline means the block is already there. The canonical text lives in the managed payload
+// doc (single source of truth) — snippet() extracts the marker region from it, so the doc and the
+// injected block can never drift.
+const MARKER_START = '# >>> wrxn sidecar >>>';
+const MARKER_END = '# <<< wrxn sidecar <<<';
+
+// The one-line adopt-hint `wrxn init` surfaces. init must NEVER modify a statusline; it only points
+// the operator at the opt-in command.
+const STATUSLINE_HINT = 'SYNAPSE live-window: run `wrxn statusline` to enable';
+
+// The canonical doc inside the package payload (ships in dev and in the installed package alike).
+const DOC_PATH = path.join(__dirname, '..', 'payload', 'docs', 'statusline-sidecar.sh');
+
+/** The marker-bounded sidecar block, extracted from the canonical payload doc. */
+function snippet(docPath) {
+  const text = fs.readFileSync(docPath || DOC_PATH, 'utf8');
+  const start = text.indexOf(MARKER_START);
+  const end = text.indexOf(MARKER_END);
+  if (start < 0 || end < 0 || end < start) {
+    throw new Error('statusline doc is missing its sidecar markers');
+  }
+  return text.slice(start, end + MARKER_END.length) + '\n';
+}
+
+/**
+ * Resolve the statusline script path from a settings `statusLine.command`.
+ * Returns a path for a bare `<path>` or a `bash <path>` / `sh <path>` command; null for any other
+ * shape (an inline command, a node script, a multi-token bare command) — we only auto-inject into a
+ * shell script we can unambiguously identify.
+ */
+function resolveScriptPath(command, home) {
+  const parts = command.split(/\s+/).filter(Boolean);
+  let candidate = null;
+  if ((parts[0] === 'bash' || parts[0] === 'sh') && parts.length === 2) {
+    candidate = parts[1];
+  } else if (parts.length === 1) {
+    candidate = parts[0];
+  } else {
+    return null;
+  }
+  if (candidate.startsWith('~/')) candidate = path.join(home, candidate.slice(2));
+  return candidate;
+}
+
+/**
+ * Inspect `<home>/.claude/settings.json` for a configured statusline.
+ * @returns {{ configured: boolean, command: string|null, scriptPath: string|null }}
+ */
+function detectStatusLine(home) {
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(path.join(home, '.claude', 'settings.json'), 'utf8'));
+  } catch {
+    return { configured: false, command: null, scriptPath: null };
+  }
+  const sl = settings && settings.statusLine;
+  const command = sl && typeof sl.command === 'string' && sl.command.trim() ? sl.command.trim() : null;
+  if (!command) return { configured: false, command: null, scriptPath: null };
+  return { configured: true, command, scriptPath: resolveScriptPath(command, home) };
+}
+
+/**
+ * Append the sidecar block to an existing statusline script — APPEND-ONLY and idempotent.
+ * No-op if the marker is already present; never rewrites or reorders existing content. The script
+ * must already exist (we never conjure a statusline — that would risk shadowing the operator's own).
+ * @returns {{ injected: boolean, reason?: string, path: string }}
+ */
+function injectSnippet(scriptPath, docPath) {
+  if (!scriptPath) throw new Error('injectSnippet requires a script path');
+  if (!fs.existsSync(scriptPath)) {
+    throw new Error(`statusline script not found: ${scriptPath} — create it (or configure a statusline) first`);
+  }
+  const current = fs.readFileSync(scriptPath, 'utf8');
+  if (current.includes(MARKER_START)) {
+    return { injected: false, reason: 'already-present', path: scriptPath };
+  }
+  const sep = current.length && !current.endsWith('\n') ? '\n' : '';
+  fs.appendFileSync(scriptPath, `${sep}\n${snippet(docPath)}`);
+  return { injected: true, path: scriptPath };
+}
+
+module.exports = {
+  snippet,
+  detectStatusLine,
+  injectSnippet,
+  resolveScriptPath,
+  MARKER_START,
+  MARKER_END,
+  STATUSLINE_HINT,
+  DOC_PATH,
+};

package/lib/update.cjs

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 
 const { loadManifest, inProfile } = require('./manifest.cjs');
-const { RECEIPT, packageVersion } = require('./install.cjs');
+const { RECEIPT, MCP_PATH, packageVersion, mergeMcpServer } = require('./install.cjs');
 const { compareVersions } = require('./semver.cjs');
 const { runMigrations } = require('./migrate.cjs');
 
@@ -49,8 +49,20 @@ function update(opts) {
     }
 
     if (entry.class === 'managed') {
-      lay(src, dest);
-      updated.push({ path: entry.path, class: entry.class });
+      // .mcp.json is managed but operator-shared: an update MUST NOT clobber the operator's other MCP
+      // servers (finding N2). When the dest already exists, MERGE just the recon-wrxn key in (same
+      // contract as init). A malformed operator file can't be merged → preserve it untouched (never
+      // crash, never clobber a hand-written config); an absent dest falls through to a plain lay.
+      if (entry.path === MCP_PATH && fs.existsSync(dest)) {
+        if (mergeMcpServer(src, dest)) {
+          updated.push({ path: entry.path, class: entry.class, merged: true });
+        } else {
+          preserved.push({ path: entry.path, class: entry.class, reason: 'unparseable-preserved' });
+        }
+      } else {
+        lay(src, dest);
+        updated.push({ path: entry.path, class: entry.class });
+      }
     } else if (!fs.existsSync(dest)) {
       // seeded/state that did not exist in the prior version → lay it once now
       lay(src, dest);

package/manifest.json

@@ -359,7 +359,12 @@
       "profile": "workspace"
     },
     {
-      "path": ".recon.json",
+      "path": ".mcp.json",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".recon-wrxn.json",
       "class": "seeded",
       "profile": "project"
     },
@@ -438,6 +443,11 @@
       "class": "seeded",
       "profile": "project"
     },
+    {
+      "path": "docs/statusline-sidecar.sh",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": "docs/workspace/operator-layer.md",
       "class": "seeded",

package/migrations/001-recon-to-recon-wrxn.cjs

@@ -0,0 +1,79 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * R4 — rebrand an existing install from the legacy `recon` to `recon-wrxn`, in place, preserving the
+ * costly index (recon-wrxn-04). The ENTIRE migration is gated on the legacy `.recon/` index dir: a
+ * fresh (or already-migrated) install has no `.recon/`, so this is a complete no-op — which also makes
+ * it idempotent (a second run sees `.recon/` already renamed away). Runs via `wrxn update` once the
+ * install reaches 0.2.0; the file-class update has already laid the rebranded payload before this runs.
+ */
+module.exports = {
+  id: '001',
+  version: '0.2.0',
+  up(ctx) {
+    const target = ctx.target;
+    const legacyDir = path.join(target, '.recon');
+    if (!fs.existsSync(legacyDir)) return; // gate: no legacy index → nothing to migrate
+
+    // 1. Rename the index dir, preserving the index (storage format unchanged per R1). If the new dir
+    //    already exists (operator ran recon-wrxn before updating), it is authoritative — discard the
+    //    legacy `.recon/` rather than leave it behind: it is a disposable cache that would otherwise
+    //    linger no-longer-gitignored, and this run-once migration would never reclaim it.
+    const newDir = path.join(target, '.recon-wrxn');
+    if (!fs.existsSync(newDir)) {
+      fs.renameSync(legacyDir, newDir);
+    } else {
+      fs.rmSync(legacyDir, { recursive: true, force: true });
+    }
+
+    // 2. Rename the config (content unchanged — the operator's recon config carries over). The seeded
+    //    `.recon-wrxn.json` template laid by `wrxn update` is overwritten so the operator's content wins.
+    const legacyCfg = path.join(target, '.recon.json');
+    if (fs.existsSync(legacyCfg)) {
+      fs.renameSync(legacyCfg, path.join(target, '.recon-wrxn.json'));
+    }
+
+    // 3. Drop the stale `recon` server key from .mcp.json (the `recon-wrxn` server was already merged in
+    //    by `wrxn update`). Only touch a file that exists and parses; never crash on a malformed config,
+    //    never remove any other server key.
+    const mcpPath = path.join(target, '.mcp.json');
+    if (fs.existsSync(mcpPath)) {
+      let mcp = null;
+      try {
+        mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
+      } catch {
+        mcp = null; // malformed operator config → leave it alone
+      }
+      if (mcp && mcp.mcpServers && Object.prototype.hasOwnProperty.call(mcp.mcpServers, 'recon')) {
+        delete mcp.mcpServers.recon;
+        fs.writeFileSync(mcpPath, JSON.stringify(mcp, null, 2) + '\n');
+      }
+    }
+
+    // 4. .gitignore: replace the stale `.recon/` line(s) with a single `.recon-wrxn/`; drop any extra
+    //    stale lines and never emit a duplicate (whether `.recon-wrxn/` pre-existed or `.recon/` repeats).
+    const giPath = path.join(target, '.gitignore');
+    if (fs.existsSync(giPath)) {
+      const lines = fs.readFileSync(giPath, 'utf8').split('\n');
+      let haveNew = lines.some((l) => l.trim() === '.recon-wrxn/');
+      const out = [];
+      for (const l of lines) {
+        if (l.trim() === '.recon/') {
+          if (!haveNew) { out.push('.recon-wrxn/'); haveNew = true; }
+        } else {
+          out.push(l);
+        }
+      }
+      fs.writeFileSync(giPath, out.join('\n'));
+    }
+
+    // 5. Remove the vendored legacy recon (superseded by the npm dependency; only WRXN-OS has it).
+    const vendor = path.join(target, 'vendor', 'recon-aiox');
+    if (fs.existsSync(vendor)) {
+      fs.rmSync(vendor, { recursive: true, force: true });
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcunharodrigues/wrxn",
-  "version": "0.1.0",
+  "version": "0.2.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"
@@ -15,6 +15,9 @@
   "scripts": {
     "test": "node --test"
   },
+  "dependencies": {
+    "recon-wrxn": "6.0.0-wrxn.1"
+  },
   "engines": {
     "node": ">=20"
   },

package/payload/.claude/hooks/code-intel-push.cjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 'use strict';
 
-// WRXN code-intel-push hook — first-touch code-intel / recon-freshness nudge (wrxn-kernel-11).
+// WRXN code-intel-push hook — first-touch code-intel / recon-wrxn-freshness nudge (wrxn-kernel-11).
 // PostToolUse (Edit|Write). On the FIRST touch of a code file this session it injects a <code-intel>
-// nudge: where a recon graph exists it notes freshness (commit lag) and points at recon; absent a
-// graph it nudges to build one. First-touch-GATED per session+file (a touched-list under
+// nudge: where a recon-wrxn index exists it points at the mcp__recon-wrxn__* tools; absent an index
+// it nudges to prime one. First-touch-GATED per session+file (a touched-list under
 // .wrxn/history/<sid>.touched) so a repeat edit of the same file is silent — no per-edit spam.
 //
 // Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
@@ -60,13 +60,14 @@ function isFirstTouch(root, sid, relPath) {
   }
 }
 
-// A short freshness note: stale (or unknown) when the recon graph's commit doesn't prefix-match HEAD.
+// A short freshness note pointing at the recon-wrxn MCP server (mcp__recon-wrxn__* tools), whose
+// index lives in the fixed `.recon-wrxn/` dir and auto-builds lazily on first query.
 function freshnessNote(root) {
-  const graph = path.join(root, '.recon', 'graph.json');
-  if (!fs.existsSync(graph)) {
-    return 'No recon graph (.recon/graph.json absent) — build it for code-connection enrichment, then reindex.';
+  const indexDir = path.join(root, '.recon-wrxn');
+  if (!fs.existsSync(indexDir)) {
+    return 'No recon-wrxn index (.recon-wrxn/ absent) — query via the mcp__recon-wrxn__* tools to auto-index, or run `recon-wrxn index` to prime it now.';
   }
-  return 'recon graph present — reindex if it lags your edits (the graph is rebuilt at session close).';
+  return 'recon-wrxn index present (.recon-wrxn/) — query code connections via the mcp__recon-wrxn__* tools; it re-indexes live as you edit.';
 }
 
 function main() {

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

@@ -179,26 +179,49 @@ function readResidentTokens(transcriptPath) {
   }
 }
 
-// Model context window, resolved by an explicit precedence (issue 29). On [1m] sessions
-// lastModelUsage is often EMPTY and the transcript model id lacks the [1m] tag — there is no
-// reliable auto-signal — so the window must be settable explicitly rather than guessed:
-//   1. env WRXN_CONTEXT_WINDOW — a positive finite number wins unconditionally.
-//   2. manifest CONTEXT_WINDOW — a positive finite value (when manifestText is supplied).
-//   3. ~/.claude.json lastModelUsage KEYS — a [1m] tag ⇒ 1,000,000 (auto-detect, when present).
-//   4. fallback 200,000.
-// homeDir/manifestText overrides keep it testable.
-function modelWindow(cwd, homeDir, manifestText) {
+// The LIVE window for a session, published by the statusline. UserPromptSubmit hooks receive no
+// model/context-window data, but the statusline payload carries context_window.context_window_size
+// (resolved by Claude Code, refreshed every render — so it tracks a mid-session /model switch). The
+// statusline writes it to a session-scoped /tmp sidecar; we read it back here by session_id.
+// See statusline.sh and memory `handoff-window-defaults-200k`. Returns a positive number or null.
+function readStatuslineWindow(sessionId) {
+  if (!sessionId) return null;
+  try {
+    const p = path.join(os.tmpdir(), `claude-statusline-ctx-${sessionId}.json`);
+    const o = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const w = Number(o && o.context_window_size);
+    return Number.isFinite(w) && w > 0 ? w : null;
+  } catch {
+    return null;
+  }
+}
+
+// Model context window, resolved by an explicit precedence (issue 29 + dynamic statusline bridge).
+// On [1m] sessions lastModelUsage is often EMPTY and the transcript model id lacks the [1m] tag, and
+// the hook payload carries no model — so we lean on the statusline (which DOES know the live window):
+//   1. env WRXN_CONTEXT_WINDOW — a positive finite number wins unconditionally (manual force).
+//   2. statusline sidecar — the live per-session window; tracks mid-session model switches.
+//   3. manifest CONTEXT_WINDOW — a positive finite value (when manifestText is supplied).
+//   4. ~/.claude.json lastModelUsage KEYS — a [1m] tag ⇒ 1,000,000 (auto-detect, when present).
+//   5. self-correcting net — resident already past the 200k default ⇒ window is necessarily larger.
+//   6. fallback 200,000.
+// homeDir/manifestText/sessionId/resident overrides keep it testable.
+function modelWindow(cwd, homeDir, manifestText, sessionId, resident) {
   // 1. explicit env override.
   const envWin = Number(process.env.WRXN_CONTEXT_WINDOW);
   if (Number.isFinite(envWin) && envWin > 0) return envWin;
 
-  // 2. manifest CONTEXT_WINDOW (the engine already reads scalar manifest values).
+  // 2. statusline sidecar — the live, authoritative window (dynamic across /model switches).
+  const scWin = readStatuslineWindow(sessionId);
+  if (scWin) return scWin;
+
+  // 3. manifest CONTEXT_WINDOW (the engine already reads scalar manifest values).
   if (manifestText != null) {
     const manWin = Number(manifestValue(manifestText, 'CONTEXT_WINDOW'));
     if (Number.isFinite(manWin) && manWin > 0) return manWin;
   }
 
-  // 3. lastModelUsage [1m] auto-detect.
+  // 4. lastModelUsage [1m] auto-detect.
   try {
     const home = homeDir || process.env.HOME || os.homedir();
     const cfg = JSON.parse(fs.readFileSync(path.join(home, '.claude.json'), 'utf8'));
@@ -206,10 +229,13 @@ function modelWindow(cwd, homeDir, manifestText) {
     const keys = Object.keys(proj.lastModelUsage || {});
     if (keys.some((k) => /\[1m\]/i.test(k))) return 1000000;
   } catch {
-    // fall through to the default.
+    // fall through.
   }
 
-  // 4. fallback.
+  // 5. self-correcting net: resident past the 200k default ⇒ a larger (1M) window.
+  if (Number.isFinite(resident) && resident > 200000) return 1000000;
+
+  // 6. fallback.
   return 200000;
 }
 
@@ -295,7 +321,7 @@ function compose(root, event) {
   if (ev.transcript_path) {
     const resident = readResidentTokens(ev.transcript_path);
     if (resident != null) {
-      const window = modelWindow(ev.cwd || root, process.env.HOME || os.homedir(), manifestText);
+      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));
@@ -345,6 +371,7 @@ module.exports = {
   compose,
   findInstallRoot,
   readResidentTokens,
+  readStatuslineWindow,
   modelWindow,
   resolveHandoffPct,
   handoffDirective,

package/payload/.mcp.json

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

package/payload/.recon-wrxn.json

@@ -0,0 +1,6 @@
+{
+  "projects": [],
+  "embeddings": false,
+  "watch": true,
+  "ignore": []
+}

package/payload/docs/statusline-sidecar.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# WRXN SYNAPSE statusline sidecar — the live context-window writer.
+#
+# Why: UserPromptSubmit hooks (where SYNAPSE runs) receive no model/context-window data, so the
+# handoff math cannot tell a 200k session from a 1M one. The statusline IS handed the live window
+# (context_window.context_window_size) on stdin every render — so we publish it to a session-scoped
+# temp file that the synapse-engine hook reads back (readStatuslineWindow → .context_window_size).
+# The temp dir MUST match the reader's os.tmpdir() — both honor $TMPDIR, falling back to /tmp.
+#
+# How to enable: paste the marker-bounded block below into your Claude Code statusline script, OR run
+#   wrxn statusline --inject [--path <your-statusline-script>]
+# which appends it idempotently. It NEVER overwrites your statusline — append-only, marker-guarded.
+#
+# Assumptions the block makes about the host statusline:
+#   - $input        the raw statusline stdin JSON (most statuslines do `input=$(cat)` at the top).
+#   - $session_id   the session id (e.g. `session_id=$(echo "$input" | jq -r '.session_id')`).
+# If your statusline lacks these, set them above the block. The block fails safe regardless: the write
+# is guarded by `2>/dev/null || true`, so a missing tool or var can never break your statusline render.
+
+# >>> wrxn sidecar >>>
+# UserPromptSubmit hooks receive NO model/context-window data, so SYNAPSE's handoff math can't tell
+# a 200k session from a 1M one. Publish the live window to a session-scoped file the hook reads.
+# Refreshed every render → tracks a mid-session /model switch.
+if [[ -n "$session_id" ]]; then
+    cw_size=$(echo "$input" | jq -r '.context_window.context_window_size // empty')
+    [[ -z "$cw_size" || "$cw_size" == "null" ]] && { [[ "$(echo "$input" | jq -r '.model.id // ""')" == *"[1m]"* ]] && cw_size=1000000 || cw_size=200000; }
+    printf '{"context_window_size":%s,"model_id":"%s"}\n' "$cw_size" "$(echo "$input" | jq -r '.model.id // ""')" \
+        > "${TMPDIR:-/tmp}/claude-statusline-ctx-${session_id}.json" 2>/dev/null || true
+fi
+# <<< wrxn sidecar <<<

package/payload/.recon.json

@@ -1,3 +0,0 @@
-{
-  "ignore": ["node_modules", ".git", ".wrxn/wiki", "vendor"]
-}