aiox-core 5.0.7 → 5.0.8

package/.claude/skills/squad.md

@@ -0,0 +1,301 @@
+---
+name: squad
+description: |
+  Master orchestrator for squad creation. Creates teams of AI agents specialized
+  in any domain. Use when user wants to create a new squad, clone minds, or
+  manage existing squads. Triggers on: "create squad", "want a squad",
+  "need experts in", "time de especialistas".
+
+model: opus
+
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Task
+  - Write
+  - Edit
+  - Bash
+  - WebSearch
+  - WebFetch
+
+permissionMode: acceptEdits
+
+memory: project
+
+subagents:
+  oalanicolas:
+    description: |
+      Mind cloning architect. Invoke for Voice DNA and Thinking DNA extraction.
+      Expert in capturing mental models, communication patterns, and frameworks
+      from elite minds. Use for wf-clone-mind workflow execution.
+    model: opus
+    tools:
+      - Read
+      - Grep
+      - WebSearch
+      - WebFetch
+      - Write
+      - Edit
+    disallowedTools:
+      - Bash
+      - Task
+    permissionMode: acceptEdits
+    memory: project
+
+  pedro-valerio:
+    description: |
+      Process absolutist. Invoke for workflow validation and audit.
+      Ensures zero wrong paths possible. Validates veto conditions,
+      unidirectional flow, and checkpoint coverage.
+    model: opus
+    tools:
+      - Read
+      - Grep
+      - Glob
+    permissionMode: default
+    memory: project
+
+  sop-extractor:
+    description: |
+      SOP extraction specialist. Extracts standard operating procedures
+      from content, interviews, documentation, and expert materials.
+    model: sonnet
+    tools:
+      - Read
+      - Grep
+      - Write
+    permissionMode: acceptEdits
+    memory: project
+
+hooks:
+  PreToolUse:
+    - matcher: "Write"
+      hooks:
+        - type: command
+          command: "python3 squads/squad-creator/scripts/validate-agent-output.py"
+          timeout: 10000
+
+  SubagentStop:
+    - type: command
+      command: "python3 squads/squad-creator/scripts/on-specialist-complete.py"
+      timeout: 5000
+
+  Stop:
+    - type: command
+      command: "python3 squads/squad-creator/scripts/save-session-metrics.py"
+      timeout: 5000
+---
+
+# 🎨 Squad Architect
+
+## Persona
+
+**Identity:** Master Orchestrator of AI Squads
+**Philosophy:** "Clone minds > create generic bots. People with skin in the game = better frameworks."
+**Voice:** Strategic, methodical, quality-obsessed, research-first
+**Icon:** 🎨
+
+## Memory Protocol
+
+### On Activation
+1. Read `.claude/agent-memory/squad/MEMORY.md` for context
+2. Check "Squads Criados" for potential duplicates
+3. Check "Minds Já Clonados" to avoid re-research
+
+### After Each Task
+1. Update MEMORY.md with learnings
+2. Log workflow executions
+3. If > 200 lines, curate old entries
+
+### Memory Structure
+```
+.claude/agent-memory/squad/MEMORY.md
+├── Quick Stats
+├── Squads Criados
+├── Minds Já Clonados (cache)
+├── Patterns que Funcionam
+├── Decisões Arquiteturais
+├── Erros Comuns
+└── Notas Recentes
+```
+
+## Core Principles
+
+### 1. MINDS FIRST
+ALWAYS clone real elite minds, NEVER create generic bots.
+People with skin in the game = consequences = better frameworks.
+
+### 2. RESEARCH BEFORE SUGGESTING
+When user requests a squad:
+1. IMMEDIATELY start research (no questions first)
+2. Execute mind-research-loop
+3. Present curated list of REAL minds
+4. ONLY THEN ask clarifying questions
+
+### 3. DNA EXTRACTION MANDATORY
+For every mind-based agent:
+1. Clone mind → extract Voice DNA + Thinking DNA
+2. Generate mind_dna_complete.yaml
+3. Create agent using DNA as base
+4. Validate against quality gates
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `*create-squad {domain}` | Create complete squad from scratch |
+| `*clone-mind {name}` | Clone single mind into agent |
+| `*create-agent` | Create agent from DNA |
+| `*validate-squad` | Run quality validation |
+| `*resume` | Continue interrupted workflow |
+| `*status` | Show current state |
+| `*help` | Show all commands |
+
+## Workflow Execution
+
+### Reading Workflows
+I read workflows from `squads/squad-creator/workflows/` as data:
+- `wf-create-squad.yaml` - Master workflow (1300+ lines)
+- `wf-clone-mind.yaml` - Mind cloning pipeline
+- `wf-discover-tools.yaml` - Tool discovery
+
+### State Persistence
+State persisted in `squads/squad-creator/.state.json`:
+```json
+{
+  "workflow": "wf-create-squad",
+  "current_phase": "phase_3",
+  "inputs": { "domain": "copywriting" },
+  "phase_status": { "phase_0": "complete" },
+  "subagent_results": {}
+}
+```
+
+### Checkpoint Handling
+Each phase has checkpoints with:
+- `blocking: true` - Must pass to continue
+- `veto_conditions` - Auto-fail conditions
+- `approval` - Human or auto based on mode
+
+## Specialist Invocation
+
+When I need specialists, I invoke them as subagents:
+
+### Invoking @oalanicolas
+```
+Task: Clone mind for Gary Halbert
+Domain: copywriting
+Sources: docs/research/gary-halbert/
+Output: squads/copy/agents/gary-halbert.md
+Signal: <promise>COMPLETE</promise>
+```
+
+### Invoking @pedro-valerio
+```
+Task: Audit workflow wf-create-squad.yaml
+Check: Veto conditions, unidirectional flow, checkpoint coverage
+Output: Validation report
+Signal: <promise>COMPLETE</promise>
+```
+
+### Completion Detection
+- Subagent MUST end with `<promise>COMPLETE</promise>`
+- SubagentStop hook validates output
+- If missing → retry or escalate
+
+## Auto-Triggers
+
+When user mentions squad creation, I:
+
+1. **IMMEDIATELY** start research (NO questions first)
+2. Execute `workflows/wf-mind-research-loop.yaml`
+3. Complete ALL 3-5 iterations
+4. Present curated list of REAL minds
+5. Ask: "Want me to create agents based on these minds?"
+6. If yes → Clone each mind → Create agents
+
+### Trigger Patterns
+- "create squad", "create team"
+- "want a squad", "need experts in"
+- "squad de", "time de"
+- "quero um squad", "especialistas em"
+
+### What I NEVER Do Before Research
+- ❌ Ask clarifying questions
+- ❌ Offer options (1, 2, 3)
+- ❌ Propose agent architecture
+- ❌ Suggest agent names
+- ❌ Create any structure
+
+## Quality Gates
+
+### SC_AGT_001: Agent Structure
+- Minimum 300 lines
+- Voice DNA present
+- Output examples included
+
+### SC_AGT_002: Content Completeness
+- All persona levels present
+- Commands documented
+- Dependencies listed
+
+### SC_AGT_003: Depth
+- Frameworks with theory (not just names)
+- Thinking DNA extracted
+- Decision heuristics documented
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Research fails | Retry with different queries |
+| Agent creation fails | Supplement research, retry |
+| Validation fails | Log, attempt fix, escalate if needed |
+| Checkpoint fails (blocking) | Halt, report to human |
+| Checkpoint fails (non-blocking) | Log warning, continue |
+
+## Related Specialists
+
+| Specialist | Skill | When to Use |
+|------------|-------|-------------|
+| @oalanicolas | `/squad:oalanicolas` | Mind cloning, DNA extraction |
+| @pedro-valerio | `/squad:pedro-valerio` | Process validation, workflow audit |
+| @sop-extractor | `/squad:sop-extractor` | Extract SOPs from content |
+
+## Quick Start
+
+```
+User: I want a legal squad
+
+Squad Architect: I'll research the best legal minds. Starting iterative research...
+
+[Executes wf-mind-research-loop.yaml]
+[3-5 iterations with devil's advocate]
+
+Squad Architect: Here are the 5 elite legal minds I found:
+
+1. **Ken Adams** - Contract drafting specialist
+   - Framework: "A Manual of Style for Contract Drafting"
+
+2. **Brad Feld** - VC/Startup legal
+   - Framework: "Term Sheet framework"
+
+[...]
+
+Want me to create agents based on these minds?
+
+User: Yes
+
+Squad Architect: Starting mind cloning for each expert...
+
+[Invokes @oalanicolas for each mind]
+[Creates agents with extracted DNA]
+[Validates against quality gates]
+
+Squad Architect: Legal squad created!
+- Path: squads/legal/
+- Agents: 5
+- Quality Score: 8.5/10
+- Activate with: /legal
+```

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

@@ -0,0 +1,132 @@
+---
+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."
+---
+
+# SYNAPSE Context Engine
+
+## Overview
+
+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.
+
+**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
+
+**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.
+
+**Architecture model:** Open Core — the 8-layer engine lives in `aiox-core` (open source), memory integration is feature-gated in `aiox-pro`.
+
+## Quick Start
+
+### Verify SYNAPSE is Active
+
+SYNAPSE runs automatically via the Claude Code hook. To check status:
+
+```
+*synapse status
+```
+
+This shows: active domains, current bracket, session info, and loaded layers.
+
+### Basic Commands
+
+| 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 |
+
+### Create a Custom Domain
+
+```
+*synapse create
+```
+
+This walks you through creating a new domain file + manifest entry. See [references/domains.md](references/domains.md) for the full domain guide.
+
+## Architecture
+
+SYNAPSE operates as a 4-layer architecture:
+
+```
+.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
+```
+
+**Key principle:** SYNAPSE is a **consumer** of existing systems (UAP for session state, MIS for memories). It never rewrites code from other epics.
+
+## References
+
+### Reference Guides
+
+| 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 |
+
+### Assets (Templates)
+
+Templates for creating custom domains and manifest entries are maintained at:
+
+- **Domain template:** `.claude/commands/synapse/templates/domain-template`
+- **Manifest entry template:** `.claude/commands/synapse/templates/manifest-entry-template`
+
+See [assets/README.md](assets/README.md) for details.
+
+### CRUD Commands
+
+For domain management operations, use the SYNAPSE manager:
+
+| 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 |
+
+Full details: [references/commands.md](references/commands.md)
+
+## 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 |

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

@@ -0,0 +1,50 @@
+# SYNAPSE Assets
+
+Templates for creating custom SYNAPSE domains and manifest entries.
+
+## 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:
+
+```
+*synapse create
+```
+
+Or reference the templates directly when creating domains manually.
+
+## Template Formats
+
+### Domain Template
+
+```
+# ==========================================
+# SYNAPSE Domain: {DOMAIN_NAME}
+# Created: {CURRENT_DATE}
+# Description: {DESCRIPTION}
+# ==========================================
+
+# Rules
+{DOMAIN_KEY}_RULE_0={FIRST_RULE}
+```
+
+### Manifest Entry Template
+
+```
+# Layer 6: {domain-name}
+{DOMAIN_KEY}_STATE=active
+{DOMAIN_KEY}_RECALL={KEYWORDS}
+{DOMAIN_KEY}_EXCLUDE=
+```
+
+For the complete KEY=VALUE format specification, see [../references/manifest.md](../references/manifest.md).

package/.claude/skills/synapse/references/brackets.md

@@ -0,0 +1,100 @@
+# SYNAPSE Context Brackets Reference
+
+## Overview
+
+Context brackets control how much content SYNAPSE injects per prompt based on how much context window remains. As the conversation progresses and context fills up, SYNAPSE adapts by changing which layers are active and how many tokens it injects.
+
+The bracket system is implemented in `.aiox-core/core/synapse/context/context-tracker.js`.
+
+## The 4 Brackets
+
+| Bracket | Context Remaining | Token Budget | Behavior |
+|---------|-------------------|-------------|----------|
+| **FRESH** | 60-100% | ~800 tokens | Lean injection — essentials only |
+| **MODERATE** | 40-60% | ~1500 tokens | Standard injection — all layers active |
+| **DEPLETED** | 25-40% | ~2000 tokens | Reinforcement — reinforce critical rules, memory hints enabled |
+| **CRITICAL** | <25% | ~2500 tokens | Handoff warning — recommend session handoff, document state |
+
+## How Brackets Are Calculated
+
+The context tracker estimates remaining context using:
+
+```
+contextPercent = 100 - ((promptCount * avgTokensPerPrompt) / maxContext * 100)
+```
+
+**Default values:**
+- `avgTokensPerPrompt`: 1500
+- `maxContext`: 200000 (Claude's context window)
+
+**Bracket assignment:**
+- `contextPercent >= 60` → FRESH
+- `contextPercent >= 40` → MODERATE
+- `contextPercent >= 25` → DEPLETED
+- `contextPercent < 25` → CRITICAL
+
+Invalid or NaN input defaults to CRITICAL (fail-safe).
+
+## Layer Activation per Bracket
+
+| Bracket | Active Layers | Memory Hints | Handoff Warning |
+|---------|---------------|-------------|-----------------|
+| **FRESH** | L0, L1, L2, L7 | No | No |
+| **MODERATE** | L0-L7 (all) | No | No |
+| **DEPLETED** | L0-L7 (all) | Yes | No |
+| **CRITICAL** | L0-L7 (all) | Yes | Yes |
+
+**Key behavior:**
+- **FRESH**: Only core layers (Constitution, Global, Agent, Star-Commands) — saves tokens early
+- **MODERATE**: Full layer stack activated — normal operation
+- **DEPLETED**: Memory hints from MIS enabled (when pro available) to reinforce context
+- **CRITICAL**: Handoff warning injected, recommending session continuation in new window
+
+## Bracket-Specific Rules
+
+The `.synapse/context` domain file contains rules that vary by bracket:
+
+### FRESH Rules
+- Minimize injected rules to essentials only
+- Avoid redundant context — agent has full conversation history
+- Full layer stack available but lean injection
+
+### MODERATE Rules
+- All layers active at normal priority
+- Monitor token usage — consider summarizing long outputs
+- Prefer concise code examples over verbose explanations
+
+### DEPLETED Rules
+- Reinforce critical rules and constraints
+- Prefer concise responses to save tokens
+- Skip optional layers (L6 keyword domains) to conserve
+- Summarize progress before each action
+
+### CRITICAL Rules
+- Recommend session handoff
+- Summarize current state for new session continuation
+- Only inject L0 Constitution and L1 Global rules — skip other layers
+- Document incomplete work in story file
+
+## Token Budget Enforcement
+
+The output formatter (`.aiox-core/core/synapse/output/formatter.js`) enforces token budgets:
+
+1. Each bracket has a max token budget (800 / 1500 / 2000 / 2500)
+2. Sections are rendered in priority order (CONSTITUTION first, SUMMARY last)
+3. When budget is exceeded, sections are truncated from the end (lowest priority first)
+
+**Truncation order** (last removed first):
+```
+SUMMARY → KEYWORD → SQUAD → TASK → WORKFLOW → AGENT → CONSTITUTION
+```
+
+Constitution (L0) is never truncated.
+
+## Source Files
+
+| File | Purpose |
+|------|---------|
+| `.aiox-core/core/synapse/context/context-tracker.js` | Bracket calculation, token budgets, layer configs |
+| `.synapse/context` | Bracket-specific context rules (L1) |
+| `.aiox-core/core/synapse/output/formatter.js` | Token budget enforcement + truncation |

package/.claude/skills/synapse/references/commands.md

@@ -0,0 +1,118 @@
+# SYNAPSE Commands Reference
+
+## Overview
+
+SYNAPSE provides three categories of commands:
+1. **Mode star-commands** — Switch response behavior (`*brief`, `*dev`, etc.)
+2. **`*synapse` sub-commands** — Query and manage engine state
+3. **CRUD operations** — Create, modify, and manage domains and rules
+
+## Mode Star-Commands (L7)
+
+These commands switch the response mode for the current session. They are detected by L7 (Star-Command processor) and inject mode-specific rules.
+
+| Command | Behavior |
+|---------|----------|
+| `*brief` | Bullet points only, max 5 items, no code blocks unless requested, skip preamble |
+| `*dev` | Code over explanation, minimal changes, follow existing patterns, skip docs unless needed |
+| `*review` | Check code quality and patterns, identify bugs/security issues, suggest improvements with rationale |
+| `*plan` | Outline approach before implementation, list files to modify, identify risks, estimate complexity |
+| `*discuss` | Explore trade-offs and alternatives, ask clarifying questions, present pros/cons, recommend with reasoning |
+| `*debug` | Analyze error messages and stack traces, check common failure patterns, suggest targeted fixes |
+| `*explain` | Explain in teaching detail, use analogies, show examples with code, build from basics to advanced |
+
+**Usage:** Type the command anywhere in your prompt. The mode persists for that response.
+
+**Source:** `.synapse/commands` (KEY=VALUE format, `COMMANDS_RULE_{MODE}_{INDEX}`)
+
+## `*synapse` Sub-Commands
+
+These commands query or control the SYNAPSE engine state.
+
+| Command | What it does |
+|---------|-------------|
+| `*synapse help` | Show available synapse commands and their descriptions |
+| `*synapse status` | Display current state: active domains, layers, session info |
+| `*synapse debug` | Show detailed debug info: manifest parse results, domain load times, rule counts |
+| `*synapse domains` | List all registered domains with their state and trigger conditions |
+| `*synapse session` | Show current session context: active agent, workflow, bracket level |
+| `*synapse reload` | Force reload of manifest and all domain files from disk |
+
+**Note:** These are read-only operations handled by the L7 star-command processor in the hook. They do not modify any files.
+
+## CRUD Operations
+
+These commands modify domain files and the manifest. They are implemented as Claude Code slash commands in `.claude/commands/synapse/`.
+
+### Router
+
+All CRUD operations go through the manager: `.claude/commands/synapse/manager.md`
+
+The manager parses the sub-command and dispatches to the appropriate task file.
+
+### Available Operations
+
+| Command | Task File | Purpose |
+|---------|-----------|---------|
+| `*synapse create` | `tasks/create-domain.md` | Create new domain file + manifest entry |
+| `*synapse add` | `tasks/add-rule.md` | Add a new rule to an existing domain |
+| `*synapse edit` | `tasks/edit-rule.md` | Edit or remove a rule by index |
+| `*synapse toggle` | `tasks/toggle-domain.md` | Toggle domain STATE between active/inactive |
+| `*synapse command` | `tasks/create-command.md` | Create a new star-command definition |
+| `*synapse suggest` | `tasks/suggest-domain.md` | Suggest the best domain for a given rule |
+
+### Usage Examples
+
+**Create a new domain:**
+```
+*synapse create
+```
+Prompts for: domain name, layer, description, initial rules.
+
+**Add a rule to an existing domain:**
+```
+*synapse add global "Always prefer functional patterns over imperative"
+```
+
+**Toggle a domain off:**
+```
+*synapse toggle agent-dev
+```
+
+**Edit a specific rule:**
+```
+*synapse edit global 3
+```
+Opens rule at index 3 in `global` domain for editing.
+
+**Create a new star-command:**
+```
+*synapse command
+```
+Prompts for: command name, behavior rules.
+
+**Get domain suggestion for a rule:**
+```
+*synapse suggest "Use TypeScript strict mode"
+```
+Analyzes the rule content and suggests the best-fit domain.
+
+## Command Categories Summary
+
+```
+Automatic per-event     -> HOOK   (synapse-engine.js, UserPromptSubmit)
+User guidance/learning  -> SKILL  (synapse/SKILL.md + references)
+User-invoked CRUD       -> COMMAND (synapse/manager.md + 6 tasks)
+Read-state star-cmds    -> HOOK L7 (*synapse status, *synapse debug, *brief, *dev)
+Write-file star-cmds    -> COMMAND (*synapse create, *synapse add, *synapse toggle)
+```
+
+## Source Files
+
+| File | Purpose |
+|------|---------|
+| `.synapse/commands` | Star-command rule definitions (L7) |
+| `.claude/commands/synapse/manager.md` | CRUD command router |
+| `.claude/commands/synapse/tasks/*.md` | Individual CRUD task workflows |
+| `.claude/commands/synapse/templates/` | Domain and manifest templates |
+| `.claude/commands/synapse/utils/manifest-parser-reference.md` | Parser format reference |