@rune-kit/rune 2.1.1

package/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: sequential-thinking
+description: "Step-by-step complex reasoning for multi-variable problems. Breaks interconnected decisions into ordered logical steps with bias detection, reversibility classification, and second-order effect tracking."
+metadata:
+  author: runedev
+  version: "0.3.0"
+  layer: L3
+  model: sonnet
+  group: reasoning
+  tools: "Read, Glob, Grep"
+---
+
+# sequential-thinking
+
+## Purpose
+
+Multi-variable analysis utility for decisions where factors are interdependent and order of reasoning matters. Receives a decision problem, classifies reversibility, detects cognitive biases, maps variable dependencies, processes them in dependency order, checks for second-order effects, and returns a structured decision tree with final recommendation. Stateless — no memory between calls.
+
+## Calls (outbound)
+
+None — pure L3 reasoning utility.
+
+## Called By (inbound)
+
+- `debug` (L2): multi-factor bugs with interacting causes
+- `plan` (L2): complex architecture with many trade-offs
+- `brainstorm` (L2): evaluating approaches with many variables
+
+## When to Use
+
+Invoke this skill when:
+- The decision has more than 3 interacting variables
+- Choosing option A changes what options are valid for B and C
+- Architecture decisions have cascading downstream effects
+- Trade-off analysis where constraints eliminate entire solution branches
+
+Do NOT use for simple linear analysis — `problem-solver` is more efficient for single-dimension reasoning.
+
+## Execution
+
+### Input
+
+```
+decision: string        — the decision or problem to analyze
+variables: string[]     — (optional) pre-identified factors; if omitted, skill identifies them
+constraints: string[]   — (optional) hard limits that eliminate options
+goal: string            — (optional) success criteria or desired outcome
+```
+
+### Step 0 — Reversibility Classification
+
+Before investing analytical effort, classify the decision:
+
+| Type | Definition | Analytical Effort |
+|------|-----------|-------------------|
+| **Two-way door** | Reversible, can iterate, low switching cost | Decide quickly, set review date. Light analysis. |
+| **One-way door** | Irreversible, high stakes, costly to reverse | Full sequential analysis. Deep reasoning. |
+| **Partially reversible** | Some aspects reversible, some not | Full analysis on irreversible aspects, light on reversible. |
+
+If two-way door → streamline: skip Step 4 (second-order) and Step 5 (bias cross-check). State reasoning.
+
+### Step 1 — Identify All Variables
+
+List every factor that affects the decision. For each variable, record:
+- Name and description
+- Possible values or range
+- Whether it is controllable (we can choose) or fixed (constraint from environment)
+
+If the caller provided `variables`, validate and expand the list. If omitted, derive from the decision statement.
+
+### Step 2 — Map Dependencies
+
+For each pair of variables, determine if a dependency exists:
+- `[A] constrains [B]`: choosing a value for A limits valid values for B
+- `[A] influences [B]`: A affects the cost/benefit calculation for B but does not eliminate options
+- `[A] independent of [B]`: no relationship
+
+Document dependencies as: `[Variable A] → [Variable B]: [type and reason]`
+
+Identify which variables have the most outbound dependencies — those must be resolved first.
+
+### Step 3 — Evaluate in Dependency Order
+
+Sort variables from most-constrained (fixed / most depended upon) to least-constrained (free / most flexible). Process in that order:
+
+For each variable in sequence:
+- State current known state of all previously resolved variables
+- Evaluate valid options given those constraints
+- Select the best option with explicit reasoning
+- Record the conclusion and how it affects downstream variables
+
+Do not jump ahead — each step must reference the conclusions of prior steps.
+
+**Running state block** at each step:
+
+```
+State after Step N:
+- [Variable A]: resolved to [value] because [reason]
+- [Variable B]: resolved to [value] because [reason]
+- Remaining: [Variable C], [Variable D]
+```
+
+### Step 4 — Second-Order Effects Check
+
+After all variables are resolved, apply second-order thinking:
+
+For each resolved variable, ask: **"And then what?"**
+
+| Variable | First-Order Effect | Second-Order Effect | Risk Level |
+|----------|-------------------|--------------------|-|
+| [A = value] | [immediate consequence] | [consequence of consequence] | low/medium/high |
+
+Flag any second-order effect that:
+- Contradicts the goal stated in the input
+- Creates a feedback loop (reinforcing or balancing)
+- Affects stakeholders not considered in the analysis
+- Would flip a previous variable's optimal value
+
+If a dangerous second-order effect is found → revisit the affected variable with this new information.
+
+### Step 5 — Bias Cross-Check
+
+Check the analysis for the 3 biases most dangerous to multi-variable decisions:
+
+| Bias | Detection Question | If Detected |
+|------|-------------------|-------------|
+| **Anchoring** | Did the first variable we resolved disproportionately constrain all others? Would the result differ if we started from a different variable? | Re-evaluate with a different starting variable. Compare results. |
+| **Status Quo** | Did we give an unfair advantage to "keep current approach" for any variable? Would we choose this if starting from scratch? | Evaluate current state with same rigor as alternatives. |
+| **Overconfidence** | How confident are we in each variable's resolution? Are confidence intervals wide enough? | Assign explicit confidence % to each resolution. Flag any > 90% without strong evidence. |
+
+If bias is detected → note it in the report and state whether it changes the recommendation.
+
+### Step 6 — Synthesize
+
+After all variables are resolved and cross-checked:
+- Combine all per-step conclusions into a coherent final recommendation
+- Identify any variables that remained ambiguous — state what additional information would resolve them
+- Assess overall confidence: `high` (all variables resolved cleanly), `medium` (1-2 ambiguous), `low` (major uncertainty remains)
+- Note the reversibility classification from Step 0 — if two-way door, include a review date
+
+### Step 7 — Report
+
+Return the full decision tree and recommendation in the output format below.
+
+## Constraints
+
+- Never evaluate variable B before all variables that constrain B are resolved
+- If a dependency cycle is detected, flag it explicitly and break the cycle by treating one variable as a fixed assumption
+- Use Sonnet — reasoning depth and coherence across many steps matters
+- If more than 8 variables are identified, group related ones into composite variables to keep analysis tractable
+- MUST classify reversibility (Step 0) before investing analytical effort
+- MUST check for second-order effects on one-way door decisions
+- MUST run bias cross-check on one-way door decisions
+
+## Output Format
+
+```
+## Sequential Analysis: [Decision]
+
+### Reversibility: [two-way door / one-way door / partially reversible]
+[One sentence reasoning. If two-way: "Light analysis — decide quickly, review in [timeframe]."]
+
+### Variables Identified
+| Variable | Possible Values | Type |
+|----------|----------------|------|
+| [A]      | [options]      | controllable / fixed |
+| [B]      | [options]      | controllable / fixed |
+
+### Dependency Map
+- [A] → [B]: [type] — [reason]
+- [C] → [A]: [type] — [reason]
+
+### Step-by-Step Evaluation
+1. **[Variable A]** (no dependencies — evaluate first)
+   - Options: [x, y, z]
+   - Reasoning: [why one is better given constraints]
+   - Conclusion: **[chosen value]** (confidence: X%)
+   - State: { A: [value] }
+
+2. **[Variable B]** (depends on A = [value])
+   - Options remaining: [filtered list]
+   - Reasoning: [updated analysis given A's value]
+   - Conclusion: **[chosen value]** (confidence: X%)
+   - State: { A: [value], B: [value] }
+
+...
+
+### Second-Order Effects (one-way door only)
+| Variable | First-Order | Second-Order | Risk |
+|----------|------------|-------------|------|
+| [A] | [effect] | [and then what?] | low/medium/high |
+
+### Bias Check
+- ⚠️ [Bias]: [detection result] → [action taken or "not detected"]
+
+### Ambiguities
+- [variable or factor that could not be fully resolved, and what information would resolve it]
+
+### Final Recommendation
+[synthesized conclusion incorporating all resolved variables, with confidence level]
+
+- **Confidence**: high | medium | low
+- **Key assumption**: [the most critical assumption this recommendation depends on]
+- **Review date**: [when to revisit this decision, especially for two-way doors]
+```
+
+## Sharp Edges
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Evaluating variable B before all variables constraining B are resolved | CRITICAL | Dependency order is mandatory — sort by constraint depth first |
+| Dependency cycle detected but not flagged | HIGH | Break cycle by treating one variable as a fixed assumption — flag explicitly |
+| More than 8 variables without grouping | MEDIUM | Group related variables — keep tractable, not exhaustive |
+| Final recommendation missing confidence level | MEDIUM | Confidence (high/medium/low) is required — ambiguities drive confidence down |
+| Full analysis on a two-way door decision | MEDIUM | Step 0 classifies reversibility — two-way doors get light analysis |
+| Ignoring second-order effects on irreversible decisions | HIGH | Step 4 is mandatory for one-way doors — "and then what?" |
+| Anchoring on first variable resolved | MEDIUM | Bias cross-check Step 5 — test if different starting variable changes result |
+| No review date on reversible decisions | LOW | Two-way doors MUST include a review date — iterate, don't commit |
+
+## Done When
+
+- Reversibility classified (two-way / one-way / partial)
+- All variables identified and typed (controllable vs. fixed)
+- Dependency map documented (A constrains B, C influences D)
+- Variables evaluated in dependency order with running state block and confidence % at each step
+- Second-order effects checked (one-way door decisions)
+- Bias cross-check completed (anchoring, status quo, overconfidence)
+- Ambiguities listed with what information would resolve them
+- Final recommendation emitted with confidence level and review date
+- Sequential Analysis report in output format
+
+## Cost Profile
+
+~500-1500 tokens input, ~500-1200 tokens output. Sonnet for reasoning depth.

package/skills/session-bridge/SKILL.md

@@ -0,0 +1,287 @@
+---
+name: session-bridge
+description: Universal context persistence across sessions. Auto-saves decisions, conventions, and progress to .rune/ files. Loads state at session start. Use when any skill makes architectural decisions or establishes patterns that must survive session boundaries.
+metadata:
+  author: runedev
+  version: "0.2.0"
+  layer: L3
+  model: haiku
+  group: state
+  tools: "Read, Write, Edit, Glob, Grep"
+---
+
+# session-bridge
+
+## Purpose
+
+Solve the #1 developer complaint: context loss across sessions. Session-bridge auto-saves critical context to `.rune/` files in the project directory, and loads them at session start. Every new session knows exactly where the last one left off.
+
+## Triggers
+
+- Auto-trigger: when an architectural decision is made
+- Auto-trigger: when a convention/pattern is established
+- Auto-trigger: before context compaction
+- Auto-trigger: at session end (stop hook)
+- `/rune status` — manual state check
+
+## Calls (outbound)
+
+# Exception: L3→L3 coordination (same pattern as hallucination-guard → research)
+- `integrity-check` (L3): verify .rune/ file integrity before loading state
+
+## Called By (inbound)
+
+- `cook` (L1): auto-save decisions during feature implementation
+- `rescue` (L1): state management throughout refactoring
+- `context-engine` (L3): save state before compaction
+
+## State Files Managed
+
+```
+.rune/
+├── decisions.md      — Architectural decisions log
+├── conventions.md    — Established patterns & style
+├── progress.md       — Task progress tracker
+└── session-log.md    — Brief log of each session
+```
+
+## Execution
+
+### Save Mode (end of session or pre-compaction)
+
+#### Step 1 — Gather state
+
+Collect from the current session:
+- All architectural or technology choices made (language, library, approach)
+- Conventions established (naming patterns, file structure, coding style)
+- Tasks completed, in-progress, and blocked
+- A one-paragraph summary of what this session accomplished
+
+**Python project context** (if `pyproject.toml` or `setup.py` detected):
+- Python version (from `.python-version`, `pyproject.toml` `requires-python`, or `python --version`)
+- Virtual environment path and type (venv, poetry, uv, conda)
+- Installed optional dependency groups (e.g., `[dev]`, `[test]`, `[embeddings]`)
+- Last mypy error count (from most recent verification run, if available)
+- Last test coverage percentage (from most recent test run, if available)
+- DB migration version (if alembic, django migrations, or similar detected)
+
+#### Step 2 — Update .rune/decisions.md
+
+Use `Glob` to check if `.rune/decisions.md` exists. If not, use `Write` to create it with a `# Decisions Log` header.
+
+For each architectural decision from this session, use `Edit` to append to `.rune/decisions.md`:
+
+```markdown
+## [YYYY-MM-DD HH:MM] Decision: <title>
+
+**Context:** Why this decision was needed
+**Decision:** What was decided
+**Rationale:** Why this approach over alternatives
+**Impact:** What files/modules are affected
+```
+
+#### Step 3 — Update .rune/conventions.md
+
+Use `Glob` to check if `.rune/conventions.md` exists. If not, use `Write` to create it with a `# Conventions` header.
+
+For each pattern or convention established, use `Edit` to append to `.rune/conventions.md`:
+
+```markdown
+## [YYYY-MM-DD] Convention: <title>
+
+**Pattern:** Description of the convention
+**Example:** Code example showing the pattern
+**Applies to:** Where this convention should be followed
+```
+
+Python example:
+```markdown
+## [YYYY-MM-DD] Convention: Async-First I/O
+
+**Pattern:** All I/O functions use `async def`; blocking calls (`requests`, `open`, `time.sleep`) are forbidden in async modules
+**Example:** `async def fetch_data(): async with httpx.AsyncClient() as client: ...`
+**Applies to:** All modules in `src/` — sync wrappers only in CLI entry points
+```
+
+#### Step 4 — Update .rune/progress.md
+
+Use `Glob` to check if `.rune/progress.md` exists. If not, use `Write` to create it with a `# Progress` header.
+
+Use `Edit` to append the current task status to `.rune/progress.md`:
+
+```markdown
+## [YYYY-MM-DD HH:MM] Session Summary
+
+**Completed:**
+- [x] Task description
+
+**In Progress:**
+- [ ] Task description (step X/Y)
+
+**Blocked:**
+- [ ] Task description — reason
+
+**Next Session Should:**
+- Start with X
+- Continue Y from step Z
+
+**Python Context** (if Python project):
+- Python: [version] ([venv type])
+- Installed extras: [list of optional dependency groups]
+- mypy: [error count] ([strict/normal])
+- Coverage: [percentage]%
+- Migration: [version or N/A]
+```
+
+#### Step 5 — Update .rune/session-log.md
+
+Use `Glob` to check if `.rune/session-log.md` exists. If not, use `Write` to create it with a `# Session Log` header.
+
+Use `Edit` to append a one-line entry to `.rune/session-log.md`:
+
+```
+[YYYY-MM-DD HH:MM] — [brief description of session accomplishments]
+```
+
+#### Step 6 — Cross-Project Knowledge Extraction (Neural Memory Bridge)
+
+Before committing, extract generalizable patterns from this session for cross-project reuse:
+
+1. Review the session's decisions, conventions, and completed tasks
+2. Identify 1-3 patterns that are NOT project-specific but would help in OTHER projects:
+   - Technology choices with reasoning ("Chose Redis over Memcached because X")
+   - Architecture patterns ("Fan-out queue pattern solved Y")
+   - Failure modes discovered ("React 19 useEffect cleanup breaks when Z")
+   - Performance insights ("N+1 query pattern in Prisma solved by include")
+3. For each generalizable pattern, save to Neural Memory:
+   - Use `nmem_remember` with rich cognitive language (causal, comparative, decisional)
+   - Tags: `[cross-project, <technology>, <pattern-type>]`
+   - Priority: 6-7 (important enough to surface in other projects)
+4. Skip if session was purely project-specific (config changes, bug fixes with no transferable insight)
+
+**Why**: This turns every project session into learning that compounds across ALL projects. A pattern discovered in Project A auto-surfaces when Project B faces a similar problem.
+
+#### Step 7 — Commit
+
+Stage and commit all updated state files:
+
+```bash
+git add .rune/ && git commit -m "chore: update rune session state"
+```
+
+If git is not available or the directory is not a repo, skip the commit and emit a warning.
+
+---
+
+### Load Mode (start of session)
+
+#### Step 1 — Check existence
+
+Use `Glob` to check for `.rune/` directory:
+
+```
+Glob pattern: .rune/*.md
+```
+
+If no files found: suggest running `/rune onboard` to initialize the project. Exit load mode.
+
+#### Step 1.5 — Integrity verification
+
+Before loading state files, invoke `integrity-check` (L3) to verify `.rune/` files haven't been tampered:
+
+```
+REQUIRED SUB-SKILL: rune:integrity-check
+→ Invoke integrity-check on all .rune/*.md files found in Step 1.
+→ Capture: status (CLEAN | SUSPICIOUS | TAINTED), findings list.
+```
+
+Handle results:
+- `CLEAN` → proceed to Step 2 (load files)
+- `SUSPICIOUS` → present warning to user with specific findings. Ask: "Suspicious patterns detected in .rune/ files. Load anyway?" If user approves → proceed. If not → exit load mode.
+- `TAINTED` → **BLOCK load**. Report: ".rune/ integrity check FAILED — possible poisoning detected. Run `/rune integrity` for details."
+
+#### Step 2 — Load files
+
+Use `Read` on all four state files in parallel:
+
+```
+Read: .rune/decisions.md
+Read: .rune/conventions.md
+Read: .rune/progress.md
+Read: .rune/session-log.md
+```
+
+#### Step 3 — Summarize
+
+Present the loaded context to the agent in a structured summary:
+
+> "Here's what happened in previous sessions:"
+> - Last session: [last line from session-log.md]
+> - Key decisions: [last 3 entries from decisions.md]
+> - Active conventions: [count from conventions.md]
+> - Current progress: [in-progress and blocked items from progress.md]
+> - Next task: [first item under "Next Session Should" from progress.md]
+
+#### Step 4 — Resume
+
+Identify the next concrete task from `progress.md` → "Next Session Should" section. Present it as the recommended starting point to the calling orchestrator.
+
+## Output Format
+
+### Save Mode
+```
+## Session Bridge — Saved
+- **decisions.md**: [N] decisions appended
+- **conventions.md**: [N] conventions appended
+- **progress.md**: updated (completed/in-progress/blocked counts)
+- **session-log.md**: 1 entry appended
+- **Git commit**: [hash] | skipped (no git)
+```
+
+### Load Mode
+```
+## Session Bridge — Loaded
+- **Last session**: [date and summary]
+- **Decisions on file**: [count]
+- **Conventions on file**: [count]
+- **Next task**: [task description]
+```
+
+## Constraints
+
+1. MUST save decisions, conventions, and progress — not just a status line
+2. MUST verify saved context can be loaded in a fresh session — test the round-trip
+3. MUST NOT overwrite existing bridge data without merging
+
+## Sharp Edges
+
+Known failure modes for this skill. Check these before declaring done.
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Overwriting existing .rune/ files instead of appending | HIGH | Constraint 3: use Edit to append entries — never Write to overwrite existing state |
+| Saving only a status line, missing decisions/conventions | HIGH | Constraint 1: all three files (decisions, conventions, progress) must be updated |
+| Load mode presenting stale context without age marker | MEDIUM | Mark each loaded entry with its session date — caller knows how fresh it is |
+| Silent failure when git unavailable | MEDIUM | Note "no git available" in report — do not fail silently or skip without logging |
+| Loading poisoned .rune/ files without verification | CRITICAL | Step 1.5 integrity-check MUST run before loading — TAINTED = block load |
+
+## Done When (Save Mode)
+
+- decisions.md updated with all architectural decisions made this session
+- conventions.md updated with all new patterns established
+- progress.md updated with completed/in-progress/blocked task status
+- session-log.md appended with one-line session summary
+- Git commit made (or "no git" noted in report)
+- Session Bridge Saved report emitted
+
+## Done When (Load Mode)
+
+- .rune/*.md files found and read
+- Last session summary presented
+- Current in-progress and blocked tasks identified
+- Next task recommendation from progress.md
+- Session Bridge Loaded report emitted
+
+## Cost Profile
+
+~100-300 tokens per save. ~500-1000 tokens per load. Always haiku. Negligible cost.