opencodekit 0.21.10 → 0.23.0

package/dist/template/.opencode/skill/systematic-debugging/SKILL.md

@@ -1,402 +0,0 @@
----
-name: systematic-debugging
-description: Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes - four-phase framework (root cause investigation, pattern analysis, hypothesis testing, implementation) that ensures understanding before attempting solutions
-version: 1.0.0
-tags: [debugging, workflow]
-dependencies: []
----
-
-# Systematic Debugging
-
-> **Replaces** "shotgun debugging" — making random changes hoping something fixes the issue without understanding the cause
-
-## When to Use
-
-- Test failures, production bugs, build breaks, or unexpected behavior
-- Issues with unclear root cause or multiple failed fix attempts
-- Situations where time pressure makes “quick fixes” tempting
-
-## When NOT to Use
-
-- Pure feature development with no failures to investigate
-- Non-technical questions that don’t require root cause analysis
-
-## Debugging Checklist
-
-- [ ] Read error messages/stack traces fully
-- [ ] Reproduce consistently (or gather more data)
-- [ ] Check recent changes (diffs, deps, config)
-- [ ] Trace data flow to source (use root-cause-tracing if deep)
-- [ ] Form a single hypothesis and test minimally
-- [ ] Create a failing test before implementing the fix
-- [ ] Implement one change and verify it resolves the issue
-- [ ] If 3+ fixes fail, stop and question architecture
-
-## Overview
-
-Random fixes waste time and create new bugs. Quick patches mask underlying issues.
-
-**Core principle:** ALWAYS find root cause before attempting fixes. Symptom fixes are failure.
-
-**Violating the letter of this process is violating the spirit of debugging.**
-
-## The Iron Law
-
-```
-NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST
-```
-
-If you haven't completed Phase 1, you cannot propose fixes.
-
-## The Four Phases
-
-You MUST complete each phase before proceeding to the next.
-
-### Debug File Protocol
-
-**Persistent debugging state survives context resets:**
-
-**Location:** `.planning/debug/{slug}.md` or `.beads/artifacts/<id>/debug/{slug}.md`
-
-**Template:**
-
-```markdown
-# Debug: [Brief Issue Description]
-
-**Opened:** [Date]
-**Status:** [gathering | investigating | fixing | verifying | resolved]
-**Reporter:** [human partner or "self-detected"]
-
-## Symptoms
-
-- [ ] Symptom 1: [What happens / doesn't happen]
-- [ ] Symptom 2: [Additional observation]
-
-## Eliminated Hypotheses
-
-- [x] [Hypothesis]: [Why it was wrong] (date)
-
-## Evidence Log
-
-| Timestamp | Data                | Interpretation  |
-| --------- | ------------------- | --------------- |
-| [time]    | [What was observed] | [What it means] |
-
-## Current Hypothesis
-
-[I think X is happening because Y. Testing with Z.]
-
-## Fix Attempts
-
-| #   | Change             | Result      | Notes |
-| --- | ------------------ | ----------- | ----- |
-| 1   | [What was changed] | [Pass/Fail] | [Why] |
-
-## Resolution
-
-**Root Cause:** [What was actually wrong]
-**Fix:** [How it was fixed]
-**Date:** [When resolved]
-```
-
-**Update Rules:**
-
-- **OVERWRITE** when updating status or hypothesis
-- **APPEND** to Evidence Log and Fix Attempts
-
-**Status Transitions:**
-
-- `gathering` → `investigating` → `fixing` → `verifying` → `resolved`
-
-### Phase 1: Root Cause Investigation
-
-**BEFORE attempting ANY fix:**
-
-1. **Read Error Messages Carefully**
-   - Don't skip past errors or warnings
-   - They often contain the exact solution
-   - Read stack traces completely
-   - Note line numbers, file paths, error codes
-
-2. **Reproduce Consistently**
-   - Can you trigger it reliably?
-   - What are the exact steps?
-   - Does it happen every time?
-   - If not reproducible → gather more data, don't guess
-
-3. **Check Recent Changes**
-   - What changed that could cause this?
-   - Git diff, recent commits
-   - New dependencies, config changes
-   - Environmental differences
-
-4. **Gather Evidence in Multi-Component Systems**
-
-   **WHEN system has multiple components (CI → build → signing, API → service → database):**
-
-   **BEFORE proposing fixes, add diagnostic instrumentation:**
-
-   ```
-   For EACH component boundary:
-     - Log what data enters component
-     - Log what data exits component
-     - Verify environment/config propagation
-     - Check state at each layer
-
-   Run once to gather evidence showing WHERE it breaks
-   THEN analyze evidence to identify failing component
-   THEN investigate that specific component
-   ```
-
-   **Example (multi-layer system):**
-
-   ```bash
-   # Layer 1: Workflow
-   echo "=== Secrets available in workflow: ==="
-   echo "IDENTITY: ${IDENTITY:+SET}${IDENTITY:-UNSET}"
-
-   # Layer 2: Build script
-   echo "=== Env vars in build script: ==="
-   env | grep IDENTITY || echo "IDENTITY not in environment"
-
-   # Layer 3: Signing script
-   echo "=== Keychain state: ==="
-   security list-keychains
-   security find-identity -v
-
-   # Layer 4: Actual signing
-   codesign --sign "$IDENTITY" --verbose=4 "$APP"
-   ```
-
-   **This reveals:** Which layer fails (secrets → workflow ✓, workflow → build ✗)
-
-5. **Trace Data Flow**
-
-   **WHEN error is deep in call stack:**
-
-   **REQUIRED SUB-SKILL:** Use skill({ name: "root-cause-tracing" }) for backward tracing technique
-
-   **Quick version:**
-   - Where does bad value originate?
-   - What called this with bad value?
-   - Keep tracing up until you find the source
-   - Fix at source, not at symptom
-
-### Phase 2: Pattern Analysis
-
-**Find the pattern before fixing:**
-
-1. **Find Working Examples**
-   - Locate similar working code in same codebase
-   - What works that's similar to what's broken?
-
-2. **Compare Against References**
-   - If implementing pattern, read reference implementation COMPLETELY
-   - Don't skim - read every line
-   - Understand the pattern fully before applying
-
-3. **Identify Differences**
-   - What's different between working and broken?
-   - List every difference, however small
-   - Don't assume "that can't matter"
-
-4. **Understand Dependencies**
-   - What other components does this need?
-   - What settings, config, environment?
-   - What assumptions does it make?
-
-**Evidence-Based Debugging (GSD Method):**
-
-**Information you have:**
-
-- ✅ Errors/warnings (with exact messages, line numbers)
-- ✅ Code I can read and trace through
-- ✅ Evidence from what I can observe directly
-
-**Information you DON'T have:**
-
-- ❌ What the user intended (ask if unclear)
-- ❌ Environment-specific state I can't observe
-- ❌ Intent behind code that doesn't match my understanding
-
-**When to gather more evidence vs. when to form hypothesis:**
-
-- **Gather evidence** when: Multiple components involved, unclear which one fails
-- **Form hypothesis** when: Error message points to specific location, pattern is clear
-- **Ask user** when: Behavior contradicts apparent code intent
-
-### Phase 3: Hypothesis and Testing
-
-**Scientific method:**
-
-1. **Form Single Hypothesis**
-   - State clearly: "I think X is the root cause because Y"
-   - Write it down
-   - Be specific, not vague
-
-2. **Test Minimally**
-   - Make the SMALLEST possible change to test hypothesis
-   - One variable at a time
-   - Don't fix multiple things at once
-
-3. **Verify Before Continuing**
-   - Did it work? Yes → Phase 4
-   - Didn't work? Form NEW hypothesis
-   - DON'T add more fixes on top
-
-4. **When You Don't Know**
-   - Say "I don't understand X"
-   - Don't pretend to know
-   - Ask for help
-   - Research more
-
-### Phase 4: Implementation
-
-**Fix the root cause, not the symptom:**
-
-1. **Create Failing Test Case**
-   - Simplest possible reproduction
-   - Automated test if possible
-   - One-off test script if no framework
-   - MUST have before fixing
-   - **REQUIRED SUB-SKILL:** Use skill({ name: "test-driven-development" }) for writing proper failing tests
-
-2. **Implement Single Fix**
-   - Address the root cause identified
-   - ONE change at a time
-   - No "while I'm here" improvements
-   - No bundled refactoring
-
-3. **Verify Fix**
-   - Test passes now?
-   - No other tests broken?
-   - Issue actually resolved?
-
-4. **If Fix Doesn't Work**
-   - STOP
-   - Count: How many fixes have you tried?
-   - If < 3: Return to Phase 1, re-analyze with new information
-   - **If ≥ 3: STOP and question the architecture (step 5 below)**
-   - DON'T attempt Fix #4 without architectural discussion
-
-5. **If 3+ Fixes Failed: Question Architecture**
-
-   **Pattern indicating architectural problem:**
-   - Each fix reveals new shared state/coupling/problem in different place
-   - Fixes require "massive refactoring" to implement
-   - Each fix creates new symptoms elsewhere
-
-   **STOP and question fundamentals:**
-   - Is this pattern fundamentally sound?
-   - Are we "sticking with it through sheer inertia"?
-   - Should we refactor architecture vs. continue fixing symptoms?
-
-   **Discuss with your human partner before attempting more fixes**
-
-   This is NOT a failed hypothesis - this is a wrong architecture.
-
-## Red Flags - STOP and Follow Process
-
-If you catch yourself thinking:
-
-- "Quick fix for now, investigate later"
-- "Just try changing X and see if it works"
-- "Add multiple changes, run tests"
-- "Skip the test, I'll manually verify"
-- "It's probably X, let me fix that"
-- "I don't fully understand but this might work"
-- "Pattern says X but I'll adapt it differently"
-- "Here are the main problems: [lists fixes without investigation]"
-- Proposing solutions before tracing data flow
-- **"One more fix attempt" (when already tried 2+)**
-- **Each fix reveals new problem in different place**
-
-**ALL of these mean: STOP. Return to Phase 1.**
-
-**If 3+ fixes failed:** Question the architecture (see Phase 4.5)
-
-## your human partner's Signals You're Doing It Wrong
-
-**Watch for these redirections:**
-
-- "Is that not happening?" - You assumed without verifying
-- "Will it show us...?" - You should have added evidence gathering
-- "Stop guessing" - You're proposing fixes without understanding
-- "Ultrathink this" - Question fundamentals, not just symptoms
-- "We're stuck?" (frustrated) - Your approach isn't working
-
-**When you see these:** STOP. Return to Phase 1.
-
-## Common Rationalizations
-
-| Excuse                                       | Reality                                                                 |
-| -------------------------------------------- | ----------------------------------------------------------------------- |
-| "Issue is simple, don't need process"        | Simple issues have root causes too. Process is fast for simple bugs.    |
-| "Emergency, no time for process"             | Systematic debugging is FASTER than guess-and-check thrashing.          |
-| "Just try this first, then investigate"      | First fix sets the pattern. Do it right from the start.                 |
-| "I'll write test after confirming fix works" | Untested fixes don't stick. Test first proves it.                       |
-| "Multiple fixes at once saves time"          | Can't isolate what worked. Causes new bugs.                             |
-| "Reference too long, I'll adapt the pattern" | Partial understanding guarantees bugs. Read it completely.              |
-| "I see the problem, let me fix it"           | Seeing symptoms ≠ understanding root cause.                             |
-| "One more fix attempt" (after 2+ failures)   | 3+ failures = architectural problem. Question pattern, don't fix again. |
-
-## Anti-Patterns
-
-| Anti-Pattern | Why It Fails | Instead |
-| --- | --- | --- |
-| Changing multiple things at once | You can’t isolate what actually fixed or broke behavior | Change one variable at a time and measure outcome |
-| Not reading the error message carefully | You skip direct clues (file, line, code, failing invariant) | Read the full error and stack trace before edits |
-| Assuming the bug is in the most recently changed code | Correlation bias hides older or shared-state causes | Trace actual data/control flow from symptom to source |
-| Skipping reproduction steps | Non-repro bugs encourage guessing and untestable fixes | Establish reliable repro steps, then verify fix against them |
-
-## Quick Reference
-
-| Phase                 | Key Activities                                         | Success Criteria            |
-| --------------------- | ------------------------------------------------------ | --------------------------- |
-| **1. Root Cause**     | Read errors, reproduce, check changes, gather evidence | Understand WHAT and WHY     |
-| **2. Pattern**        | Find working examples, compare                         | Identify differences        |
-| **3. Hypothesis**     | Form theory, test minimally                            | Confirmed or new hypothesis |
-| **4. Implementation** | Create test, fix, verify                               | Bug resolved, tests pass    |
-
-## When Process Reveals "No Root Cause"
-
-If systematic investigation reveals issue is truly environmental, timing-dependent, or external:
-
-1. You've completed the process
-2. Document what you investigated
-3. Implement appropriate handling (retry, timeout, error message)
-4. Add monitoring/logging for future investigation
-
-**But:** 95% of "no root cause" cases are incomplete investigation.
-
-## Integration with Other Skills
-
-**This skill requires using:**
-
-- **root-cause-tracing** - REQUIRED when error is deep in call stack (see Phase 1, Step 5)
-- **test-driven-development** - REQUIRED for creating failing test case (see Phase 4, Step 1)
-
-**Complementary skills:**
-
-- **defense-in-depth** - Add validation at multiple layers after finding root cause
-- **condition-based-waiting** - Replace arbitrary timeouts identified in Phase 2
-- **verification-before-completion** - Verify fix worked before claiming success
-
-## Real-World Impact
-
-From debugging sessions:
-
-- Systematic approach: 15-30 minutes to fix
-- Random fixes approach: 2-3 hours of thrashing
-- First-time fix rate: 95% vs 40%
-- New bugs introduced: Near zero vs common
-
-## Verification
-
-- Confirm the fix: reproduce the original bug scenario — it must now succeed.
-- Regression check: run related tests to ensure fix didn't break adjacent behavior.
-
-## See Also
-
-- **root-cause-tracing** - Deep call-stack tracing to identify original trigger before fixing
-- **condition-based-waiting** - Stabilize timing/race-condition fixes with state-based waits

package/dist/template/.opencode/skill/terse-output-mode/SKILL.md

@@ -1,95 +0,0 @@
----
-name: terse-output-mode
-description: Use when the user asks for terse, brief, less-wordy, token-efficient, or caveman-style responses. Applies concise output style while preserving technical precision, verification evidence, safety warnings, and exact code/command/error text.
-version: 1.0.0
-tags: [workflow]
-dependencies: []
----
-
-# Terse Output Mode
-
-## Overview
-
-Terse output mode reduces assistant prose, not tool output or reasoning quality. Use it to answer with fewer words while preserving exact technical substance, safety constraints, and verification evidence.
-
-Default style is professional terse. Use meme-like caveman phrasing only when the user explicitly asks for `caveman mode`.
-
-## When to Use
-
-- User says: "be brief", "less words", "terse", "concise", "token-efficient", "caveman mode", or similar.
-- User wants short implementation progress updates.
-- User asks for compact status, diff summaries, review findings, or next actions.
-- Context pressure is high and user-facing prose can be shortened without losing fidelity.
-
-## When NOT to Use
-
-- Security warnings, secrets handling, destructive actions, or irreversible confirmations.
-- PRDs, implementation plans, ADRs, migrations, release notes, or docs where clarity beats brevity.
-- Debugging explanations where missing nuance could cause a wrong fix.
-- User appears confused, asks for clarification, or repeats a question.
-- Verification evidence would be hidden by compression.
-
-## Core Rules
-
-1. **Preserve exact technical content** — never rewrite code, commands, file paths, error strings, versions, numbers, API names, or config keys.
-2. **Cut filler first** — remove pleasantries, hedging, throat-clearing, repeated context, and generic reassurance.
-3. **Keep evidence** — completion claims still need command output, counts, exit status, or file references.
-4. **Prefer fragments when safe** — short noun-verb sentences are fine for status updates.
-5. **Cite precisely** — keep `file:line` references when making code claims.
-6. **Do not hide uncertainty** — if uncertain, say what is missing in fewer words.
-7. **Normal code artifacts** — commits, PR descriptions, docs, specs, and user-facing copy keep normal professional language unless requested otherwise.
-
-## Auto-Clarity Escape Hatch
-
-Temporarily leave terse mode when brevity would create risk:
-
-| Situation                     | Action                                   |
-| ----------------------------- | ---------------------------------------- |
-| Security or data-loss warning | Use normal explicit wording              |
-| Destructive confirmation      | State full impact and options            |
-| Multi-step manual instruction | Use numbered complete steps              |
-| Ambiguous user intent         | Ask one clear question                   |
-| User confusion                | Explain normally, then resume terse mode |
-
-After the risky section, return to terse output automatically.
-
-## Output Patterns
-
-### Status Update
-
-```markdown
-Changed `src/auth.ts:42` guard. Typecheck running.
-```
-
-### Findings
-
-```markdown
-Critical: `src/form.tsx:88` error text is not associated with input. Screen readers miss failure.
-Fix: add `aria-describedby`, `aria-invalid`, and `role="alert"`.
-```
-
-### Final Report
-
-```markdown
-Added optional terse output mode and intent mapping.
-`npm run lint` passes: 0 warnings, 0 errors. Typecheck passes.
-No commit made.
-```
-
-## Boundaries
-
-- This skill is output style only.
-- It does not replace `rtk-command-compression`; RTK handles shell/tool output compression.
-- It does not replace DCP/context compression; DCP handles conversation compression.
-- It does not install hooks, plugins, binaries, or dependencies.
-- It does not rewrite memory files or project documentation unless explicitly asked.
-
-## Common Mistakes
-
-| Mistake                             | Fix                                                            |
-| ----------------------------------- | -------------------------------------------------------------- |
-| Making terse mode always-on         | Activate only on user request or clear token-efficiency intent |
-| Dropping verification evidence      | Keep fresh command evidence for any completion claim           |
-| Rewriting exact errors or commands  | Preserve exact text in code spans                              |
-| Using caveman meme voice by default | Default to professional terse                                  |
-| Compressing plans/specs too hard    | Use normal detail for durable artifacts                        |

package/dist/template/.opencode/skill/think-in-code/SKILL.md

@@ -1,136 +0,0 @@
----
-name: think-in-code
-description: Use when answering questions that require counting, filtering, parsing, joining, or summarizing data — write a small script that prints only the answer instead of reading large files into context. Saves 90%+ tokens vs raw reads. Adapted from context-mode (mksglu/context-mode).
-version: 1.0.0
-tags: [context, workflow]
-dependencies: []
----
-
-# Think in Code
-
-Compute answers with a small script. Don't drag raw data through context.
-
-## Core Principle
-
-> The model's job is to think. The script's job is to count, parse, filter, join. Then `console.log` only the answer.
-
-When you need a fact derived from data (logs, JSON, CSV, command output, file lists), the cheapest path is:
-
-1. Write 5–30 lines of code that produces the answer
-2. Run it
-3. Read **only** the printed answer
-
-Reading the raw data into context first is almost always wrong.
-
-## When to Use
-
-- Counting things in files / API output / logs ("how many failed runs in the last 100?")
-- Filtering large lists ("which dependencies haven't been updated in 6 months?")
-- Parsing structured output (`gh pr list --json`, `git log --pretty=...`, large JSON config)
-- Joining data across sources ("which files in `git diff` also have failing tests?")
-- Summarizing logs (top 10 error messages, error rate over time)
-- Computing diffs/intersections between two lists
-
-## When NOT to Use
-
-- The data is already small (<50 lines and you need most of it)
-- You need to **read** the content for understanding, not extract a fact (e.g. reviewing a PR)
-- The script itself would be longer than just reading the slice you need
-- A single `grep -c` or `wc -l` already answers it — just run that
-
-## Quick Decision
-
-| Situation                               | Approach                                        |
-| --------------------------------------- | ----------------------------------------------- |
-| "How many X in Y?"                      | Script → `console.log(count)`                   |
-| "Which Z match condition?"              | Script → `console.log(matches.join('\n'))`      |
-| "Top N by metric?"                      | Script → `console.log(top.map(...).join('\n'))` |
-| "What does this code do?"               | Read the file                                   |
-| "What's broken in this 30-line config?" | Read the file                                   |
-| "Count errors in 2MB log"               | Script — never `cat` it                         |
-
-## Patterns
-
-### Node one-liner (preferred for JSON / npm / fs work)
-
-```bash
-node -e "
-const fs = require('fs');
-const data = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'));
-const deps = Object.keys(data.packages || {}).filter(k => k.startsWith('node_modules/'));
-console.log('Total deps:', deps.length);
-console.log('Unique top-level:', new Set(deps.map(d => d.split('/')[1])).size);
-"
-```
-
-### Python one-liner (preferred for CSV / data crunching)
-
-```bash
-python3 -c "
-import csv, sys
-with open('data.csv') as f:
-    rows = list(csv.DictReader(f))
-errors = [r for r in rows if r['status'] == 'error']
-print(f'errors: {len(errors)} / {len(rows)}')
-print(f'top hosts:', sorted({r[\"host\"] for r in errors})[:5])
-"
-```
-
-### Bash (only when output is guaranteed small)
-
-```bash
-# OK — output is one number
-git log --since='1 week ago' --oneline | wc -l
-
-# OK — already filtered small
-gh pr list --state open --json number,title --jq '.[] | select(.title | contains("fix")) | .number'
-
-# NOT OK — dumps everything into context
-cat huge-log.txt | grep ERROR
-# Better:
-grep -c ERROR huge-log.txt                    # if you only need the count
-grep ERROR huge-log.txt | head -20            # if you need samples
-```
-
-### Save script to a file when it's reusable
-
-```bash
-cat > /tmp/count-deps.js <<'EOF'
-const fs = require('fs');
-const lock = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
-const pkgs = Object.keys(lock.packages || {});
-const stale = pkgs.filter(p => p.includes('node_modules/') && !p.includes('node_modules/.'));
-console.log(JSON.stringify({ total: pkgs.length, packages: stale.length }, null, 2));
-EOF
-node /tmp/count-deps.js package-lock.json
-```
-
-## Anti-Patterns
-
-| Anti-Pattern                                              | Why It's Wrong                               | Do Instead                                  |
-| --------------------------------------------------------- | -------------------------------------------- | ------------------------------------------- |
-| `cat huge.json` then "let me parse this in my head"       | Pulls 100KB+ into context for one answer     | `node -e "..."` to compute and print answer |
-| `gh pr list --json ...` printing all fields               | Dumps 50+ PRs of metadata you don't need     | `--jq` to filter to just the field you want |
-| `find . -name '*.ts'` to count files                      | Lists every path                             | `find . -name '*.ts' \| wc -l`              |
-| Reading 5 large logs to compare error rates               | 5x context bloat for one comparison          | Script that opens all 5 and prints summary  |
-| `curl https://api/...` raw piped to read                  | Whole response body in context               | `curl ... \| jq '.field'` or save to file   |
-| Asking the model to "estimate" instead of running a count | Hallucination risk; counts are deterministic | Run the script                              |
-
-## Verification
-
-Before considering an answer "done":
-
-1. The script ran without error
-2. The printed output is what you reasoned about (don't substitute memory for output)
-3. If the question was "how many", the script printed a number — not raw rows you then counted manually
-
-## Why This Skill Exists
-
-Adapted from the **Think in Code** pillar of [context-mode](https://github.com/mksglu/context-mode). The original ships a sandboxed executor that _forces_ this pattern; we keep the discipline as a prompt-level skill so it works without bundling new infrastructure.
-
-The savings compound: a single avoided 100KB read pays for many script iterations, and downstream summarization/handoff becomes cheaper too.
-
-## References
-
-- context-mode: https://github.com/mksglu/context-mode
-- Pairs with: `verification-before-completion`, `code-search-patterns`, `rtk-command-compression`