@gcunharodrigues/wrxn 0.1.0 → 0.2.1

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/executor.cjs

@@ -80,7 +80,7 @@ const EXECUTORS = {
     instructions: [
       'You are the devops integration executor — the ONLY executor authorized to push. Integrate the',
       'reviewed + security-passed + qa-walked track to the trunk: verify the review marker (review-<id>.md)',
-      '+ a green suite exist, THEN push (AIOX_ACTIVE_AGENT=devops). This is the single path through the push gate.',
+      '+ a green suite exist, then authorize the push by setting WRXN_ACTIVE_AGENT to devops under the `env` key of .claude/settings.local.json (an inline command-scoped assignment never reaches the gate hook), push, then REMOVE WRXN_ACTIVE_AGENT from .claude/settings.local.json — a persistent flag defeats the anti-accidental-push gate. This is the single path through the push gate.',
     ],
     artifact: 'authorized-push',
     canPush: true,

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/migrations/002-seeded-honesty.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 002 — seeded-file honesty migration (foundation-honesty-06).
+ *
+ * Managed payload reaches existing installs on `wrxn update`, but SEEDED files are never overwritten
+ * (operator-owned) — so two artifacts seeded before 0.2.1 keep their stale wording forever unless a
+ * migration corrects them:
+ *   - .synapse/routing's ROUTING_RULE_0 still asserts a fictional "devops role" authority.
+ *   - docs/agents/domain.md still points at the deleted CONTEXT-MAP.md context.
+ * Each file is rewritten in place ONLY while it still carries its known-stale marker, so an operator
+ * who already customized it (or whose install is already honest) is never clobbered. The two branches
+ * are independent and neither ever crashes on a missing file.
+ *
+ * The honest content is EMBEDDED below as frozen 0.2.1 constants: a migration is a historical
+ * transform of the 0.2.1 release, not a re-read of the evolving template (ctx carries no pkgRoot, by
+ * design). Idempotency falls out of the gate — after the rewrite the stale markers ("devops role",
+ * "CONTEXT-MAP.md") are gone, so a second run is a no-op. Runs via `wrxn update` once the install
+ * reaches 0.2.1.
+ */
+
+// The honest ROUTING_RULE_0 — mirrors the seeded `.synapse/routing` template (issue 04 confirmation-
+// gate wording, minus the constitution citation the managed `global` GLOBAL_RULE_0 carries).
+const HONEST_ROUTING_RULE_0 =
+  'ROUTING_RULE_0=git push, PR creation, and release tags are deliberate acts held behind a confirmation flag (anti-accidental-push) — they run only once the session sets WRXN_ACTIVE_AGENT=devops in .claude/settings.local.json; `devops` is a dispatch-phase label, not an authority.';
+
+// The honest domain glossary — frozen verbatim from the post-issue-05 payload docs/agents/domain.md.
+const HONEST_DOMAIN_MD = `# Domain Docs
+
+How the engineering skills should consume this repo's domain documentation when exploring the codebase.
+
+## Before exploring, read these
+
+- **\`CONTEXT.md\`** at the repo root — the domain glossary, the canonical vocabulary for this project.
+- **\`docs/adr/\`** — Architecture Decision Records. Read the ADRs that touch the area you're about to work in.
+
+If either doesn't exist yet, **proceed silently**. Don't flag its absence; don't suggest creating it upfront. The producer skill (\`grill-with-docs\`) creates them lazily — \`CONTEXT.md\` when the first term is resolved, an ADR when a hard-to-reverse decision is actually made.
+
+## File structure
+
+A fresh install ships neither file. They appear at the repo root as the project's language and decisions accumulate:
+
+\`\`\`
+/
+├── CONTEXT.md        ← domain glossary (created lazily by grill-with-docs)
+└── docs/
+    └── adr/          ← one file per decision, named NNNN-<slug>.md
+\`\`\`
+
+## Use the glossary's vocabulary
+
+When your output names a domain concept (in an issue title, a refactor proposal, a hypothesis, a test name), use the term as defined in \`CONTEXT.md\`. Don't drift to synonyms the glossary explicitly avoids.
+
+If the concept you need isn't in the glossary yet, that's a signal — either you're inventing language the project doesn't use (reconsider) or there's a real gap (note it for \`grill-with-docs\`).
+
+## Flag ADR conflicts
+
+If your output contradicts an existing ADR, surface it explicitly rather than silently overriding:
+
+> _Contradicts ADR-0007 — but worth reopening because…_
+`;
+
+module.exports = {
+  id: '002',
+  version: '0.2.1',
+  up(ctx) {
+    const target = ctx.target;
+
+    // 1. routing: replace ONLY a ROUTING_RULE_0 line still carrying the stale "devops role" authority
+    //    wording. Comments and any operator-added ROUTING_RULE_N lines are preserved verbatim; the
+    //    split/join round-trip keeps the trailing newline. No stale line → routing left untouched.
+    const routingPath = path.join(target, '.synapse', 'routing');
+    if (fs.existsSync(routingPath)) {
+      const lines = fs.readFileSync(routingPath, 'utf8').split('\n');
+      let changed = false;
+      const out = lines.map((line) => {
+        if (line.startsWith('ROUTING_RULE_0=') && line.includes('devops role')) {
+          changed = true;
+          return HONEST_ROUTING_RULE_0;
+        }
+        return line;
+      });
+      if (changed) fs.writeFileSync(routingPath, out.join('\n'));
+    }
+
+    // 2. domain.md: overwrite the whole glossary with the honest content ONLY while it still names the
+    //    deleted CONTEXT-MAP.md context. An honest or operator-customized file (marker absent) is left
+    //    untouched. Missing file → nothing to do.
+    const domainPath = path.join(target, 'docs', 'agents', 'domain.md');
+    if (fs.existsSync(domainPath)) {
+      const body = fs.readFileSync(domainPath, 'utf8');
+      if (body.includes('CONTEXT-MAP.md')) {
+        fs.writeFileSync(domainPath, HONEST_DOMAIN_MD);
+      }
+    }
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcunharodrigues/wrxn",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "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/constitution.md

@@ -5,7 +5,10 @@ Project-local preferences live in the seeded `constitution.local.md` addendum, n
 
 ## Article I — Agent Authority (NON-NEGOTIABLE)
 
-- `git push`, PR creation, and release tags are EXCLUSIVE to the devops role.
+- `git push`, PR creation, and release tags are deliberate acts, held behind a
+  confirmation flag to prevent an accidental push: the op proceeds only once the session
+  confirms intent by setting `WRXN_ACTIVE_AGENT=devops` in the machine-local
+  `.claude/settings.local.json`. `devops` here is a dispatch-phase label, not an authority grant.
 - An agent acts only within its scope; it delegates when out of scope and never assumes
   another agent's authority.
 

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() {