--- name: distill description: Distill Claude Code session operations into reusable tinctures (Skills, Commands, Agents). Uses category theory for structural preservation, information theory for potency analysis, and the Golden Ratio for classification. Use when you want to capture effective workflows, or when the user says "distill", "extract this", "make a tincture", "capture this workflow", or "turn this into a skill\/command". --- # Distill: The Alchemist's Art > *"Solve et Coagula" — Dissolve and Coagulate* Extract the **quintessence** from ephemeral session operations, purifying them into eternal, reusable artifacts through the sacred art of distillation. --- ## The Mathematical Foundation ### The Distillation Functor Distillation is mathematically modeled as a **functor** between categories: ``` D: Session → Artifacts Where: Session = Category(States, Operations, Composition) Artifacts = Product(Command, Skill, Agent) ``` **Functor Laws (D must preserve):** ``` D(id_A) = id_D(A) (Identity preservation) D(g ∘ f) = D(g) ∘ D(f) (Composition preservation) ``` **Why this matters:** The functor preserves the essential structure of the session while transforming it into a different form. Patterns compose in artifacts the same way they composed in the session. ### The Comonad for Pattern Extraction Pattern extraction uses a **Comonad** W: ``` W: SessionHistory → PatternContext With operations: ε: W(A) → A (extract: get current pattern) δ: W(A) → W(W(A)) (duplicate: contextual awareness) Laws: ε ∘ δ = id W(ε) ∘ δ = id δ ∘ δ = W(δ) ∘ δ ``` **Intuition:** The comonad provides *focused awareness* - extracting patterns while maintaining their context. Each pattern knows its neighborhood. ### The Monad for Refinement Tincture refinement uses a **Monad** M: ``` M: Pattern → RefinedPattern With operations: η: A → M(A) (unit: initial refinement) μ: M(M(A)) → M(A) (join: flatten nested refinements) Laws: μ ∘ M(η) = id μ ∘ η_M = id μ ∘ M(μ) = μ ∘ μ_M ``` **Kleisli Composition for Iterative Refinement:** ``` f >=> g = μ ∘ M(g) ∘ f Allows: refine₁ >=> refine₂ >=> ... >=> refineₙ ``` ### The Adjunction W ⊣ M Extraction and refinement form an **adjunction**: ``` Hom_Pattern(W(A), B) ≅ Hom_Session(A, M(B)) The counit: ε: W ∘ M → Id (extract after refine) The unit: η: Id → M ∘ W (refine after extract) ``` This captures the duality: extracting patterns from context ↔ refining patterns into context. --- ## Quantum-Theoretic Foundation ### The Observer Effect Distillation is a **measurement** that collapses superposition: ``` |Session⟩ = Σ αᵢ|Patternᵢ⟩ Before distillation: Session exists in superposition of all possible patterns After distillation: Collapsed to specific tincture D|Session⟩ → |Tincture⟩ The act of observation (analysis) determines the outcome. ``` **Why this matters:** The observer (the intention) shapes what patterns are perceived. Clarify intention first. ### Entanglement: Perceiving Connections Patterns in a session can be **entangled** - correlated in ways that transcend local context: ``` |Ψ⟩ = (1\/√2)(|Pattern_A⟩|Pattern_B⟩ + |Pattern_A'⟩|Pattern_B'⟩) Measuring Pattern_A instantly determines Pattern_B. They share a quantum correlation. ``` **In Distillation:** - Look for **non-local correlations** - patterns that affect each other across the session - A change in one file may entangle with a test, a config, a deployment - Capture the **entire entangled system**, not just local operations ### Source Perception: The Wave Function Origin Every pattern has a **source** - the initial condition that propagated through the session: ``` |Source⟩ → U(t)|Session⟩ Where U(t) is the unitary evolution operator. To understand a pattern, trace back to its source: Pattern → Cause → Cause⁻¹ → ... → Source ``` **The Backward Light Cone:** ``` Pattern (now) \/\ \/ \ \/ \ \/ \ Cause₁ Cause₂ \ \/ \ \/ \\/ Source (origin) ``` **In Distillation:** Ask not just "what happened" but "why did it originate?" ### Quantum Superposition of Abstractions Before classification, the tincture exists in **superposition**: ``` |Tincture⟩ = α|Command⟩ + β|Skill⟩ + γ|Agent⟩ Where |α|² + |β|² + |γ|² = 1 The complexity score φ.classify performs the "measurement": φ.classify|Tincture⟩ → |Type⟩ ``` **Interference Effects:** - Constructive: When session patterns align, potency increases - Destructive: When patterns conflict, potency decreases - The φ balance equation finds the constructive interference point ### The Heisenberg Trade-off ``` ΔSpecificity × ΔGenerality ≥ ℏ_distill You cannot simultaneously maximize both specificity and generality. The golden ratio φ provides the optimal trade-off point. ``` **Connection to Quality:** ``` Quality = φ⁻¹ × Specificity + φ × Generality At the Heisenberg-optimal point: Specificity × Generality = 1 ``` ### Non-Locality: Connections Across Distance Patterns can be **non-locally connected** - correlated without direct causal links: ``` ⟨Pattern_A, Pattern_B⟩ ≠ 0 even when d(A, B) >> 0 Where d(A, B) is the "distance" (different files, different phases) ``` **In Distillation:** - Search for patterns that **resonate** across the codebase - A naming convention in one file may echo in another - Error handling patterns may repeat non-locally - These non-local correlations often reveal deeper structure ### The Density Matrix: Mixed States Real sessions are **mixed states**, not pure: ``` ρ = Σ pᵢ |Patternᵢ⟩⟨Patternᵢ| Where pᵢ is the probability of pattern i. Purity: Tr(ρ²) ∈ [0, 1] Pure state: Tr(ρ²) = 1 (single clear pattern) Mixed state: Tr(ρ²) < 1 (multiple overlapping patterns) ``` **In Distillation:** A session with low purity may require multiple tinctures or a higher-potency (Agent) tincture to handle the mixed state. --- ## Information-Theoretic Foundation ### Entropy Reduction Distillation is fundamentally about **entropy reduction**: ``` H(Session) > H(Tincture) Where: H(Session) = -Σ p(sᵢ) log p(sᵢ) (Session entropy) H(Tincture) = -Σ p(tⱼ) log p(tⱼ) (Tincture entropy) ``` **The Distillation Inequality:** ``` H(Tincture) ≤ H(Session) - I(Session; Dross) The tincture entropy is bounded by session entropy minus the mutual information with discarded material (dross). ``` ### Mutual Information Preservation The essence preserved in distillation: ``` I(Session; Tincture) = H(Session) + H(Tincture) - H(Session, Tincture) ``` **For quality distillation:** ``` I(Session; Tincture) \/ H(Session) ≥ φ⁻¹ (0.618) At least 61.8% of session information must be preserved. ``` ### Synergistic Information True distillation creates **synergy** - the tincture is more than compression: ``` Synergy = I(Session, Context; Tincture) - I(Session; Tincture) - I(Context; Tincture) ``` **Positive synergy** means the tincture enables new operations that neither the session nor the context alone could support. ### The Rate-Distortion Trade-off ``` R(D) = min_{p(t|s): E[d(s,t)]≤D} I(S; T) Where: R = rate (tincture complexity) D = distortion (loss from session) d(s,t) = distance between session and tincture representation ``` **Optimal distillation** operates at the rate-distortion bound. --- ## The Golden Ratio (φ = 1.618...) The divine proportion governs tincture classification: ``` a + b a φ = ─────── = ───── = 1.618033988749895... a b ``` **Algebraic Form:** φ is the positive root of x² - x - 1 = 0 ``` φ = (1 + √5) \/ 2 ``` **Self-Similar Properties:** ``` φ² = φ + 1 (φ contains itself plus unity) 1\/φ = φ - 1 (inverse is complement) φⁿ = φⁿ⁻¹ + φⁿ⁻² (Fibonacci recurrence) ``` ### The Potency Spectrum ``` Complexity Score = (O × D × I) \/ β Where: O = operation count D = decision points (1 if none) I = iteration cycles (1 if none) β = 5 (base complexity constant) ``` **φ Classification:** | Score Range | φ Category | Tincture Type | Potency | |-------------|------------|---------------|---------| | < 0.618 | 1\/φ | Command (Extract) | Low | | 0.618 - 1.618 | φ⁰ to φ¹ | Skill (Tincture) | Medium | | > 1.618 | > φ | Agent (Elixir) | High | | > 2.618 | > φ² | Agent (Potent Elixir) | Very High | **The Golden Spiral of Potency:** ``` r(θ) = a · φ^(θ·2\/π) Tincture potency follows the golden spiral. Higher scores converge toward the center (autonomy). ``` ### The Quality Balance Equation ``` Quality = φ⁻¹ × Specificity + φ × Generality Optimal when: Specificity × Generality = 1 ``` **Derivation:** ``` Let S = Specificity, G = Generality Q(S, G) = αS + βG subject to S·G = 1 Setting α = φ⁻¹ = 0.618, β = φ = 1.618: Q = 0.618S + 1.618G Optimum at S = G = 1: Q = 0.618 + 1.618 = 2.236 = √5 ``` The optimal quality equals √5, which is 2φ - 1. This is the diagonal of a 1×2 rectangle (the golden rectangle). --- ## Topological Foundation ### The Quotient Space Distillation creates a **quotient space**: ``` Tincture = Session \/ ~ Where ~ is the equivalence relation: s₁ ~ s₂ iff Pattern(s₁) = Pattern(s₂) ``` The tincture is the space of equivalence classes - concrete instances collapsed to abstract patterns. ### Fiber Bundle Structure The distillation forms a **fiber bundle**: ``` E (Total Space - All Sessions) | π ↓ B (Base Space - Pattern Types) Fiber over b ∈ B: π⁻¹(b) = all sessions exhibiting pattern b ``` **The tincture is a section** s: B → E that picks one representative from each fiber. ### Homotopy Equivalence Two distillation processes are equivalent if **homotopy equivalent**: ``` D₁ ≃ D₂ iff ∃ f: D₁ → D₂, g: D₂ → D₁ such that g∘f ≃ id, f∘g ≃ id ``` Different distillation paths yielding equivalent tinctures. --- ## The Four Stages of the Opus ``` NIGREDO → ALBEDO → CITRINITAS → RUBEDO (Black) (White) (Yellow) (Red) Dissolve Purify Classify Coagulate Session Essence Potency Tincture ``` ### Stage 1: NIGREDO - Dissolution (W.extract) **The Blackening:** Dissolve the session into its constituent patterns. **Mathematical Operation:** ``` W.extract: SessionHistory → PatternSet Nigredo(S) = {p ∈ Pattern | ∃ morphism f: p → S} ``` **Pattern Categories:** | Pattern Type | Categorical Signature | Tincture Affinity | |--------------|----------------------|-------------------| | Linear sequence | A → B → C | Command | | Branching | A → B ⊔ C | Agent | | Iteration | A →ⁿ A' | Agent | | Composition | A ⊗ B | Skill | | Simple | A → B | Command | **Entropy Analysis:** ``` H(Nigredo) = H(Session) Dissolution preserves total entropy while revealing structure. ``` ### Stage 2: ALBEDO - Purification (F.map) **The Whitening:** Purify concrete operations into abstract essences. **Mathematical Operation:** ``` F.map: ConcreteOp → AbstractPattern Albedo(p) = (Invariant(p), Variant(p)) Where: Invariant(p) = the essence (what stays constant) Variant(p) = the dross (what becomes parameters) ``` **The Purification Functor:** ``` F: Concrete → Abstract F preserves: F(f ∘ g) = F(f) ∘ F(g) F forgets: Specific values, contexts, instances F retains: Structure, relationships, patterns ``` **Abstraction Rules:** | Concrete | Abstract | Parameter | |----------|----------|-----------| | `\/path\/to\/file.js` | `{file_path}` | $PATH | | `"specific text"` | `{content}` | $CONTENT | | `grep "pattern"` | `grep "{query}"` | $QUERY | | `--quality=0.8` | `--quality={n}` | @quality: | **Mutual Information:** ``` I(Concrete; Abstract) should be maximized I(Dross; Abstract) should be minimized ``` ### Stage 3: CITRINITAS - Golden Classification (φ.classify) **The Yellowing:** Apply the Golden Ratio to determine tincture potency. **Mathematical Operation:** ``` φ.classify: AbstractPattern → TinctureType Complexity(p) = (|Operations| × |Decisions| × |Iterations|) \/ 5 Type(p) = | Complexity < φ⁻¹ → Command | Complexity < φ → Skill | Complexity ≥ φ → Agent ``` **The Golden Section:** ``` 0 φ⁻¹ 1 φ φ² │────────│─────────│────────│────────│ │ Command│ Skill │ Skill │ Agent │ Simple Moderate Complex ``` **Override Conditions:** - Autonomous decision-making required → Agent - Step-by-step guidance needed → Skill - Simple execution sufficient → Command ### Stage 4: RUBEDO - Coagulation (Generate) **The Reddening:** Solidify the purified essence into material form. **Mathematical Operation:** ``` Generate: (AbstractPattern, TinctureType) → Tincture Rubedo(p, t) = Template(t) ⊗ Content(p) ``` **The Tensor Product:** ``` dim(Tincture) = dim(Template) × dim(Content) The tincture has multiplicative, not additive, structure. ``` --- ## The Seven Hermetic Principles of Distillation ### 1. MENTALISM - The All is Mind > *"The session patterns exist first as mental models."* ``` Intention: I → Hom(Session, Tincture) The morphism from intention to tincture must be clear before distillation. ``` **Application:** Clarify what you want to capture before extracting. ### 2. CORRESPONDENCE - As Above, So Below > *"The tincture structure mirrors the session structure."* ``` F: Session → Tincture preserves: F(f ∘ g) = F(f) ∘ F(g) Functors preserve structure across categories. ``` **Application:** Find the isomorphism. Tincture architecture should reflect session architecture. ### 3. VIBRATION - Nothing Rests > *"Complexity determines tincture frequency."* ``` Potency(t) = ω(Operations, Decisions, Iterations) Higher frequency (complexity) → higher potency tincture. ``` **Application:** Match the tincture type to the session's vibrational signature. ### 4. POLARITY - Opposites are Identical in Nature > *"Specificity and generality are one spectrum."* ``` Hom(Specific ⊗ General, Quality) ≅ Hom(Specific, General → Quality) Through currying, opposition becomes complementarity. ``` **Application:** Balance specific enough to be useful, general enough to be reusable. ### 5. RHYTHM - Everything Flows > *"Session flow distills into repeatable rhythm."* ``` dx\/dt = f(x), with periodic orbits The session has a tempo; the tincture captures that rhythm. ``` **Application:** Preserve the natural sequence of operations. ### 6. CAUSE & EFFECT - Nothing Escapes the Law > *"Each operation contributes to tincture purpose."* ``` If f is injective: f(a) = f(b) ⟹ a = b Every pattern element maps uniquely to tincture element. ``` **Application:** Be deliberate. Every instruction has consequences. ### 7. GENDER - Generation Requires Two > *"Analysis + Generation = Tincture"* ``` τ: Analysis × Synthesis → Tincture is bilinear Creation requires the dance of two principles. ``` **Application:** Balance analytical extraction with generative construction. --- ## Tincture Templates ### Command Template (Simple Extract - 1\/φ) ```markdown --- description: [One-line description derived from session purpose] allowed-tools: [Tools actually used in session] argument-hint: [Parameters extracted from session variables] --- # [Command Name] [Brief overview from session intent] ## Task $ARGUMENTS ## Process [Steps derived from session operations - abstracted] ## Output [Format observed in session] ``` **Naming Convention:** `{verb}-{noun}.md` or `{domain}.{action}.md` ### Skill Template (Tincture - φ) ```markdown --- name: [kebab-case-name] description: [What + When + Trigger phrases] --- # [Skill Name] [Overview paragraph explaining the skill] ## When to Use [Situations derived from session context] ## Mathematical Foundation [Category-theoretic or information-theoretic basis if applicable] ## Instructions ### Step 1: [First Operation] [Details with guidance] ### Step 2: [Second Operation] [Details with guidance] ... ## Examples [Concrete examples from session or generalized] ## Best Practices [Patterns observed working well] ``` **Naming Convention:** `{domain}-{capability}\/SKILL.md` ### Agent Template (Elixir - φ²) ```markdown --- name: [agent-name] description: | [Comprehensive description with examples] model: [opus for complex, sonnet for standard] color: [thematic color] tools: - [Tools used in session] --- You are the **[Agent Name]**, specializing in [domain]. ## Core Identity [Role distilled from session patterns] ## Mathematical Foundation [Category-theoretic structure if applicable] ## Your Process ### Phase 1: [First Phase] [Operations and decisions] ### Phase 2: [Second Phase] [Operations and decisions] ... ## Decision Framework [Branching logic from session] ## Error Handling [Recovery patterns observed] ## Quality Standards [Quality criteria from session] ``` **Naming Convention:** `{role}-{specialty}\/agent.md` --- ## Validation (M.bind) Apply the monad M to validate the distilled tincture: ``` M.bind: Tincture → ValidatedTincture M.bind(t) = | potency(t) ≥ 0.75 → Success(t) | otherwise → iterate(t) ``` ### Potency Metrics | Metric | Weight | Formula | |--------|--------|---------| | Completeness | 30% | |required sections| \/ |total sections| | | Universality | 25% | I(Tincture; NewContext) \/ H(Tincture) | | Specificity | 25% | I(Tincture; OriginalSession) \/ H(Session) | | Structure | 20% | |valid elements| \/ |total elements| | **Aggregate Potency:** ``` Potency = 0.30×Completeness + 0.25×Universality + 0.25×Specificity + 0.20×Structure ``` **The Potency Threshold:** ``` If Potency < 0.75: M.bind(refine(t)) recursively If Potency ≥ 0.75: emit(t) ``` ### Validation Checklist ``` Hermetic Principles: [ ] Mentalism: Clear intention captured [ ] Correspondence: Structure preserved [ ] Vibration: Complexity matched to type [ ] Polarity: Specific ↔ General balanced [ ] Rhythm: Natural flow maintained [ ] Cause & Effect: All operations purposeful [ ] Gender: Analysis + Synthesis complete Mathematical Properties: [ ] Functor laws satisfied [ ] Entropy reduced [ ] Mutual information preserved [ ] Golden ratio balance achieved ``` --- ## Output Format ```yaml DISTILLATION_COMPLETE: prima_materia: operations: [count] decisions: [count] iterations: [count] complexity_score: [value] phi_category: "[1\/φ | φ⁰ | φ | φ²]" information_metrics: session_entropy: [H(Session)] tincture_entropy: [H(Tincture)] mutual_information: [I(Session; Tincture)] compression_ratio: [H(Tincture) \/ H(Session)] tinctures: - type: "[Command | Skill | Agent]" name: "[name]" path: "[full path]" potency: [0-1] alchemical_trace: nigredo: "W.extract(session) → patterns" albedo: "F.map(patterns) → essence" citrinitas: "φ.classify(essence) → [type]" rubedo: "Generate([type]) → [path]" validation: "M.bind(tincture) → potency [score]" hermetic_alignment: mentalism: "[intention captured]" correspondence: "[structure preserved]" vibration: "[potency level]" polarity: "[specific↔general balance]" ``` --- ## Distillation Laws ### Law 1: Preserve Essence (Functor Faithfulness) ``` The distillation functor D must be faithful: D(f) = D(g) ⟹ f = g for session operations f, g No essential distinctions are collapsed. ``` ### Law 2: Reduce Entropy (Compression) ``` H(Tincture) < H(Session) The tincture is more ordered than the session. ``` ### Law 3: Maintain Mutual Information (Relevance) ``` I(Session; Tincture) ≥ φ⁻¹ × H(Session) At least 61.8% of session information is preserved. ``` ### Law 4: Balance at Golden Ratio (Quality) ``` Quality = φ⁻¹ × Specificity + φ × Generality = √5 Optimal balance achieved at the golden ratio. ``` ### Law 5: Match Potency to Complexity (Classification) ``` Type(Tincture) = φ.classify(Complexity(Session)) Higher complexity demands higher potency tincture. ``` ### Law 6: Iterate Until Threshold (Refinement) ``` M.bind^n(t) until Potency(t) ≥ 0.75 Monadic iteration continues until quality threshold. ``` ### Law 7: Satisfy Hermetic Principles (Alignment) ``` ∀ principle p ∈ Hermetic: align(Tincture, p) = True All seven principles must be satisfied. ``` --- ## Anti-Patterns (Failed Distillations) **The Mud** - Tincture with no clear structure *Category Error: D is not a functor (doesn't preserve composition)* *Violates: Correspondence, Structure* **The Vapor** - Too abstract, loses essential content *Category Error: Excessive quotienting, H(Tincture) << H(Session)* *Violates: Law 3, Specificity* **The Tar** - Too specific, not reusable *Category Error: Trivial quotient, Tincture ≈ Session* *Violates: Law 2, Generality* **The Explosion** - Complexity misclassified *Category Error: φ.classify returns wrong type* *Violates: Law 5, Vibration* **The Leech** - Extracts wrong patterns *Category Error: W.extract focuses on noise not signal* *Violates: Mentalism, Cause & Effect* --- ## The Alchemical Formula ``` SESSION CONTEXT │ │ ▼ │ ┌───────┐ │ │NIGREDO│ W.extract │ │ ~~~ │ Dissolution │ └───┬───┘ │ │ │ ▼ │ ┌───────┐ │ │ALBEDO │ F.map │ │ ○ │ Purification │ └───┬───┘ │ │ │ │ ┌────────────────────┐ │ └───►│ CITRINITAS │◄─────┘ │ │ │ φ.classify │ │ │ │ 1\/φ φ φ² │ │ │ │ │ │ │ Cmd Skill Agent │ │ │ └─────────┬──────────┘ │ ▼ ┌────────────────────┐ │ RUBEDO │ │ │ │ Generate ⊗ │ │ Template │ │ │ └─────────┬──────────┘ │ ▼ ┌────────────────────┐ │ VALIDATION │ │ │ │ M.bind until │ │ Potency ≥ 0.75 │ │ │ └─────────┬──────────┘ │ ▼ ┌────────────────────┐ │ TINCTURE │ │ │ │ H(T) < H(S) │ │ I(S;T) ≥ φ⁻¹H(S) │ │ Potency ≥ 0.75 │ │ │ └────────────────────┘ ``` --- ## Self-Reference This skill was itself distilled from the meta-pattern of creating reusable artifacts: ``` D(D) = distill\/SKILL.md The fixed point of the distillation functor. ``` **The Recursive Structure:** ``` Session(creating reusable artifacts) → D(Nigredo): Extract pattern of pattern-extraction → D(Albedo): Purify to essence of purification → D(Citrinitas): φ² (high complexity) → Agent\/Skill → D(Rubedo): Generate this document → D(Validate): Potency = 0.85 D(D) = This SKILL.md ``` --- ## Quick Reference Formulas ### Golden Ratio ``` φ = (1 + √5)\/2 ≈ 1.618033988749895 φ² = φ + 1 ≈ 2.618 1\/φ = φ - 1 ≈ 0.618 ``` ### Complexity Score ``` Complexity = (Operations × Decisions × Iterations) \/ 5 ``` ### Quality Balance ``` Quality = φ⁻¹ × Specificity + φ × Generality Optimal at Specificity × Generality = 1 ``` ### Potency ``` Potency = 0.30C + 0.25U + 0.25S + 0.20St Where: C=Completeness, U=Universality, S=Specificity, St=Structure ``` ### Information Preservation ``` I(Session; Tincture) ≥ φ⁻¹ × H(Session) ``` ### Entropy Reduction ``` H(Tincture) < H(Session) ``` --- ## The Alchemist's Creed ``` "Solve et Coagula" (Dissolve and Coagulate) From the prima materia of the session, Through the nigredo of dissolution, The albedo of purification, The citrinitas of golden classification, Emerges the rubedo of the tincture. What enters as chaos emerges as cosmos. What enters as ephemeral emerges as eternal. What enters as specific emerges as universal. ``` --- ## Version - **Specification Version**: 2.0 - **Foundation**: Category Theory (F, M, W) + Information Theory + Hermetic Alchemy + Golden Ratio - **Mathematical Models**: Functor, Monad, Comonad, Adjunction, Quotient Space, Fiber Bundle - **Created**: Distilled from session operations analysis and self-applied recursively --- *"In the Alembic, all things are transformed."* **— The Way of Distillation**