aiox-core 5.0.7 → 5.0.8

package/.claude/commands/synapse/tasks/create-domain.md

@@ -0,0 +1,127 @@
+# Create Domain
+
+Creates a new SYNAPSE domain file and registers it in the manifest.
+
+---
+
+## Purpose
+
+Create a new custom domain in `.synapse/` with a corresponding entry in `.synapse/manifest`, allowing users to add their own rule sets to the SYNAPSE context engine.
+
+---
+
+## Prerequisites
+
+- `.synapse/manifest` exists
+- `.synapse/` directory exists
+- User provides a domain name
+
+---
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `domain-name` | Yes | Name for the new domain (kebab-case, lowercase) |
+| `description` | No | Short description of the domain's purpose |
+| `recall-keywords` | No | Comma-separated RECALL keywords for L6 matching |
+| `exclude-keywords` | No | Comma-separated EXCLUDE keywords |
+| `initial-rules` | No | One or more initial rules to include |
+
+---
+
+## Steps
+
+### Step 1: Validate Domain Name
+
+- Domain name MUST be lowercase kebab-case (e.g., `my-custom-rules`)
+- Allowed characters: `a-z`, `0-9`, `-`
+- Must NOT start or end with `-`
+- Must NOT be empty
+
+If invalid, report: `Error: Domain name must be lowercase kebab-case (e.g., "my-custom-rules"). Got: "{name}"`
+
+### Step 2: Derive Domain Key
+
+Convert the kebab-case name to UPPERCASE_SNAKE_CASE for use in manifest and domain file:
+- `my-custom-rules` -> `MY_CUSTOM_RULES`
+
+### Step 3: Check Uniqueness
+
+Read `.synapse/manifest` and check if `{DOMAIN_KEY}_STATE` already exists.
+
+If it exists, report: `Error: Domain "{domain-name}" already exists in the manifest. Use "add" to add rules to it instead.`
+
+Check if file `.synapse/{domain-name}` already exists on the filesystem.
+
+If it exists, report: `Error: Domain file ".synapse/{domain-name}" already exists on disk.`
+
+### Step 4: Create Domain File
+
+Create `.synapse/{domain-name}` using the template from `.claude/commands/synapse/templates/domain-template`:
+
+```ini
+# ==========================================
+# SYNAPSE Domain: {DOMAIN_NAME}
+# Created: {CURRENT_DATE}
+# Description: {DESCRIPTION}
+# ==========================================
+
+# Rules
+{DOMAIN_KEY}_RULE_0={FIRST_RULE_OR_PLACEHOLDER}
+```
+
+- Replace `{DOMAIN_NAME}` with the domain display name (e.g., `My Custom Rules`)
+- Replace `{DOMAIN_KEY}` with the UPPERCASE_SNAKE_CASE key
+- Replace `{DATE}` with current date (YYYY-MM-DD)
+- Replace `{DESCRIPTION}` with user-provided description or `Custom domain`
+- If user provided initial rules, add them as `{DOMAIN_KEY}_RULE_0`, `_RULE_1`, etc.
+- If no initial rules, use a placeholder: `{DOMAIN_KEY}_RULE_0=Add your first rule here`
+
+### Step 5: Add Manifest Entry
+
+Append to `.synapse/manifest` using the template from `.claude/commands/synapse/templates/manifest-entry-template`:
+
+```ini
+
+# Layer 6: {domain-name}
+{DOMAIN_KEY}_STATE=active
+{DOMAIN_KEY}_RECALL={recall-keywords-or-empty}
+{DOMAIN_KEY}_EXCLUDE={exclude-keywords-or-empty}
+```
+
+- Add a blank line before the new entry for readability
+- If no RECALL keywords provided, use domain name words as defaults
+- EXCLUDE is empty by default
+
+### Step 6: Validate
+
+- Read back the manifest and verify `{DOMAIN_KEY}_STATE=active` is present
+- Read back the domain file and verify it parses correctly (has at least one rule line)
+
+---
+
+## Validation
+
+- [ ] Domain file created at `.synapse/{domain-name}`
+- [ ] Manifest entry added with `_STATE=active`
+- [ ] Domain name is valid kebab-case
+- [ ] No duplicate domain in manifest or filesystem
+- [ ] Domain file follows KEY=VALUE format parseable by SYN-1
+
+---
+
+## Error Handling
+
+| Error | Message |
+|-------|---------|
+| Invalid name | `Error: Domain name must be lowercase kebab-case (e.g., "my-custom-rules"). Got: "{name}"` |
+| Domain exists (manifest) | `Error: Domain "{name}" already exists in the manifest. Use "add" to add rules to it instead.` |
+| Domain exists (file) | `Error: Domain file ".synapse/{name}" already exists on disk.` |
+| Manifest not found | `Error: .synapse/manifest not found. SYNAPSE must be initialized first (SYN-8).` |
+| Write failure | `Error: Failed to write domain file. Check filesystem permissions.` |
+
+---
+
+*Create Domain — SYNAPSE CRUD Command C2*
+*Source: SYNAPSE-HOOK-SKILL-COMMAND-ANALYSIS.md section 2.3*

package/.claude/commands/synapse/tasks/diagnose-synapse.md

@@ -0,0 +1,245 @@
+# SYNAPSE Diagnostics Task
+
+Run a comprehensive diagnostic of the SYNAPSE context engine, comparing expected vs. actual pipeline state, including **session performance analysis** with exact timing data.
+
+## Instructions
+
+Execute the following steps in order:
+
+### Step 1: Run Diagnostics Script
+
+```bash
+node -e "const {runDiagnostics}=require('./.aiox-core/core/synapse/diagnostics/synapse-diagnostics');console.log(runDiagnostics(process.cwd()))"
+```
+
+### Step 2: Display Report
+
+Show the full markdown report output to the user.
+
+### Step 3: Analyze Gaps
+
+If the report contains any FAIL or WARN items:
+1. List each gap with its severity
+2. Provide the recommended fix from the report
+3. Ask the user if they want to apply any fixes
+
+### Step 4: Session Performance Analysis
+
+Run the timing analyzer to get **exact execution data** for this session:
+
+```bash
+node -e "
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LOG_DIR = path.join(os.homedir(), '.claude', 'logs');
+const today = new Date().toISOString().slice(0, 10);
+const logFile = path.join(LOG_DIR, 'timing-' + today + '.jsonl');
+
+if (!fs.existsSync(logFile)) {
+  console.log('NO_TIMING_DATA');
+  process.exit(0);
+}
+
+const lines = fs.readFileSync(logFile, 'utf8').trim().split('\n');
+const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+
+// Group by session
+const sessions = {};
+entries.forEach(e => {
+  if (!sessions[e.session]) sessions[e.session] = [];
+  sessions[e.session].push(e);
+});
+
+// Find the latest session (most likely current)
+const sessionIds = Object.keys(sessions);
+const latestSessionId = sessionIds[sessionIds.length - 1];
+const currentEvents = sessions[latestSessionId] || [];
+
+// Build JSON output for analysis
+const result = {
+  date: today,
+  logFile,
+  totalSessions: sessionIds.length,
+  currentSession: {
+    id: latestSessionId ? latestSessionId.slice(0, 12) : null,
+    totalEntries: currentEvents.length,
+    firstEvent: currentEvents[0] ? currentEvents[0].timestamp : null,
+    lastEvent: currentEvents.length ? currentEvents[currentEvents.length - 1].timestamp : null,
+    wallClockMs: currentEvents.length >= 2
+      ? currentEvents[currentEvents.length - 1].epochMs - currentEvents[0].epochMs
+      : 0,
+    timeline: [],
+    toolSummary: {},
+    gaps: [],
+    totalToolTimeMs: 0,
+    totalThinkingTimeMs: 0,
+  },
+};
+
+// Build timeline
+let prevEpoch = null;
+currentEvents.forEach(e => {
+  const gap = prevEpoch ? e.epochMs - prevEpoch : 0;
+  const item = {
+    time: e.timestamp ? e.timestamp.slice(11, 23) : '',
+    event: e.event === 'PreToolUse' ? 'START' : 'END',
+    tool: e.tool,
+    durationMs: e.durationMs || null,
+    gapMs: gap,
+    input: e.input || null,
+  };
+  result.currentSession.timeline.push(item);
+  prevEpoch = e.epochMs;
+});
+
+// Tool duration summary
+currentEvents.filter(e => e.durationMs).forEach(e => {
+  if (!result.currentSession.toolSummary[e.tool]) {
+    result.currentSession.toolSummary[e.tool] = { calls: 0, totalMs: 0, maxMs: 0, durations: [] };
+  }
+  const ts = result.currentSession.toolSummary[e.tool];
+  ts.calls++;
+  ts.totalMs += e.durationMs;
+  ts.maxMs = Math.max(ts.maxMs, e.durationMs);
+  ts.durations.push(e.durationMs);
+  result.currentSession.totalToolTimeMs += e.durationMs;
+});
+
+// Gap analysis (thinking time between PostToolUse → PreToolUse)
+for (let i = 1; i < currentEvents.length; i++) {
+  if (currentEvents[i].event === 'PreToolUse' && currentEvents[i - 1].event === 'PostToolUse') {
+    const gapMs = currentEvents[i].epochMs - currentEvents[i - 1].epochMs;
+    result.currentSession.gaps.push({
+      from: currentEvents[i - 1].tool,
+      to: currentEvents[i].tool,
+      gapMs,
+    });
+    result.currentSession.totalThinkingTimeMs += gapMs;
+  }
+}
+
+// Sort gaps descending
+result.currentSession.gaps.sort((a, b) => b.gapMs - a.gapMs);
+
+console.log(JSON.stringify(result, null, 2));
+"
+```
+
+### Step 5: Render Performance Report
+
+Using the JSON output from Step 4, present a **Session Performance Report** with these sections:
+
+#### 5a. Session Overview
+
+| Metric | Value |
+|--------|-------|
+| Wall Clock Total | (firstEvent → lastEvent) |
+| Tool Execution Time | sum of all durationMs |
+| Thinking/Processing Time | total gaps between PostToolUse → PreToolUse |
+| Overhead Ratio | thinkingTime / wallClock as % |
+
+#### 5b. Execution Timeline
+
+Show every tool call in chronological order:
+```
+HH:MM:SS.mmm  START  ToolName  — input summary
+HH:MM:SS.mmm  END    ToolName  [Xms]  (+Yms gap)
+```
+
+Highlight any gaps > 5 seconds with a warning marker.
+
+#### 5c. Tool Duration Ranking
+
+Table sorted by total time descending:
+
+| Tool | Calls | Total | Avg | Max |
+|------|-------|-------|-----|-----|
+| ... | | | | |
+
+#### 5d. Largest Thinking Gaps
+
+Show top 10 gaps (PostToolUse → PreToolUse), sorted descending:
+
+| Gap | From → To | Analysis |
+|-----|-----------|----------|
+| Xs | Tool A → Tool B | (explain likely cause) |
+
+For the Analysis column, infer causes:
+- **> 15s gap**: Likely LLM processing large context or generating long response
+- **5-15s gap**: Normal thinking for complex decisions, reading tool output
+- **2-5s gap**: Standard inter-tool processing
+- **< 2s gap**: Fast, healthy
+
+#### 5e. Bottleneck Diagnosis
+
+Based on the data, provide a concrete diagnosis:
+1. What % of total time was spent in tool execution vs thinking?
+2. Which specific tool call or gap was the single largest time consumer?
+3. Actionable recommendations to reduce total time
+
+### Step 6: Handle Missing Timing Data
+
+If Step 4 outputs `NO_TIMING_DATA`:
+1. Inform the user that the timing hooks are not yet capturing data
+2. Explain that timing data requires the `PreToolUse`/`PostToolUse` hooks in `~/.claude/settings.json`
+3. Check if hooks are registered:
+   ```bash
+   node -e "const s=require(require('os').homedir()+'/.claude/settings.json');console.log(JSON.stringify({pre:!!s.hooks?.PreToolUse,post:!!s.hooks?.PostToolUse}))"
+   ```
+4. If hooks are missing, offer to install them
+5. Note: timing data only exists for the **current session onwards** — previous sessions have no retroactive data
+
+### Step 7: Quick Health Summary
+
+Combine SYNAPSE health + Performance into a single status line:
+
+- **Healthy + Fast**: "SYNAPSE 100% | Session: Xs wall, Y% thinking"
+- **Healthy + Slow**: "SYNAPSE 100% | Session: Xs wall, Y% thinking — bottleneck: [detail]"
+- **Degraded**: "SYNAPSE N warnings | Session: Xs wall — [top issue]"
+- **Broken**: "SYNAPSE N critical issues — fix before performance analysis"
+- **No timing**: "SYNAPSE [status] | Timing hooks not active — run next session for data"
+
+## Context
+
+This diagnostic checks:
+1. **Hook Status** - Is the synapse-engine hook registered and functional?
+2. **Session Status** - Does the session have active_agent, prompt_count, bracket?
+3. **Manifest Integrity** - Do all manifest domains have corresponding files?
+4. **Pipeline Simulation** - For the current bracket, which layers should be active?
+5. **UAP Bridge** - Did the UAP write _active-agent.json at activation?
+6. **Memory Bridge** - Is Pro available? Does the bracket require memory hints?
+7. **Gaps & Recommendations** - Prioritized list of issues with fixes
+8. **Session Performance** - Exact timing of every tool call, thinking gaps, bottleneck diagnosis
+
+## When to Use
+
+- After activating an agent, to verify SYNAPSE is injecting the right context
+- When agent-specific rules seem to be missing from responses
+- When debugging context injection issues
+- **When activation or responses feel slow** — timing data pinpoints exactly where time is spent
+- As part of story development for SYNAPSE-related changes
+- Periodically to verify system health
+
+## Dependencies
+
+- **Timing hooks**: `~/.claude/hooks/timing-logger.js` (PreToolUse/PostToolUse)
+- **Timing analyzer**: `~/.claude/hooks/analyze-timing.js` (CLI report)
+- **SYNAPSE diagnostics**: `.aiox-core/core/synapse/diagnostics/synapse-diagnostics.js`
+
+## Quick Commands
+
+```bash
+# Full diagnostic (this skill)
+/synapse:tasks:diagnose-synapse
+
+# Timing report only (CLI)
+node ~/.claude/hooks/analyze-timing.js
+
+# Timing for specific date
+node ~/.claude/hooks/analyze-timing.js 2026-02-17
+
+# Last N entries
+node ~/.claude/hooks/analyze-timing.js --last 50
+```

package/.claude/commands/synapse/tasks/edit-rule.md

@@ -0,0 +1,109 @@
+# Edit Rule
+
+Edits or removes a rule by index in an existing SYNAPSE domain file.
+
+---
+
+## Purpose
+
+Modify the text of an existing rule or delete it entirely, re-numbering remaining rules to maintain a sequential index.
+
+---
+
+## Prerequisites
+
+- `.synapse/manifest` exists
+- Target domain exists in manifest AND as a file in `.synapse/`
+- Target rule index exists in the domain file
+
+---
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `domain-name` | Yes | Existing domain name (kebab-case) |
+| `index` | Yes | Rule index number to edit or remove |
+| `new-text` | No | New rule text (omit to delete the rule) |
+
+---
+
+## Steps
+
+### Step 1: Validate Domain Exists
+
+1. Derive the domain key: `my-domain` -> `MY_DOMAIN`
+2. Verify `{DOMAIN_KEY}_STATE` exists in `.synapse/manifest`
+3. Verify `.synapse/{domain-name}` file exists on disk
+
+### Step 2: Find Target Rule
+
+Read the domain file and find the line matching `{DOMAIN_KEY}_RULE_{index}=`.
+
+If not found: `Error: Rule index {index} not found in domain "{domain-name}". Domain has rules 0-{max}.`
+
+### Step 3: Edit or Delete
+
+**If new-text is provided (EDIT):**
+- Replace the rule line with `{DOMAIN_KEY}_RULE_{index}={new-text}`
+- Display: `Updated rule {index} in {domain-name}: {new-text}`
+
+**If new-text is NOT provided (DELETE):**
+- Remove the rule line from the file
+- Re-number all remaining rules sequentially starting from 0
+- Display: `Deleted rule {index} from {domain-name}. Re-numbered {count} remaining rules.`
+
+### Step 4: Re-Number After Deletion
+
+When a rule is deleted, re-number all remaining rules to maintain a sequential index:
+
+**Before:**
+```
+MY_DOMAIN_RULE_0=First rule
+MY_DOMAIN_RULE_1=Second rule  <-- DELETED
+MY_DOMAIN_RULE_2=Third rule
+```
+
+**After:**
+```
+MY_DOMAIN_RULE_0=First rule
+MY_DOMAIN_RULE_1=Third rule
+```
+
+Algorithm:
+1. Collect all rule values (preserving order, excluding deleted rule)
+2. Rewrite all rules with sequential indices starting from 0
+3. Preserve all non-rule lines (comments, blanks) in their original positions
+
+### Step 5: Validate
+
+- Read back the domain file
+- Verify rules are sequentially numbered (0, 1, 2, ... N) with no gaps
+- Verify total rule count matches expected (original count minus 1 for delete)
+
+---
+
+## Validation
+
+- [ ] Target rule exists before edit/delete
+- [ ] After edit: rule text updated correctly
+- [ ] After delete: remaining rules re-numbered sequentially (no gaps)
+- [ ] Non-rule lines (comments, blanks) preserved
+- [ ] Domain file remains parseable after modification
+
+---
+
+## Error Handling
+
+| Error | Message |
+|-------|---------|
+| Domain not found | `Error: Domain "{name}" not found in manifest.` |
+| Domain file missing | `Error: Domain file ".synapse/{name}" not found on disk.` |
+| Index not found | `Error: Rule index {index} not found in domain "{name}". Domain has rules 0-{max}.` |
+| Negative index | `Error: Rule index must be a non-negative integer.` |
+| Edit with empty text | `Error: New rule text cannot be empty. To delete, omit the new text.` |
+
+---
+
+*Edit Rule — SYNAPSE CRUD Command C4*
+*Source: SYNAPSE-HOOK-SKILL-COMMAND-ANALYSIS.md section 2.3*

package/.claude/commands/synapse/tasks/suggest-domain.md

@@ -0,0 +1,116 @@
+# Suggest Domain
+
+Analyzes a rule and suggests the ideal SYNAPSE domain for it.
+
+---
+
+## Purpose
+
+Help users place rules in the most appropriate domain by analyzing the rule's content, matching it against existing domain keywords, and considering domain purposes.
+
+---
+
+## Prerequisites
+
+- `.synapse/manifest` exists
+- At least one domain exists in `.synapse/`
+
+---
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `rule-text` | Yes | The rule text to analyze |
+
+---
+
+## Steps
+
+### Step 1: Load Existing Domains
+
+Read `.synapse/manifest` and build a list of all domains with their:
+- Domain name and key
+- RECALL keywords (from `{DOMAIN_KEY}_RECALL`)
+- Current state (active/inactive)
+- Rule count (from reading each domain file)
+
+### Step 2: Analyze Rule Content
+
+Examine the rule text for:
+- **Agent references:** mentions of `@dev`, `@qa`, `@architect`, etc. -> suggests agent-specific domain
+- **Workflow references:** mentions of "story", "sprint", "review", "deploy" -> suggests workflow domain
+- **Technical keywords:** "test", "lint", "commit", "branch" -> match against RECALL keywords
+- **Domain-specific terms:** "security", "performance", "accessibility" -> match domain names
+
+### Step 3: Score Domains
+
+For each existing domain, calculate a relevance score:
+
+| Factor | Weight | Points | Description |
+|--------|--------|--------|-------------|
+| RECALL keyword match | High | 3 | Rule text contains a domain's RECALL keyword |
+| Domain name word match | Medium | 2 | Rule text contains words from domain name |
+| Agent trigger match | High | 3 | Rule mentions an agent that triggers a domain |
+| Existing rule similarity | Low | 1 | Rule is similar to existing rules in domain |
+
+Sum the points for each domain. Maximum possible score is 9 (round up to 10 if all factors match). Present as `{score}/10`.
+
+### Step 4: Present Suggestion
+
+Display the top suggestion(s):
+
+```
+Suggested domain for rule: "{rule-text}"
+
+  1. {domain-name} (score: {score}/10)
+     Reason: {justification}
+     RECALL keywords: {keywords}
+     Current rules: {count}
+
+  2. {domain-name} (score: {score}/10)
+     Reason: {justification}
+
+  [NEW] Create new domain "{suggested-name}"
+     If no existing domain fits well.
+```
+
+### Step 5: Offer Quick Action (Optional)
+
+After displaying the suggestion, offer:
+
+```
+Quick actions:
+  1. Add rule to {suggested-domain} now
+  2. Create new domain and add rule
+  3. Cancel (do nothing)
+```
+
+If user selects 1: Follow the add-rule task for the suggested domain.
+If user selects 2: Follow the create-domain task, then add-rule.
+If user selects 3: Exit without changes.
+
+---
+
+## Validation
+
+- [ ] All existing domains loaded and analyzed
+- [ ] Suggestion includes justification
+- [ ] Score is based on keyword matching and domain analysis
+- [ ] Quick action options work correctly if selected
+- [ ] Handles case where no good match exists (suggests new domain)
+
+---
+
+## Error Handling
+
+| Error | Message |
+|-------|---------|
+| No domains exist | `No domains found in manifest. Use "create" to create your first domain.` |
+| Empty rule text | `Error: Please provide the rule text to analyze.` |
+| Manifest not found | `Error: .synapse/manifest not found. SYNAPSE must be initialized first.` |
+
+---
+
+*Suggest Domain — SYNAPSE CRUD Command C7*
+*Source: SYNAPSE-HOOK-SKILL-COMMAND-ANALYSIS.md section 2.3*

package/.claude/commands/synapse/tasks/toggle-domain.md

@@ -0,0 +1,83 @@
+# Toggle Domain
+
+Toggles a SYNAPSE domain between active and inactive in the manifest.
+
+---
+
+## Purpose
+
+Enable or disable a domain by changing its `_STATE` value in `.synapse/manifest`. This controls whether the domain's rules are loaded by the SYNAPSE engine. The domain file itself is NOT modified.
+
+---
+
+## Prerequisites
+
+- `.synapse/manifest` exists
+- Target domain exists in the manifest
+
+---
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `domain-name` | Yes | Domain name to toggle (kebab-case) |
+
+---
+
+## Steps
+
+### Step 1: Validate Domain Exists in Manifest
+
+1. Derive the domain key: `my-domain` -> `MY_DOMAIN`
+2. Read `.synapse/manifest`
+3. Find the line `{DOMAIN_KEY}_STATE=active` or `{DOMAIN_KEY}_STATE=inactive`
+
+If not found: `Error: Domain "{domain-name}" not found in manifest.`
+
+### Step 2: Toggle State
+
+- If current state is `active`, change to `inactive`
+- If current state is `inactive`, change to `active`
+
+**Modify ONLY the manifest file.** Do NOT modify the domain file in `.synapse/{domain-name}`.
+
+Replace the line `{DOMAIN_KEY}_STATE={old-state}` with `{DOMAIN_KEY}_STATE={new-state}` in `.synapse/manifest`.
+
+### Step 3: Display Result
+
+```
+Toggled domain "{domain-name}":
+  {DOMAIN_KEY}_STATE: {old-state} -> {new-state}
+```
+
+### Step 4: Validate
+
+- Read back `.synapse/manifest`
+- Verify `{DOMAIN_KEY}_STATE={new-state}` is present
+- Verify the domain file was NOT modified (compare timestamp or content)
+
+---
+
+## Validation
+
+- [ ] Domain exists in manifest before toggle
+- [ ] Only `_STATE` value changed in manifest
+- [ ] Domain file (`.synapse/{domain-name}`) was NOT modified
+- [ ] Previous and new state displayed to user
+- [ ] Manifest remains parseable after modification
+
+---
+
+## Error Handling
+
+| Error | Message |
+|-------|---------|
+| Domain not in manifest | `Error: Domain "{name}" not found in manifest.` |
+| Manifest not found | `Error: .synapse/manifest not found. SYNAPSE must be initialized first.` |
+| Invalid state value | `Error: Unexpected state value "{value}" for domain "{name}". Expected "active" or "inactive".` |
+
+---
+
+*Toggle Domain — SYNAPSE CRUD Command C5*
+*Source: SYNAPSE-HOOK-SKILL-COMMAND-ANALYSIS.md section 2.3*

package/.claude/commands/synapse/templates/domain-template

@@ -0,0 +1,8 @@
+# ==========================================
+# SYNAPSE Domain: {DOMAIN_NAME}
+# Created: {CURRENT_DATE}
+# Description: {DESCRIPTION}
+# ==========================================
+
+# Rules
+{DOMAIN_KEY}_RULE_0={FIRST_RULE}

package/.claude/commands/synapse/templates/manifest-entry-template

@@ -0,0 +1,4 @@
+# Layer 6: {domain-name}
+{DOMAIN_KEY}_STATE=active
+{DOMAIN_KEY}_RECALL={KEYWORDS}
+{DOMAIN_KEY}_EXCLUDE=