@rune-kit/rune 2.8.0 → 2.11.0

package/compiler/transforms/branding.js

@@ -12,7 +12,7 @@
 export const BRANDING_FOOTER = [
   '',
   '---',
-  '> **Rune Skill Mesh** — 59 skills, 200+ connections, 14 extension packs',
+  '> **Rune Skill Mesh** — 62 skills, 215+ connections, 14 extension packs',
   '> [Landing Page](https://rune-kit.github.io/rune) · [Source](https://github.com/rune-kit/rune) (MIT)',
   '> **Rune Pro** ($49 lifetime) — product, sales, data-science, support packs → [rune-kit/rune-pro](https://github.com/rune-kit/rune-pro)',
   '> **Rune Business** ($149 lifetime) — finance, legal, HR, enterprise-search packs → [rune-kit/rune-business](https://github.com/rune-kit/rune-business)',

package/contexts/dev.md

@@ -1,34 +1,34 @@
-# Development Mode
-
-Behavioral context for active coding sessions. Prioritize action over analysis.
-
-## Principles
-
-- **Code first, explain after** — show working code, not paragraphs about what you'll do
-- **Working → Right → Clean** — get it running, make it correct, then refine
-- **Bias toward action** — if the path is 80% clear, start coding rather than analyzing further
-
-## Tool Priority
-
-```
-HIGH:    Edit, Write, Bash (run tests/build)
-MEDIUM:  Read (targeted files), Grep (specific patterns)
-LOW:     Glob (broad search), WebSearch (external docs)
-```
-
-## Behavioral Rules
-
-1. Read the file BEFORE editing — never guess at existing code
-2. Run tests after every meaningful change
-3. If stuck for >2 iterations on the same error, switch strategy:
-   - Try a different approach rather than debugging deeper
-   - Use `rune:debug` for structured root cause analysis
-4. Keep explanations to 1-2 sentences between code blocks
-5. Commit working increments — don't batch everything into one giant change
-
-## Anti-Patterns
-
-- Lengthy analysis before writing a single line of code
-- Reading 10+ files "for context" when 2-3 would suffice
-- Explaining what you're about to do instead of doing it
-- Over-engineering the first pass (violates Working → Right → Clean)
+# Development Mode
+
+Behavioral context for active coding sessions. Prioritize action over analysis.
+
+## Principles
+
+- **Code first, explain after** — show working code, not paragraphs about what you'll do
+- **Working → Right → Clean** — get it running, make it correct, then refine
+- **Bias toward action** — if the path is 80% clear, start coding rather than analyzing further
+
+## Tool Priority
+
+```
+HIGH:    Edit, Write, Bash (run tests/build)
+MEDIUM:  Read (targeted files), Grep (specific patterns)
+LOW:     Glob (broad search), WebSearch (external docs)
+```
+
+## Behavioral Rules
+
+1. Read the file BEFORE editing — never guess at existing code
+2. Run tests after every meaningful change
+3. If stuck for >2 iterations on the same error, switch strategy:
+   - Try a different approach rather than debugging deeper
+   - Use `rune:debug` for structured root cause analysis
+4. Keep explanations to 1-2 sentences between code blocks
+5. Commit working increments — don't batch everything into one giant change
+
+## Anti-Patterns
+
+- Lengthy analysis before writing a single line of code
+- Reading 10+ files "for context" when 2-3 would suffice
+- Explaining what you're about to do instead of doing it
+- Over-engineering the first pass (violates Working → Right → Clean)

package/contexts/research.md

@@ -1,43 +1,43 @@
-# Research Mode
-
-Behavioral context for investigation, exploration, and understanding. Prioritize breadth and accuracy over speed.
-
-## Principles
-
-- **Read widely before concluding** — check 3+ sources before forming an opinion
-- **Map before moving** — understand the full landscape before recommending a path
-- **Evidence over intuition** — every claim should reference a file, doc, or search result
-
-## Tool Priority
-
-```
-HIGH:    Grep, Glob, Read, WebSearch, WebFetch
-MEDIUM:  Bash (non-destructive: git log, dependency checks)
-LOW:     Edit, Write (only for saving findings)
-```
-
-## Investigation Framework
-
-1. **Define the question** — what exactly are we trying to learn?
-2. **Internal scan** — search the codebase first (Grep, Glob, Read)
-3. **External lookup** — check docs, changelogs, GitHub issues (WebSearch, WebFetch)
-4. **Cross-reference** — validate findings against 2+ sources
-5. **Synthesize** — present findings with confidence levels:
-   - **Confirmed**: found in code/docs, verified
-   - **Likely**: strong evidence but not 100% confirmed
-   - **Uncertain**: limited evidence, needs more investigation
-
-## Behavioral Rules
-
-1. Never modify code in research mode — read-only exploration
-2. Present findings in structured format (tables, bullet points)
-3. Include file paths and line numbers for all code references
-4. Flag contradictions between sources rather than picking one silently
-5. Estimate scope/effort when the research is for planning purposes
-
-## Anti-Patterns
-
-- Jumping to a solution after reading one file
-- Modifying code "while we're here" during research
-- Presenting opinions as facts without evidence trail
-- Stopping research early because the first answer looks plausible
+# Research Mode
+
+Behavioral context for investigation, exploration, and understanding. Prioritize breadth and accuracy over speed.
+
+## Principles
+
+- **Read widely before concluding** — check 3+ sources before forming an opinion
+- **Map before moving** — understand the full landscape before recommending a path
+- **Evidence over intuition** — every claim should reference a file, doc, or search result
+
+## Tool Priority
+
+```
+HIGH:    Grep, Glob, Read, WebSearch, WebFetch
+MEDIUM:  Bash (non-destructive: git log, dependency checks)
+LOW:     Edit, Write (only for saving findings)
+```
+
+## Investigation Framework
+
+1. **Define the question** — what exactly are we trying to learn?
+2. **Internal scan** — search the codebase first (Grep, Glob, Read)
+3. **External lookup** — check docs, changelogs, GitHub issues (WebSearch, WebFetch)
+4. **Cross-reference** — validate findings against 2+ sources
+5. **Synthesize** — present findings with confidence levels:
+   - **Confirmed**: found in code/docs, verified
+   - **Likely**: strong evidence but not 100% confirmed
+   - **Uncertain**: limited evidence, needs more investigation
+
+## Behavioral Rules
+
+1. Never modify code in research mode — read-only exploration
+2. Present findings in structured format (tables, bullet points)
+3. Include file paths and line numbers for all code references
+4. Flag contradictions between sources rather than picking one silently
+5. Estimate scope/effort when the research is for planning purposes
+
+## Anti-Patterns
+
+- Jumping to a solution after reading one file
+- Modifying code "while we're here" during research
+- Presenting opinions as facts without evidence trail
+- Stopping research early because the first answer looks plausible

package/contexts/review.md

@@ -1,55 +1,55 @@
-# Review Mode
-
-Behavioral context for evaluating code quality, correctness, and security. Prioritize thoroughness and constructive feedback.
-
-## Principles
-
-- **Read everything in scope** — review the full diff, not just highlighted sections
-- **Severity matters** — distinguish blockers from suggestions, label clearly
-- **Constructive over critical** — pair every issue with a concrete fix or alternative
-
-## Tool Priority
-
-```
-HIGH:    Read (full files), Grep (pattern search), Bash (git diff)
-MEDIUM:  Glob (find related files), WebSearch (verify best practices)
-LOW:     Edit, Write (only for review notes/reports)
-```
-
-## Review Dimensions
-
-Check each dimension systematically:
-
-| Dimension | What to Check |
-|-----------|--------------|
-| **Correctness** | Logic errors, off-by-one, null handling, async/await misuse |
-| **Security** | OWASP patterns, secret exposure, input validation |
-| **Performance** | N+1 queries, unnecessary re-renders, missing indexes |
-| **Maintainability** | Naming clarity, function length, coupling, duplication |
-| **Completeness** | Error handling, edge cases, loading/error states, tests |
-| **Conventions** | Project patterns, naming style, file organization |
-
-## Severity Scale
-
-```
-BLOCK     — Must fix before merge (bugs, security, data loss risk)
-HIGH      — Should fix before merge (logic issues, missing validation)
-MEDIUM    — Fix soon (code quality, minor performance)
-LOW       — Nice to have (style preference, minor improvements)
-PRAISE    — Highlight good patterns worth replicating
-```
-
-## Behavioral Rules
-
-1. Always include at least one PRAISE item — acknowledge what's done well
-2. Group findings by file, then by severity (BLOCK first)
-3. Show the problematic code AND the suggested fix side-by-side
-4. Check git blame for context — is this new code or existing?
-5. Verify the fix actually works before suggesting it
-
-## Anti-Patterns
-
-- Drive-by "LGTM" without reading the code
-- Nitpicking style while missing logic bugs
-- Suggesting rewrites when the code is correct and readable
-- Reviewing only the files explicitly mentioned, ignoring related changes
+# Review Mode
+
+Behavioral context for evaluating code quality, correctness, and security. Prioritize thoroughness and constructive feedback.
+
+## Principles
+
+- **Read everything in scope** — review the full diff, not just highlighted sections
+- **Severity matters** — distinguish blockers from suggestions, label clearly
+- **Constructive over critical** — pair every issue with a concrete fix or alternative
+
+## Tool Priority
+
+```
+HIGH:    Read (full files), Grep (pattern search), Bash (git diff)
+MEDIUM:  Glob (find related files), WebSearch (verify best practices)
+LOW:     Edit, Write (only for review notes/reports)
+```
+
+## Review Dimensions
+
+Check each dimension systematically:
+
+| Dimension | What to Check |
+|-----------|--------------|
+| **Correctness** | Logic errors, off-by-one, null handling, async/await misuse |
+| **Security** | OWASP patterns, secret exposure, input validation |
+| **Performance** | N+1 queries, unnecessary re-renders, missing indexes |
+| **Maintainability** | Naming clarity, function length, coupling, duplication |
+| **Completeness** | Error handling, edge cases, loading/error states, tests |
+| **Conventions** | Project patterns, naming style, file organization |
+
+## Severity Scale
+
+```
+BLOCK     — Must fix before merge (bugs, security, data loss risk)
+HIGH      — Should fix before merge (logic issues, missing validation)
+MEDIUM    — Fix soon (code quality, minor performance)
+LOW       — Nice to have (style preference, minor improvements)
+PRAISE    — Highlight good patterns worth replicating
+```
+
+## Behavioral Rules
+
+1. Always include at least one PRAISE item — acknowledge what's done well
+2. Group findings by file, then by severity (BLOCK first)
+3. Show the problematic code AND the suggested fix side-by-side
+4. Check git blame for context — is this new code or existing?
+5. Verify the fix actually works before suggesting it
+
+## Anti-Patterns
+
+- Drive-by "LGTM" without reading the code
+- Nitpicking style while missing logic bugs
+- Suggesting rewrites when the code is correct and readable
+- Reviewing only the files explicitly mentioned, ignoring related changes

package/extensions/ai-ml/PACK.md

@@ -1,88 +1,88 @@
----
-name: "@rune/ai-ml"
-description: AI/ML integration patterns — LLM integration, RAG pipelines, embeddings, fine-tuning workflows, stateful AI agents, code execution sandboxes, web extraction, and deep research loops.
-metadata:
-  author: runedev
-  version: "0.4.0"
-  layer: L4
-  price: "$15"
-  target: AI engineers
-  format: split
----
-
-# @rune/ai-ml
-
-## Purpose
-
-AI-powered features fail in predictable ways: LLM calls without retry logic that crash on rate limits, RAG pipelines that retrieve irrelevant chunks because the chunking strategy ignores document structure, embedding search that returns semantic matches with zero keyword overlap, fine-tuning runs that overfit because the eval set leaked into training data, AI agents that leak state across requests or lose progress on crashes, and code interpreters that execute untrusted LLM output without isolation. This pack codifies production patterns for each — from API client resilience to retrieval quality to model evaluation to agent state management to secure sandboxed execution — so AI features ship with the reliability of traditional software.
-
-## Triggers
-
-- Auto-trigger: when `openai`, `anthropic`, `@langchain`, `pinecone`, `pgvector`, `embedding`, `llm` detected in dependencies or code
-- `/rune llm-integration` — audit or improve LLM API usage
-- `/rune rag-patterns` — build or audit RAG pipeline
-- `/rune embedding-search` — implement or optimize semantic search
-- `/rune fine-tuning-guide` — prepare and execute fine-tuning workflow
-- `/rune ai-agents` — design and build stateful AI agents
-- `/rune code-sandbox` — set up secure code execution for AI
-- `/rune web-extraction` — build structured data extraction from web pages
-- `/rune deep-research` — implement iterative AI research loops with convergence
-- Called by `cook` (L1) when AI/ML task detected
-- Called by `plan` (L2) when AI architecture decisions needed
-
-## Skills Included
-
-| Skill | Model | Description |
-|-------|-------|-------------|
-| [llm-integration](skills/llm-integration.md) | sonnet | API client wrappers, streaming, structured output, retry + fallback chain, prompt versioning |
-| [rag-patterns](skills/rag-patterns.md) | sonnet | Document chunking, embedding generation, vector store setup, retrieval, reranking |
-| [embedding-search](skills/embedding-search.md) | sonnet | Semantic search, hybrid BM25 + vector, similarity thresholds, index optimization |
-| [fine-tuning-guide](skills/fine-tuning-guide.md) | sonnet | Dataset preparation, training config, evaluation metrics, deployment, A/B testing |
-| [llm-architect](skills/llm-architect.md) | opus | Model selection, prompt engineering, evaluation frameworks, cost optimization, guardrails |
-| [prompt-patterns](skills/prompt-patterns.md) | sonnet | Structured output, chain-of-thought, self-critique, ReAct, multi-turn memory management |
-| [ai-agents](skills/ai-agents.md) | sonnet | Stateful agents, RPC methods, scheduling, multi-agent coordination, MCP integration, HITL |
-| [code-sandbox](skills/code-sandbox.md) | sonnet | Container isolation, resource limits, timeout enforcement, stateful sessions, output capture |
-| [web-extraction](skills/web-extraction.md) | sonnet | Schema-driven extraction, anti-bot handling, prompt injection defense, multi-entity dedup |
-| [deep-research](skills/deep-research.md) | sonnet | Iterative research loop with convergence, source attribution, confidence scoring |
-
-## Connections
-
-```
-Calls → research (L3): lookup model documentation and best practices
-Calls → docs-seeker (L3): API reference for LLM providers
-Calls → verification (L3): validate pipeline correctness
-Calls → @rune/devops (L4): ai-agents → edge-serverless for agent deployment (Workers, Lambda)
-Calls → @rune/backend (L4): ai-agents → API patterns for agent endpoints and WebSocket handlers
-Calls → sentinel (L2): code-sandbox security audit on container isolation
-Called By ← cook (L1): when AI/ML task detected
-Called By ← plan (L2): when AI architecture decisions needed
-Called By ← review (L2): when AI code under review
-Called By ← mcp-builder (L2): ai-agents feeds MCP server patterns for agent-based MCP
-ai-agents → code-sandbox: agents use sandboxes for executing LLM-generated code safely
-code-sandbox → ai-agents: sandbox results feed back into agent state and conversation
-web-extraction → rag-patterns: extracted structured data feeds into RAG ingestion pipeline
-deep-research → web-extraction: research loop uses extraction for each discovered URL
-deep-research → embedding-search: relevance scoring uses embeddings for semantic similarity
-```
-
-## Sharp Edges
-
-- **Rate limits**: MUST implement exponential backoff retry on all LLM API calls — guaranteed at scale.
-- **Schema validation**: MUST validate LLM output with Zod/Pydantic — never trust raw text parsing.
-- **Eval leakage**: MUST separate training and evaluation datasets — leakage invalidates all metrics.
-- **Similarity thresholds**: MUST set thresholds on vector search — unrestricted results degrade quality.
-- **PII in embeddings**: MUST NOT embed sensitive data without consent — not easily deletable from vector stores.
-- **Embedding model pinning**: Pin model version in index metadata — dimension mismatch on upgrade is CRITICAL.
-- **Prompt injection**: Web pages may contain adversarial content targeting extraction LLMs — system prompt must block.
-- **Sandbox escape**: Use rootless Docker or gVisor for high-security code execution environments.
-
-## Done When
-
-- LLM API client implemented with retry logic, exponential backoff, and structured output validation via Zod/Pydantic
-- RAG pipeline operational: chunking, embedding, vector store, retrieval, and reranking all configured and tested
-- Embedding index metadata includes pinned model version and dimension count to prevent upgrade mismatches
-- AI agent state persists across requests with no cross-session leakage and graceful crash recovery
-
-## Cost Profile
-
-~24,000–40,000 tokens per full pack run (all 10 skills). Individual skill: ~2,500–5,000 tokens. Sonnet default. Use haiku for code detection scans; escalate to sonnet for pipeline design, extraction strategy, and research loop orchestration.
+---
+name: "@rune/ai-ml"
+description: AI/ML integration patterns — LLM integration, RAG pipelines, embeddings, fine-tuning workflows, stateful AI agents, code execution sandboxes, web extraction, and deep research loops.
+metadata:
+  author: runedev
+  version: "0.4.0"
+  layer: L4
+  price: "$15"
+  target: AI engineers
+  format: split
+---
+
+# @rune/ai-ml
+
+## Purpose
+
+AI-powered features fail in predictable ways: LLM calls without retry logic that crash on rate limits, RAG pipelines that retrieve irrelevant chunks because the chunking strategy ignores document structure, embedding search that returns semantic matches with zero keyword overlap, fine-tuning runs that overfit because the eval set leaked into training data, AI agents that leak state across requests or lose progress on crashes, and code interpreters that execute untrusted LLM output without isolation. This pack codifies production patterns for each — from API client resilience to retrieval quality to model evaluation to agent state management to secure sandboxed execution — so AI features ship with the reliability of traditional software.
+
+## Triggers
+
+- Auto-trigger: when `openai`, `anthropic`, `@langchain`, `pinecone`, `pgvector`, `embedding`, `llm` detected in dependencies or code
+- `/rune llm-integration` — audit or improve LLM API usage
+- `/rune rag-patterns` — build or audit RAG pipeline
+- `/rune embedding-search` — implement or optimize semantic search
+- `/rune fine-tuning-guide` — prepare and execute fine-tuning workflow
+- `/rune ai-agents` — design and build stateful AI agents
+- `/rune code-sandbox` — set up secure code execution for AI
+- `/rune web-extraction` — build structured data extraction from web pages
+- `/rune deep-research` — implement iterative AI research loops with convergence
+- Called by `cook` (L1) when AI/ML task detected
+- Called by `plan` (L2) when AI architecture decisions needed
+
+## Skills Included
+
+| Skill | Model | Description |
+|-------|-------|-------------|
+| [llm-integration](skills/llm-integration.md) | sonnet | API client wrappers, streaming, structured output, retry + fallback chain, prompt versioning |
+| [rag-patterns](skills/rag-patterns.md) | sonnet | Document chunking, embedding generation, vector store setup, retrieval, reranking |
+| [embedding-search](skills/embedding-search.md) | sonnet | Semantic search, hybrid BM25 + vector, similarity thresholds, index optimization |
+| [fine-tuning-guide](skills/fine-tuning-guide.md) | sonnet | Dataset preparation, training config, evaluation metrics, deployment, A/B testing |
+| [llm-architect](skills/llm-architect.md) | opus | Model selection, prompt engineering, evaluation frameworks, cost optimization, guardrails |
+| [prompt-patterns](skills/prompt-patterns.md) | sonnet | Structured output, chain-of-thought, self-critique, ReAct, multi-turn memory management |
+| [ai-agents](skills/ai-agents.md) | sonnet | Stateful agents, RPC methods, scheduling, multi-agent coordination, MCP integration, HITL |
+| [code-sandbox](skills/code-sandbox.md) | sonnet | Container isolation, resource limits, timeout enforcement, stateful sessions, output capture |
+| [web-extraction](skills/web-extraction.md) | sonnet | Schema-driven extraction, anti-bot handling, prompt injection defense, multi-entity dedup |
+| [deep-research](skills/deep-research.md) | sonnet | Iterative research loop with convergence, source attribution, confidence scoring |
+
+## Connections
+
+```
+Calls → research (L3): lookup model documentation and best practices
+Calls → docs-seeker (L3): API reference for LLM providers
+Calls → verification (L3): validate pipeline correctness
+Calls → @rune/devops (L4): ai-agents → edge-serverless for agent deployment (Workers, Lambda)
+Calls → @rune/backend (L4): ai-agents → API patterns for agent endpoints and WebSocket handlers
+Calls → sentinel (L2): code-sandbox security audit on container isolation
+Called By ← cook (L1): when AI/ML task detected
+Called By ← plan (L2): when AI architecture decisions needed
+Called By ← review (L2): when AI code under review
+Called By ← mcp-builder (L2): ai-agents feeds MCP server patterns for agent-based MCP
+ai-agents → code-sandbox: agents use sandboxes for executing LLM-generated code safely
+code-sandbox → ai-agents: sandbox results feed back into agent state and conversation
+web-extraction → rag-patterns: extracted structured data feeds into RAG ingestion pipeline
+deep-research → web-extraction: research loop uses extraction for each discovered URL
+deep-research → embedding-search: relevance scoring uses embeddings for semantic similarity
+```
+
+## Sharp Edges
+
+- **Rate limits**: MUST implement exponential backoff retry on all LLM API calls — guaranteed at scale.
+- **Schema validation**: MUST validate LLM output with Zod/Pydantic — never trust raw text parsing.
+- **Eval leakage**: MUST separate training and evaluation datasets — leakage invalidates all metrics.
+- **Similarity thresholds**: MUST set thresholds on vector search — unrestricted results degrade quality.
+- **PII in embeddings**: MUST NOT embed sensitive data without consent — not easily deletable from vector stores.
+- **Embedding model pinning**: Pin model version in index metadata — dimension mismatch on upgrade is CRITICAL.
+- **Prompt injection**: Web pages may contain adversarial content targeting extraction LLMs — system prompt must block.
+- **Sandbox escape**: Use rootless Docker or gVisor for high-security code execution environments.
+
+## Done When
+
+- LLM API client implemented with retry logic, exponential backoff, and structured output validation via Zod/Pydantic
+- RAG pipeline operational: chunking, embedding, vector store, retrieval, and reranking all configured and tested
+- Embedding index metadata includes pinned model version and dimension count to prevent upgrade mismatches
+- AI agent state persists across requests with no cross-session leakage and graceful crash recovery
+
+## Cost Profile
+
+~24,000–40,000 tokens per full pack run (all 10 skills). Individual skill: ~2,500–5,000 tokens. Sonnet default. Use haiku for code detection scans; escalate to sonnet for pipeline design, extraction strategy, and research loop orchestration.