@gcunharodrigues/wrxn 0.2.0 → 0.2.1

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/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.2.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"

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/enforce-push-authority.cjs

@@ -2,9 +2,10 @@
 'use strict';
 
 // WRXN managed hook — Constitution Article I (Agent Authority).
-// PreToolUse:Bash gate: a remote git op (push / PR / tag push) is allowed only when
-// the session declares the devops role via WRXN_ACTIVE_AGENT=devops. A bare push runs
-// as @unknown and is denied. Fails OPEN on any internal error (never over-blocks).
+// PreToolUse:Bash gate: a remote git op (push / PR / tag push) is a deliberate act, 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 .claude/settings.local.json;
+// an unconfirmed op is denied. Fails OPEN on any internal error (never over-blocks).
 //
 // Contract: reads a PreToolUse hook event as JSON on stdin, writes a decision to stdout.
 //   allow → {} (exit 0)
@@ -33,13 +34,13 @@ function main() {
   }
 
   if (process.env.WRXN_ACTIVE_AGENT === 'devops') {
-    return emit({}); // authorized
+    return emit({}); // confirmed
   }
 
   return emit({
     decision: 'block',
     reason:
-      'Remote git op is devops-exclusive (Constitution Art. I). Re-run with WRXN_ACTIVE_AGENT=devops, or delegate to the devops role.',
+      'Remote git ops (push / PR / tag) are held behind a deliberate-push confirmation flag, to prevent an accidental push. To confirm intent, set WRXN_ACTIVE_AGENT=devops in .claude/settings.local.json (machine-local), then retry.',
   });
 }
 

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

@@ -1,21 +1,30 @@
 #!/usr/bin/env node
 'use strict';
 
-// WRXN session-end hook — the episodic writer (wrxn-kernel-10).
+// WRXN session-end hook — the episodic writer + session janitor (wrxn-kernel-10, foundation-honesty-02).
 // SessionEnd. Writes a dated session page into the install's own wiki sessions tier from the
-// captured turn trail, then clears the trail. CONTINUITY DOCTRINE: this writer touches ONLY
-// dated session pages — it NEVER writes the continuity baton (.wrxn/continuity/latest.md).
-// That slot has a single writer (the handoff skill); keeping the paths disjoint is the
-// structural fix for the clobber observed live 2026-06-12.
+// captured turn trail, then reaps the session's scratch state. Hygiene (foundation-honesty-02):
+//   - skip-empty: a session that captured no turns writes NO page;
+//   - reap: the consumed trail AND the first-touch marker (.wrxn/history/<sid>.touched, written by
+//     code-intel-push) are removed so .wrxn/history/ can't grow without bound;
+//   - bound: the sessions tier is capped (WRXN_SESSIONS_MAX, default 50) — oldest pages rotate out.
+// CONTINUITY DOCTRINE: this writer touches ONLY the sessions tier + the session's own history
+// scratch — it NEVER writes OR deletes the continuity baton (.wrxn/continuity/latest.md). That slot
+// has a single writer (the handoff skill); keeping the paths disjoint is the structural fix for the
+// clobber observed live 2026-06-12.
 //
 // Self-contained: ships into installs, MUST NOT import the kernel lib (node stdlib only).
 // Fail-open + side-effect-only: emits nothing useful, never blocks; any fault exits 0 silently.
 //
-// Contract: SessionEnd event JSON on stdin → exit 0. Side effect: a sessions/<date>-<sid>.md page.
+// Contract: SessionEnd event JSON on stdin → exit 0. Side effect: a sessions/<date>-<sid>.md page
+// for a non-empty session, plus reaping of that session's trail + touched marker.
 
 const fs = require('fs');
 const path = require('path');
 
+// Bound the sessions tier to the most-recent N pages (override: WRXN_SESSIONS_MAX).
+const DEFAULT_SESSIONS_MAX = 50;
+
 function done() {
   process.exit(0);
 }
@@ -64,6 +73,32 @@ function readTrail(root, sid) {
   return { turns, trail };
 }
 
+// Best-effort removal — `force` ignores a missing file; any other fault is swallowed (fail-open).
+function rmQuiet(p) {
+  try {
+    fs.rmSync(p, { force: true });
+  } catch {
+    /* best-effort cleanup, never block session close */
+  }
+}
+
+// Bound the sessions tier: keep at most `max` most-recent dated pages, reaping the oldest. Dated
+// `YYYY-MM-DD-…` slugs sort chronologically, so the oldest are the lexicographically-first ones.
+// Cap = WRXN_SESSIONS_MAX (env) or DEFAULT_SESSIONS_MAX. Self-contained: never throws.
+function capSessions(dir) {
+  const max = Number(process.env.WRXN_SESSIONS_MAX) || DEFAULT_SESSIONS_MAX;
+  if (!Number.isFinite(max) || max <= 0) return;
+  let pages;
+  try {
+    pages = fs.readdirSync(dir).filter((f) => /^\d{4}-\d{2}-\d{2}-.+\.md$/.test(f)).sort();
+  } catch {
+    return;
+  }
+  for (let i = 0; i < pages.length - max; i++) {
+    rmQuiet(path.join(dir, pages[i]));
+  }
+}
+
 function main() {
   let event = {};
   try {
@@ -76,52 +111,57 @@ function main() {
   const root = findInstallRoot();
   if (!root) done();
 
-  const sid = oneLine(event.session_id || 'session');
-  const reason = oneLine(event.reason || 'unknown');
-  const date = nowISO().slice(0, 10); // YYYY-MM-DD
-  const slug = `${date}-${safeId(event.session_id)}`;
-
   const { turns, trail } = readTrail(root, event.session_id);
-  const trailLines = turns.length
-    ? turns.map((t, i) => {
-        const tab = t.indexOf('\t');
-        const line = tab > -1 ? t.slice(tab + 1) : t;
-        return `${i + 1}. ${line}`;
-      })
-    : ['_(no turns captured)_'];
-
-  const page = [
-    '---',
-    `name: ${slug}`,
-    `description: Session ${sid} — ${turns.length} turn(s), ended ${reason}`,
-    'tier: sessions',
-    'source: session-end-hook',
-    '---',
-    '',
-    `# Session ${date} (${sid})`,
-    '',
-    `- Ended: ${reason}`,
-    `- Turns: ${turns.length}`,
-    '',
-    '## Turn trail',
-    ...trailLines,
-    '',
-  ].join('\n');
-
-  const dir = path.join(root, '.wrxn', 'wiki', 'sessions');
-  try {
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, `${slug}.md`), page);
-    // Consume the trail so the next session starts clean.
+
+  // Skip-empty: a session that captured no turns leaves NO page — the first half of bounding the
+  // sessions tier. Only write the page (and only then consume its trail) when there is activity.
+  if (turns.length) {
+    const sid = oneLine(event.session_id || 'session');
+    const reason = oneLine(event.reason || 'unknown');
+    const date = nowISO().slice(0, 10); // YYYY-MM-DD
+    const slug = `${date}-${safeId(event.session_id)}`;
+
+    const trailLines = turns.map((t, i) => {
+      const tab = t.indexOf('\t');
+      const line = tab > -1 ? t.slice(tab + 1) : t;
+      return `${i + 1}. ${line}`;
+    });
+
+    const page = [
+      '---',
+      `name: ${slug}`,
+      `description: Session ${sid} — ${turns.length} turn(s), ended ${reason}`,
+      'tier: sessions',
+      'source: session-end-hook',
+      '---',
+      '',
+      `# Session ${date} (${sid})`,
+      '',
+      `- Ended: ${reason}`,
+      `- Turns: ${turns.length}`,
+      '',
+      '## Turn trail',
+      ...trailLines,
+      '',
+    ].join('\n');
+
+    const dir = path.join(root, '.wrxn', 'wiki', 'sessions');
     try {
-      fs.rmSync(trail, { force: true });
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, `${slug}.md`), page);
+      rmQuiet(trail);     // consume the trail only after its page has landed
+      capSessions(dir);   // rotation: bound the sessions tier (reap the oldest beyond the cap)
     } catch {
-      /* trail cleanup is best-effort */
+      /* page write failed → fail-open; leave the trail intact for no-loss */
     }
-  } catch {
-    /* page write failed → fail-open, never block session close */
+  } else {
+    rmQuiet(trail);       // empty session: nothing to write; drop any stray empty trail file
   }
 
+  // The first-touch gate marker (written by code-intel-push) is pure per-session scratch — always
+  // reap it so .wrxn/history/ can't grow without bound. NEVER touches the continuity baton.
+  rmQuiet(path.join(root, '.wrxn', 'history', `${safeId(event.session_id)}.touched`));
+
   done();
 }
 

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

@@ -1,132 +1,133 @@
 ---
 name: synapse
-description: "This skill should be used when users want to understand the SYNAPSE context engine, manage domains, configure context rules, or troubleshoot rule injection. Use when asked about SYNAPSE architecture, domain management, star-commands, context brackets, or the 8-layer processing pipeline."
+description: "Use when someone wants to understand the SYNAPSE context engine, manage its rule domains, tune the token budget or handoff threshold, or troubleshoot why a rule did or didn't inject. Covers the real engine: the three layers (constitution / always-on / keyword-recall), the flat token budget, and the non-blocking handoff directive."
 ---
 
-# SYNAPSE Context Engine
+# SYNAPSE context engine
 
-## Overview
+## What it is
 
-SYNAPSE (Synkra Adaptive Processing & State Engine) is the unified context engine for AIOX. It injects contextual rules into every prompt via an 8-layer processing pipeline, adapting to context window usage through bracket-aware filtering.
+SYNAPSE is the per-prompt context-injection engine. On every `UserPromptSubmit` it assembles the
+install's active rule domains into a single `<synapse-rules>` block and returns it as
+`additionalContext`, so each prompt carries the constitution plus the operational rules that apply.
 
-**What it does:**
-- Injects rules per-prompt via Claude Code's `UserPromptSubmit` hook
-- Processes 8 layers (L0 Constitution through L7 Star-Commands) sequentially
-- Adapts injection volume based on context brackets (FRESH/MODERATE/DEPLETED/CRITICAL)
-- Integrates with agent state (active agent, workflow, task, squad)
-- Outputs `<synapse-rules>` XML block appended to each prompt
+It is one self-contained hook — `.claude/hooks/synapse-engine.cjs` — that ships into an install and
+reads only the install's own files (`.claude/constitution.md`, the `.synapse/` domains, and the
+`wrxn.install.json` receipt that marks the install root). It imports nothing from the kernel package.
+It is **fail-open**: any fault (unparseable input, missing file, assembly error) emits an empty
+envelope and injects nothing — the engine never blocks a prompt.
 
-**What it replaces:** SYNAPSE replaces the legacy CARL system with full feature parity plus 8 new capabilities including agent-scoped domains, workflow activation, and CRUD management commands.
+## The three layers
 
-**Architecture model:** Open Core — the 8-layer engine lives in `aiox-core` (open source), memory integration is feature-gated in `aiox-pro`.
+SYNAPSE assembles each prompt from three layers, in this order:
 
-## Quick Start
+| Layer | Source | Fires |
+|-------|--------|-------|
+| **L0 — Constitution** | `.claude/constitution.md` | Always. Never trimmed by the budget. |
+| **L1 — Always-on domains** | `.synapse/<domain>` where `<DOMAIN>_ALWAYS_ON=true` | Every prompt. (Seeded: `global`, `pipeline`.) |
+| **L6 — Keyword-recall domains** | `.synapse/<domain>` with a `<DOMAIN>_RECALL=word,...` list | Only when a trigger word appears in the prompt. (Seeded: `routing`.) |
 
-### Verify SYNAPSE is Active
+The constitution is rendered from `constitution.md` (article headings + their bullets) and sits
+outside the token budget — it is always kept. Every other active domain contributes a numbered rules
+section. See [the layer model](references/layers.md).
 
-SYNAPSE runs automatically via the Claude Code hook. To check status:
+## How a domain is defined
 
-```
-*synapse status
-```
+Domains are registered in `.synapse/manifest` (flat `KEY=VALUE`) and their rules live in a sibling
+file `.synapse/<domain>` (lowercased) as `<DOMAIN>_RULE_<N>=text` lines:
 
-This shows: active domains, current bracket, session info, and loaded layers.
+```
+# .synapse/manifest
+GLOBAL_STATE=active
+GLOBAL_ALWAYS_ON=true
 
-### Basic Commands
+# .synapse/global
+GLOBAL_RULE_0=git push, PR creation, and release tags are deliberate acts held behind a confirmation flag (anti-accidental-push) — `devops` is a dispatch-phase label, not an authority.
+GLOBAL_RULE_1=The unit of work is an issue with explicit acceptance criteria.
+```
 
-| Command | What it does |
-|---------|-------------|
-| `*synapse status` | Show current engine state |
-| `*synapse domains` | List all registered domains |
-| `*synapse debug` | Show detailed debug info (manifest parse, load times, rule counts) |
-| `*synapse help` | Show all available synapse commands |
-| `*brief` | Switch to brief response mode |
-| `*dev` | Switch to developer mode (code-focused) |
-| `*review` | Switch to code review mode |
+A domain loads only when `<DOMAIN>_STATE=active`. An always-on domain sets `_ALWAYS_ON=true`; a
+keyword domain sets `_RECALL=word1,word2`. See [the manifest format](references/manifest.md) and
+[domains & rule files](references/domains.md).
 
-### Create a Custom Domain
+## The token budget
 
-```
-*synapse create
-```
+Everything except the constitution is trimmable. A single flat budget (`RULES_BUDGET_TOKENS`,
+default 600; override `WRXN_RULES_BUDGET`) caps the trimmable sections; when the assembled rules
+exceed it, whole sections are dropped lowest-priority-first and a visible `[SYNAPSE-RULES-TRIM]`
+marker records what was dropped. One budget, applied flat. See
+[token budget & handoff](references/brackets.md).
 
-This walks you through creating a new domain file + manifest entry. See [references/domains.md](references/domains.md) for the full domain guide.
+## The handoff directive
 
-## Architecture
+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
+[token budget & handoff](references/brackets.md).
 
-SYNAPSE operates as a 4-layer architecture:
+## Output shape
 
 ```
-.claude/hooks/synapse-engine.js          # Layer 1: Hook Entry (~50 lines)
-        |
-        v imports
-.aiox-core/core/synapse/                 # Layer 2: Engine Modules
-|-- engine.js                            #   SynapseEngine class
-|-- layers/                              #   8 layer processors (L0-L7)
-|-- session/session-manager.js           #   Session state (JSON v2.0)
-|-- domain/domain-loader.js              #   Manifest + domain parser
-|-- context/context-tracker.js           #   Bracket calculation
-|-- memory/memory-bridge.js              #   Pro-gated MIS consumer
-|-- output/formatter.js                  #   <synapse-rules> XML
-        |
-        v reads/writes
-.synapse/                                # Layer 3: Runtime Data
-|-- manifest                             #   Central domain registry (KEY=VALUE)
-|-- constitution, global, context        #   Core domains (L0, L1)
-|-- agent-*, workflow-*                  #   Scoped domains (L2, L3)
-|-- commands                             #   Star-command definitions (L7)
-|-- sessions/, cache/                    #   Session state (gitignored)
-        |
-        v user-invoked
-.claude/commands/synapse/                # Layer 4: CRUD Commands + Skill Docs
-|-- manager.md                           #   Router/dispatcher
-|-- tasks/ (6 tasks)                     #   create, add, edit, toggle, command, suggest
-```
+<synapse-rules>
 
-**Key principle:** SYNAPSE is a **consumer** of existing systems (UAP for session state, MIS for memories). It never rewrites code from other epics.
+[CONSTITUTION] (NON-NEGOTIABLE)
+Article I — Agent Authority (NON-NEGOTIABLE)
+  git push, PR creation, and release tags are deliberate acts held behind a confirmation flag (anti-accidental-push) — `devops` is a dispatch-phase label, not an authority.
+  ...
 
-## References
+[GLOBAL]
+  1. git push, PR creation, and release tags are deliberate acts held behind a confirmation flag ...
+  2. The unit of work is an issue with explicit acceptance criteria ...
 
-### Reference Guides
+[RECALL: routing]
+  1. git push, PR creation, and release tags are deliberate acts held behind a confirmation flag ...
 
-| Guide | Description |
-|-------|-------------|
-| [domains.md](references/domains.md) | Domain types (L0-L7), KEY=VALUE format, creation guide |
-| [commands.md](references/commands.md) | Star-commands, *synapse sub-commands, CRUD operations |
-| [manifest.md](references/manifest.md) | Manifest format specification, all valid keys |
-| [brackets.md](references/brackets.md) | Context bracket system, token budgets, layer activation |
-| [layers.md](references/layers.md) | 8-layer processor architecture, priority, conflict resolution |
+[SYNAPSE-RULES-TRIM] ROUTING dropped over the 600-token rules budget
 
-### Assets (Templates)
+[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.
 
-Templates for creating custom domains and manifest entries are maintained at:
+</synapse-rules>
+```
 
-- **Domain template:** `.claude/commands/synapse/templates/domain-template`
-- **Manifest entry template:** `.claude/commands/synapse/templates/manifest-entry-template`
+The trim marker appears only when a section was dropped; the handoff directive only at/above the
+threshold. When no domains are active the engine injects nothing.
 
-See [assets/README.md](assets/README.md) for details.
+## Configuration
 
-### CRUD Commands
+| Knob | Where | Effect |
+|------|-------|--------|
+| `RULES_BUDGET_TOKENS` | `.synapse/manifest` | Trimmable-rules token ceiling (default 600). |
+| `HANDOFF_PCT` | `.synapse/manifest` | Handoff threshold as a window fraction (default 0.40). |
+| `CONTEXT_WINDOW` | `.synapse/manifest` | Pin the model window (tokens) for the handoff math. |
+| `WRXN_RULES_BUDGET` | env | Overrides `RULES_BUDGET_TOKENS`. |
+| `WRXN_HANDOFF_PCT` | env | Overrides `HANDOFF_PCT`. |
+| `WRXN_CONTEXT_WINDOW` | env | Forces the model window unconditionally. |
 
-For domain management operations, use the SYNAPSE manager:
+See [invocation & configuration](references/commands.md).
 
-| Command | Purpose |
-|---------|---------|
-| `*synapse create` | Create new domain + manifest entry |
-| `*synapse add` | Add rule to existing domain |
-| `*synapse edit` | Edit or remove rule by index |
-| `*synapse toggle` | Toggle domain active/inactive |
-| `*synapse command` | Create new star-command |
-| `*synapse suggest` | Suggest best domain for a rule |
+## References
 
-Full details: [references/commands.md](references/commands.md)
+| Guide | Covers |
+|-------|--------|
+| [The layer model](references/layers.md) | the L0/L1/L6 assembly, ordering, constitution rendering, output format |
+| [The manifest format](references/manifest.md) | the `.synapse/manifest` keys and scalars |
+| [Domains & rule files](references/domains.md) | the seeded domains, the `RULE_N` format, adding a domain |
+| [Token budget & handoff](references/brackets.md) | the flat budget governor + the non-blocking handoff |
+| [Invocation & configuration](references/commands.md) | how the hook is wired, the env/manifest knobs, troubleshooting |
+| [Templates](assets/README.md) | domain-file and manifest-entry templates |
 
-## Key Files
+## Key files
 
 | File | Purpose |
 |------|---------|
-| `.claude/hooks/synapse-engine.js` | Hook entry point (UserPromptSubmit) |
-| `.aiox-core/core/synapse/engine.js` | SynapseEngine orchestrator |
-| `.synapse/manifest` | Domain registry (KEY=VALUE) |
-| `.synapse/commands` | Star-command definitions |
-| `.claude/commands/synapse/manager.md` | CRUD command router |
+| `.claude/hooks/synapse-engine.cjs` | The engine (UserPromptSubmit hook). |
+| `.claude/constitution.md` | L0 source — the non-negotiable articles. |
+| `.synapse/manifest` | Domain registry + budget/handoff scalars. |
+| `.synapse/global`, `.synapse/pipeline` | Seeded always-on (L1) domains. |
+| `.synapse/routing` | Seeded keyword-recall (L6) domain. |

package/payload/.claude/skills/synapse/assets/README.md

@@ -1,50 +1,34 @@
-# SYNAPSE Assets
+# SYNAPSE templates
 
-Templates for creating custom SYNAPSE domains and manifest entries.
+Templates for adding a SYNAPSE domain by hand. There is no interactive creator — a domain is two
+edits: a rule file in `.synapse/` and a registry entry in `.synapse/manifest`. See
+[domains & rule files](../references/domains.md) and [the manifest format](../references/manifest.md).
 
-## Templates Location
-
-Templates are maintained as the single source of truth in the CRUD commands directory:
-
-| Template | Location |
-|----------|----------|
-| **Domain template** | `.claude/commands/synapse/templates/domain-template` |
-| **Manifest entry template** | `.claude/commands/synapse/templates/manifest-entry-template` |
-
-These templates are used by the `*synapse create` command to scaffold new domains.
-
-## Usage
-
-To create a new domain using these templates, run:
+## Domain rule file — `.synapse/<name>`
 
 ```
-*synapse create
+# Domain: <name> (<always-on L1 | keyword-recall L6>) — <one-line description>
+<NAME>_RULE_0=<first rule>
+<NAME>_RULE_1=<second rule>
 ```
 
-Or reference the templates directly when creating domains manually.
+`<NAME>` is the uppercase prefix; the file is named for its lowercase form. Rules are numbered
+ascending from 0.
 
-## Template Formats
+## Manifest entry — `.synapse/manifest`
 
-### Domain Template
+Always-on (loads on every prompt):
 
 ```
-# ==========================================
-# SYNAPSE Domain: {DOMAIN_NAME}
-# Created: {CURRENT_DATE}
-# Description: {DESCRIPTION}
-# ==========================================
-
-# Rules
-{DOMAIN_KEY}_RULE_0={FIRST_RULE}
+<NAME>_STATE=active
+<NAME>_ALWAYS_ON=true
 ```
 
-### Manifest Entry Template
+Keyword-recall (loads only when a trigger word appears in the prompt):
 
 ```
-# Layer 6: {domain-name}
-{DOMAIN_KEY}_STATE=active
-{DOMAIN_KEY}_RECALL={KEYWORDS}
-{DOMAIN_KEY}_EXCLUDE=
+<NAME>_STATE=active
+<NAME>_RECALL=word1,word2
 ```
 
-For the complete KEY=VALUE format specification, see [../references/manifest.md](../references/manifest.md).
+Set `<NAME>_STATE=inactive` (or remove the entry) to stop loading the domain.