Meta Self

Meta-Self: Unified Categorical Syntax Reference

This skill serves as the authoritative reference for the categorical meta-prompting framework. All commands and skills should align with this specification.

Categorical Foundation

F: Task → Prompt        (Functor - structure-preserving transformation)
M: Prompt →^n Prompt    (Monad - iterative refinement)
W: History → Context    (Comonad - context extraction)
α: F ⇒ G                (Natural Transformation - strategy switching)
E: Either Error A       (Exception Monad - error handling)
[0,1]: Quality → Quality (Enriched - quality tracking)

Categorical Laws (Must Be Satisfied)

1. Functor Identity:     F(id) = id
2. Functor Composition:  F(g ∘ f) = F(g) ∘ F(f)
3. Monad Left Identity:  return >=> f = f
4. Monad Right Identity: f >=> return = f
5. Monad Associativity:  (f >=> g) >=> h = f >=> (g >=> h)
6. Comonad Left Id:      extract ∘ duplicate = id
7. Comonad Associativity: duplicate ∘ duplicate = fmap duplicate ∘ duplicate
8. Naturality Condition: α_B ∘ F(f) = G(f) ∘ α_A  for all f: A → B
9. Exception Catch Id:   catch(Right(a), h) = Right(a)  (Phase 3)
10. Exception Catch Err: catch(Left(e), h) = h(e)       (Phase 3)
11. Exception Assoc:     Error handling preserves Kleisli associativity
12. Quality Monotonicity: quality(A ⊗ B) ≤ min(quality(A), quality(B))

Exception Monad E (Phase 3)

Type: Either<Error, A> = Left(Error) | Right(A)

Operations:

1. return: a → Right(a) (pure success)
2. bind (>=>): Error-propagating composition

   m >>= f = case m of
     Left(e) → Left(e)        -- error propagates
     Right(a) → f(a)          -- continue on success
   

3. catch: Error recovery

   catch(m, handler) = case m of
     Left(e) → handler(e)     -- recover from error
     Right(a) → Right(a)      -- pass through success
   

Laws:

• Left Identity: return(a) >>= f = f(a)
• Right Identity: m >>= return = m
• Associativity: (m >>= f) >>= g = m >>= (λx. f(x) >>= g)
• Catch Identity: catch(Right(a), h) = Right(a)
• Catch Error: catch(Left(e), h) = h(e)
• Catch Composition: catch(catch(m, h1), h2) = catch(m, λe. catch(h1(e), h2))

In Framework:

• Used by @catch: modifier for error handling behaviors
• Used by @fallback: modifier for recovery strategies
• Integrates with /chain and /rmp commands
• Preserves composition with existing operators (→, ||, >=>)

Unified Modifiers

All commands support these modifiers. Place them before the task description.

@mode: - Execution Mode

Example: /meta @mode:iterative "build auth system"

@quality: - Quality Threshold

Example: /rmp @quality:0.9 "optimize algorithm"

@tier: - Complexity Tier

Example: /meta @tier:L5 "design microservices"

@budget: - Token Budget

Example: /task-relay @budget:[5000,4000,6000] [R→D→I]

@variance: - Budget Variance Threshold

Example: /hekat @budget:18K @variance:15% [R→D→I]

@max_iterations: - Iteration Limit

Example: /rmp @quality:0.9 @max_iterations:3 "task"

@catch: - Error Handling Behavior (Phase 3)

Example: /chain @catch:retry:3 [/api→/process] "fetch data"

@fallback: - Error Recovery Strategy (Phase 3)

Example: /rmp @fallback:return-best @quality:0.9 "complex task"

@quality:visualize - Quality Flow Visualization (Phase 5)

Categorical Foundation: Uses [0,1]-enriched category structure where Hom_Q(A, B) = [0,1] and quality tensor follows q1 ⊗ q2 = min(q1, q2)

Example: /chain @quality:visualize [/analyze→/design→/implement] "build feature"

@template: - Template Components

Components:

• {context:expert\|teacher\|reviewer\|debugger}
• {mode:direct\|cot\|multi\|iterative}
• {format:prose\|structured\|code\|checklist}

Example: /meta @template:{context:expert}+{mode:cot}+{format:code} "implement"

@domain: - Force Domain Classification

Example: /meta @domain:SECURITY "review auth code"

@skills: - Skill Discovery & Composition

Example: /meta-command @skills:compose(api-testing⊗validation) "create tests"

Composition Operators

→ (Sequence) - Kleisli Composition

Unicode: U+2192 Meaning: Output of A becomes input of B Quality: quality(A → B) ≤ min(quality(A), quality(B))

# Command syntax
/chain [/debug→/review→/test] "error in auth.py"

# Agent syntax
[R→D→I→T] "build feature"

# Skill syntax
@skills:compose(research→design→implement)

|| (Parallel) - Concurrent Execution

Meaning: Execute A, B, C concurrently, aggregate results Quality: quality(A || B || C) = mean(quality(A), quality(B), quality(C))

# Parallel commands
/chain [/review-security || /review-performance] "audit code"

# Parallel agents
[R||D||A] "evaluate options"

# Mixed
[R→(D||F)→I] "full-stack with parallel design"

⊗ (Tensor) - Quality-Degrading Combination

Unicode: U+2297 Meaning: Combine capabilities, quality degrades to minimum Quality: quality(A ⊗ B) = min(quality(A), quality(B))

# Skill tensor
@skills:compose(api-testing⊗jest-patterns⊗validation)

# Agent tensor
[debug-detective⊗test-engineer] "fix and test"

>=> (Kleisli) - Monadic Refinement

Meaning: Composition with quality-gated iteration at each stage Quality: quality(A >=> B) improves with each iteration

# RMP stages
/rmp @quality:0.85 [analyze>=>design>=>implement] "build feature"

# Each stage:
# 1. Execute
# 2. Assess quality
# 3. If quality < threshold: refine
# 4. Pass to next stage

Command Invocation Syntax

Standard Pattern

/<command> @modifier1:value @modifier2:value [composition] "task description"

Examples

# Simple
/meta "implement rate limiter"

# With modifiers
/meta @mode:iterative @quality:0.85 "build API"

# With composition
/chain [/debug→/fix→/test] "TypeError in auth.py"

# Full syntax
/hekat @mode:active @tier:L5 @budget:18K [R→D→(I||T)] "build auth system"

# With skills
/meta-command @skills:discover(domain=API) @mode:iterative "create endpoint"

Agent Hotkeys (HEKAT Compatible)

Tier 1 - Single Agent

Tier 2 - Ctrl Modifiers

Tier 3 - Agent Chains

[R→D→I]        # Research → Design → Implement
[R→D→I→T]      # Full pipeline with testing
[P:R||D||A]    # Parallel: Research, Design, Analyze
[R→(D||F)→I]   # Mixed: Research, parallel Design/Frontend, Implement

Quality Assessment Structure

Multi-Dimensional Quality Vector

Aggregate Score

aggregate = (0.40 × correctness) + (0.25 × clarity) +
            (0.20 × completeness) + (0.15 × efficiency)

Quality Thresholds

Checkpoint Format

All commands produce standardized checkpoints:

CHECKPOINT_[type]_[n]:
  command: /[command]
  iteration: [n]
  quality:
    correctness: [0-1]
    clarity: [0-1]
    completeness: [0-1]
    efficiency: [0-1]
    aggregate: [0-1]
  quality_delta: [+/- from previous]
  budget:
    used: [tokens]
    remaining: [tokens]
    variance: [%]
  status: [CONTINUE | CONVERGED | MAX_ITERATIONS | HALT]
  trend: [RAPID_IMPROVEMENT | STEADY_IMPROVEMENT | PLATEAU | DEGRADING]

Workflow Patterns

Pattern 1: Simple Task

/meta "task"

• Auto-detect domain, tier, template
• Single-pass execution

Pattern 2: Quality-Gated Iteration

/rmp @quality:0.85 @max_iterations:5 "task"

• Iterate until quality threshold
• Track quality improvement

Pattern 3: Multi-Stage Pipeline

/chain [/analyze→/design→/implement→/test] "feature"

• Sequential execution
• Output → Input flow

Pattern 4: Parallel Exploration

/chain [/approach-a || /approach-b || /approach-c] "evaluate options"

• Concurrent execution
• Aggregate results

Pattern 5: Hierarchical Orchestration

/hekat @tier:L5 [Lead→(Worker||Worker)→Synthesize] "complex task"

• Lead agent coordinates
• Workers execute in parallel
• Synthesizer combines results

Pattern 6: Skill-Driven Meta-Command

/meta-command @skills:discover(domain=API,relevance>0.7) "create endpoint command"

• Auto-discover relevant skills
• Inject into command creation

Mode Behaviors

@mode:active

• Execute immediately
• Auto-detect all parameters
• Single-pass unless combined with @mode:iterative

@mode:iterative

• Enable RMP loop
• Iterate until @quality: threshold
• Track quality across iterations

@mode:dry-run

• Show execution plan
• Do not execute
• Exit after plan display

@mode:spec

• Generate YAML specification
• Do not execute
• Exit after spec generation

Error Handling

Budget Exceeded

STATUS: HALT
reason: "Budget variance exceeded @variance: threshold"
action: "Review agent outputs, adjust budget allocation"

Quality Plateau

STATUS: NO_IMPROVEMENT
reason: "Quality improvement < 0.02 for 2 iterations"
action: "Fixed-point reached, returning best result"

Max Iterations

STATUS: MAX_ITERATIONS
reason: "Reached @max_iterations: limit"
action: "Return best result from iterations"

Self-Reference Protocol

When executing any command or skill:

1. Check modifiers: Parse all @modifier: values
2. Apply defaults: Use defaults for unspecified modifiers
3. Validate syntax: Ensure operators match specification
4. Execute: Follow categorical laws
5. Checkpoint: Output standardized checkpoint
6. Quality assess: Evaluate using multi-dimensional vector
7. Decide: CONTINUE, CONVERGE, or HALT based on rules

Command Reference Quick Look

Core Categorical Commands (F, M, W, α)

Natural Transformation Operations (/transform)

Strategy Registry (Functors):

• zero-shot (F_ZS): Direct prompt, quality ~0.65
• few-shot (F_FS): Exemplar prompt, quality ~0.78
• chain-of-thought (F_CoT): Reasoning prompt, quality ~0.85
• tree-of-thought (F_ToT): Branching prompt, quality ~0.88
• meta-prompting (F_Meta): Adaptive prompt, quality ~0.90

Aliases:

• /cot = /transform @to:chain-of-thought
• /tot = /transform @to:tree-of-thought

Comonad Operations (/context)

Aliases:

• /extract = /context @mode:extract
• /focus = /context @mode:extract @depth:1

Composition & Routing Commands

Domain Commands

Skill Reference Quick Look

Atomic Blocks (Layer 3 Access)

For power users who need fine-grained control, the framework exposes atomic blocks that underlie all commands.

Quick Reference

Skill: atomic-blocks
Command: /blocks [composition] "task"

Available Blocks

Progressive Disclosure

Full specification: skill:atomic-blocks

Validation Checklist

Before executing any prompt:

• All modifiers use @name:value syntax
• Operators match: →, ||, ⊗, >=>
• Quality thresholds in [0,1] range
• Budget values are positive integers or "auto"
• Tier values are L1-L7
• Mode values are: active, iterative, dry-run, spec
• Composition brackets match: [...]
• Task description is quoted: "task"

Version

Specification Version: 2.5 Compatibility: 100% backward compatible Foundation: Category Theory (F, M, W, α, E, [0,1]-enriched) Last Updated: 2025-12-01 New in 2.5: Atomic blocks system with /blocks command, @block: overrides, progressive disclosure New in 2.4: Quality Visualization via @quality:visualize modifier (Phase 5) New in 2.3: Exception Monad E for error handling via @catch:/@fallback: modifiers New in 2.2: Natural Transformation α operations via /transform command New in 2.1: Comonad W operations via /context command