@gcunharodrigues/wrxn 0.1.0 → 0.2.1

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