@gcunharodrigues/wrxn 0.2.0 → 0.3.0

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/ingest/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: ingest
+description: Distill a dropped source file (PDF/DOCX/HTML/PPTX/XLSX/TXT) into curated memory-wiki pages — a summary page + N note pages, each linked back to the raw source. Use when an operator drops a file in .wrxn/raw/ (or names one) and says "ingest this", "distill this document", or "turn this source into wiki notes".
+user-invocable: true
+---
+
+# ingest — read → distill → split into notes
+
+The distillation half of `wrxn ingest <file>`. Turns a raw source into compounding wiki knowledge,
+following the Karpathy LLM-wiki pattern (Adler's *How to Read a Book*: read → distill → split into
+notes). This is built as the first concrete slice of the Phase-3 `dream` ingest.
+
+The work is **split** (the kernel executor pattern):
+
+- **The harness is deterministic** (`lib/ingest.cjs` → `wrxn ingest`): convert the source to markdown,
+  place/keep the raw under `.wrxn/raw/`, write the pages you produce with a `derived_from:` provenance
+  stamp, and enforce the **additive-only** guard. You do NOT re-implement any of that.
+- **You are the distillation step.** You read the converted markdown and produce the *content* — a
+  summary page + N note pages. Your job is the curation quality.
+
+## Scope (PRD decision E)
+
+- **Inspectional + analytical depth**: 1 source → **1 summary page + N note pages**. Divide the source
+  into its natural documents (sections / themes), one note page each.
+- **Additive-only.** You CREATE new pages. You never edit an existing wiki page and never synthesise
+  across sources — that is the `dream` loop, out of scope. The harness refuses to overwrite, so a slug
+  that collides with an existing page is silently skipped: choose fresh, source-specific slugs.
+
+## Loop
+
+1. **Convert.** Read the converted markdown — either run `wrxn convert <file>` and read its output, or
+   read what the harness converted. Do not parse the binary yourself.
+2. **Read for the gist.** One pass for the whole; identify the source's structure and its key claims.
+3. **Summary page.** One page capturing what the source IS and its main points — the inspectional read.
+4. **Note pages.** One page per distinct theme/section — the analytical read. Each note is
+   self-contained and titled by its idea, not "Section 3".
+5. **Emit the result** as the structured object below and hand it to the harness.
+
+## Result contract
+
+The harness consumes this exact shape (the CLI accepts it via `--distillation <result.json>`):
+
+```json
+{
+  "summary": { "slug": "paper-summary", "title": "...", "description": "one line", "body": "markdown" },
+  "notes": [
+    { "slug": "paper-method",  "title": "...", "description": "one line", "body": "markdown" },
+    { "slug": "paper-results", "title": "...", "description": "one line", "body": "markdown" }
+  ]
+}
+```
+
+- `slug` — kebab-case (`[a-z0-9-]`), unique, source-specific (prefix with the source name to avoid
+  collisions). The harness rejects a non-kebab slug.
+- `summary` is required (`{slug, body}` minimum); `notes` is an array (≥1 in practice).
+- `tier` is optional per page (default `concepts`; may be `concepts|decisions|gotchas|sessions`).
+- The harness adds the `derived_from: .wrxn/raw/<file>` stamp, `role`, and `source: wrxn-ingest`
+  frontmatter — you do not write frontmatter into `body`.
+
+## Run
+
+```bash
+# the harness does convert → raw placement → provenance stamp → additive write:
+wrxn ingest .wrxn/raw/paper.pdf --distillation result.json
+```
+
+Re-running on the same source is safe — existing pages are skipped, never clobbered.
+
+## Source
+
+WRXN Kernel issue multiformat-distill-06 (PRD decisions D + E). Harness: `lib/ingest.cjs`.
+Converter: `lib/convert.cjs` (slice 05). Wiki: `.wrxn/wiki/` (see the `memory` skill).

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.