opencodekit 0.17.1 → 0.17.2

package/dist/template/.opencode/package.json

@@ -11,7 +11,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.59"
+    "@opencode-ai/plugin": "1.1.60"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",

package/dist/template/.opencode/skill/context-initialization/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: context-initialization
+description: Initialize GSD-style project context files from templates
+---
+
+# Context Initialization
+
+Create project.md, roadmap.md, and state.md from templates with user input.
+
+## Process
+
+### 1. Verify Templates
+
+```bash
+test -f .opencode/memory/_templates/project.md
+test -f .opencode/memory/_templates/roadmap.md
+test -f .opencode/memory/_templates/state.md
+```
+
+Stop if missing.
+
+### 2. Gather Input
+
+Ask 5 questions:
+
+1. Project vision
+2. Success criteria
+3. Target users
+4. Phases
+5. Current phase
+
+Skip if `--skip-questions` flag set.
+
+### 3. Create Files
+
+**project.md**
+
+- Read template
+- Fill with answers
+- Write to `.opencode/memory/project/`
+
+**roadmap.md**
+
+- Read template
+- Parse phases into table
+- Write to `.opencode/memory/project/`
+
+**state.md**
+
+- Read template
+- Set initial state
+- Write to `.opencode/memory/project/`
+
+### 4. Verify
+
+```bash
+ls .opencode/memory/project/
+```
+
+Report created files.

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

@@ -50,6 +50,62 @@ Use for ANY technical issue:
 
 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:**
@@ -147,6 +203,26 @@ You MUST complete each phase before proceeding to the next.
    - 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:**

package/dist/template/.opencode/skill/writing-plans/SKILL.md

@@ -45,6 +45,74 @@ Assume they are a skilled developer, but know almost nothing about our toolset o
 ---
 ```
 
+### Goal-Backward Section (REQUIRED)
+
+Document the reasoning that produced this plan using goal-backward methodology:
+
+```markdown
+## Must-Haves
+
+**Goal:** [Outcome-shaped goal from PRD]
+
+### Observable Truths
+
+(What must be TRUE for the goal to be achieved?)
+
+1. [Truth 1: User can...]
+2. [Truth 2: User can...]
+3. [Truth 3: User can...]
+
+### Required Artifacts
+
+(What must EXIST for truths to be true?)
+| Artifact | Provides | Path |
+|----------|----------|------|
+| [File/component] | [What it does] | `src/path/to/file.ts` |
+
+### Key Links
+
+(Where is this most likely to break?)
+| From | To | Via | Risk |
+|------|-----|-----|------|
+| [Component] | [API] | `fetch` | [Why it might fail] |
+```
+
+### Dependency Graph
+
+```markdown
+### Task Dependencies
+```
+
+Task A (User model): needs nothing, creates src/models/user.ts
+Task B (Product model): needs nothing, creates src/models/product.ts
+Task C (User API): needs Task A, creates src/api/users.ts
+
+Wave 1: A, B (parallel)
+Wave 2: C (after Wave 1)
+
+```
+
+```
+
+## Context Budget
+
+Target: ~50% context per plan execution
+Maximum: 2-3 tasks per plan
+
+| Task Complexity | Max Tasks | Typical Context |
+| --------------- | --------- | --------------- |
+| Simple (CRUD)   | 3         | ~30-45%         |
+| Complex (auth)  | 2         | ~40-50%         |
+| Very complex    | 1-2       | ~30-50%         |
+
+**Split signals:**
+
+- More than 3 tasks → Create child plans
+- Multiple subsystems → Separate plans
+- Any task with >5 file modifications → Split
+- Checkpoint + implementation → Split
+- Discovery + implementation → Split
+
 ## Task Structure
 
 ````markdown

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.17.1",
+	"version": "0.17.2",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",