opencodekit 0.16.4 → 0.16.6

package/dist/template/.opencode/skill/development-lifecycle/SKILL.md

@@ -0,0 +1,305 @@
+---
+name: development-lifecycle
+description: Orchestrates the full feature development lifecycle from ideation through verification. Guides through phases (brainstorm → design → specify → plan → implement → verify) and loads appropriate sub-skills at each stage.
+---
+
+# Development Lifecycle Orchestration
+
+## Overview
+
+This skill orchestrates the complete feature development workflow, guiding you through each phase and loading the appropriate sub-skills automatically.
+
+**Use when:** Starting any new feature, migration, refactor, or significant change.
+
+**Announce at start:** "I'm using development-lifecycle to guide this work through all phases."
+
+## The Lifecycle
+
+```
+┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+│  IDEATION   │───▶│   DESIGN    │───▶│ SPECIFICATION│───▶│   PLANNING  │───▶│IMPLEMENTATION│
+│ brainstorming│   │  design.md  │    │   prd.md    │    │  tasks.md   │    │executing-plans│
+└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
+                          │                  │                  │                  │
+                          └──────────────────┴──────────────────┴──────────────────┤
+                                              │                                     ▼
+                                    ┌─────────────────┐                   ┌─────────────┐
+                                    │    RESEARCH     │                   │VERIFICATION │
+                                    │   (optional)    │                   │verification-│
+                                    │ /research cmd   │                   │before-      │
+                                    └─────────────────┘                   │completion   │
+                                                                          └─────────────┘
+```
+
+**Note:** Research (`/research <bead-id>`) can happen at any phase when you need external information or deeper codebase understanding. It's not a sequential step but a parallel activity.
+
+## Phase 1: Ideation (brainstorming)
+
+**When:** You have a rough idea but need to explore and refine it.
+
+**Load skill:**
+
+```typescript
+skill({ name: "brainstorming" });
+```
+
+**Entry criteria:** User has an idea or problem to solve.
+
+**Process:**
+
+1. Understand current project context
+2. Ask questions one at a time (prefer multiple choice)
+3. Explore 2-3 approaches with trade-offs
+4. Present design in 200-300 word sections
+
+**Exit criteria:**
+
+- Design validated by user
+- Output: `.beads/artifacts/<bead-id>/design.md`
+
+**Template:** `.opencode/memory/_templates/design.md`
+
+---
+
+## Phase 2: Specification (prd)
+
+**When:** Design is validated, need formal requirements and task breakdown.
+
+**Load skill:**
+
+```typescript
+skill({ name: "prd" });
+```
+
+**Entry criteria:** Design document exists and is validated.
+
+**Process:**
+
+1. Confirm bead id (create if needed: `br create "Feature Name"`)
+2. Ask clarifying questions (5-7 max)
+3. Explore codebase patterns and constraints
+4. Write PRD with machine-convertible Tasks section
+
+**Exit criteria:**
+
+- PRD with all sections completed
+- Output: `.beads/artifacts/<bead-id>/prd.md`
+
+**Template:** `.opencode/memory/_templates/prd.md`
+
+---
+
+## Phase 3: Task Conversion (prd-task)
+
+**When:** PRD is complete, need executable task list.
+
+**Load skill:**
+
+```typescript
+skill({ name: "prd-task" });
+```
+
+**Entry criteria:** PRD exists at `.beads/artifacts/<bead-id>/prd.md`.
+
+**Process:**
+
+1. Read PRD and extract ## Tasks section
+2. Convert to JSON format with dependencies
+3. Create progress.txt for cross-iteration memory
+
+**Exit criteria:**
+
+- JSON task file created
+- Progress file initialized
+- Output: `.beads/artifacts/<bead-id>/prd.json`, `progress.txt`
+
+---
+
+## Phase 4: Planning (writing-plans)
+
+**When:** Tasks defined, need detailed implementation instructions.
+
+**Load skill:**
+
+```typescript
+skill({ name: "writing-plans" });
+```
+
+**Entry criteria:** Task list exists (prd.json or tasks.md).
+
+**Process:**
+
+1. Create bite-sized steps (2-5 min each)
+2. Include exact file paths, complete code
+3. TDD: write failing test → verify fail → implement → verify pass → commit
+4. Add verification commands for each step
+
+**Exit criteria:**
+
+- Detailed plan ready for execution
+- Output: `.beads/artifacts/<bead-id>/plan.md`
+
+**Template:** `.opencode/memory/_templates/tasks.md` (for task structure reference)
+
+---
+
+## Phase 5: Implementation (executing-plans)
+
+**When:** Plan is ready, time to build.
+
+**Load skill:**
+
+```typescript
+skill({ name: "executing-plans" });
+```
+
+**Entry criteria:** Plan exists at `.beads/artifacts/<bead-id>/plan.md`.
+
+**Process:**
+
+1. Load and review plan critically
+2. Execute in 3-task batches
+3. Report for feedback between batches
+4. Stop on blockers, don't guess
+
+**Exit criteria:**
+
+- All tasks completed
+- All verifications pass
+- Ready for final verification
+
+---
+
+## Phase 6: Verification (verification-before-completion)
+
+**When:** Implementation complete, before claiming done.
+
+**Load skill:**
+
+```typescript
+skill({ name: "verification-before-completion" });
+```
+
+**Entry criteria:** All implementation tasks marked complete.
+
+**Process:**
+
+1. IDENTIFY: What commands prove completion?
+2. RUN: Execute full verification suite fresh
+3. READ: Check output, count failures
+4. VERIFY: Does output confirm the claim?
+5. ONLY THEN: Claim completion
+
+**Exit criteria:**
+
+- All verification commands pass with evidence
+- Bead can be closed: `br close <bead-id>`
+
+---
+
+## Phase Transitions
+
+### Quick Start (Skip to appropriate phase)
+
+| Starting Point                    | Begin At | Command                                             |
+| --------------------------------- | -------- | --------------------------------------------------- |
+| Rough idea                        | Phase 1  | `skill({ name: "brainstorming" })`                  |
+| Design done, need requirements    | Phase 2  | `skill({ name: "prd" })`                            |
+| PRD done, need task JSON          | Phase 3  | `skill({ name: "prd-task" })`                       |
+| Tasks defined, need detailed plan | Phase 4  | `skill({ name: "writing-plans" })`                  |
+| Plan ready, time to build         | Phase 5  | `skill({ name: "executing-plans" })`                |
+| Done coding, need verification    | Phase 6  | `skill({ name: "verification-before-completion" })` |
+
+### Skipping Phases
+
+For small changes, you can skip early phases:
+
+- **Bug fix:** Skip to Phase 5 (implement directly with verification)
+- **Clear requirements:** Skip Phase 1, start at Phase 2
+- **Simple refactor:** Skip to Phase 4 (plan) or Phase 5 (execute)
+
+---
+
+## Templates Reference
+
+| Phase         | Template                 | Purpose                       |
+| ------------- | ------------------------ | ----------------------------- |
+| Design        | `_templates/design.md`   | Architecture decisions        |
+| Specification | `_templates/prd.md`      | Requirements + task breakdown |
+| Planning      | `_templates/tasks.md`    | Detailed task structure       |
+| Quick Ideas   | `_templates/proposal.md` | Lightweight change proposals  |
+
+---
+
+## Beads Integration
+
+Every phase should operate within a bead context:
+
+```bash
+# Create bead for new feature
+br create "Feature Name"
+
+# Check current bead status
+br show <bead-id>
+
+# Update status as you progress
+br update <bead-id> --status in_progress
+
+# Close when complete
+br close <bead-id> --reason "All verification passed"
+
+# Sync changes
+br sync --flush-only
+```
+
+---
+
+## Example Full Workflow
+
+```
+User: "I want to add a dark mode toggle"
+
+1. IDEATION
+   → skill({ name: "brainstorming" })
+   → Questions about scope, triggers, persistence
+   → Design decisions documented
+   → Output: .beads/artifacts/bd-dark-mode/design.md
+
+2. SPECIFICATION
+   → skill({ name: "prd" })
+   → Full PRD with requirements
+   → Tasks section for conversion
+   → Output: .beads/artifacts/bd-dark-mode/prd.md
+
+3. TASK CONVERSION
+   → skill({ name: "prd-task" })
+   → JSON task list with dependencies
+   → Output: .beads/artifacts/bd-dark-mode/prd.json
+
+4. PLANNING
+   → skill({ name: "writing-plans" })
+   → Bite-sized implementation steps
+   → Output: .beads/artifacts/bd-dark-mode/plan.md
+
+5. IMPLEMENTATION
+   → skill({ name: "executing-plans" })
+   → Execute in batches with feedback
+   → All code written and committed
+
+6. VERIFICATION
+   → skill({ name: "verification-before-completion" })
+   → Tests pass: ✓
+   → Lint clean: ✓
+   → Build succeeds: ✓
+   → br close bd-dark-mode --reason "Dark mode implemented and verified"
+```
+
+---
+
+## Key Principles
+
+1. **Phase-appropriate skills:** Load the right skill for each phase
+2. **Evidence at every gate:** No phase transition without verification
+3. **Templates guide structure:** Use templates for consistent output
+4. **Beads track progress:** Every feature gets a bead
+5. **Skip only when appropriate:** Small changes can skip early phases

package/dist/template/.opencode/skill/memory-system/SKILL.md

@@ -142,13 +142,13 @@ For long-term storage health:
 
 ```typescript
 // Check current status
-memory_maintain({ operation: "status" });
+memory_admin({ operation: "status" });
 
 // Full maintenance (archive >90 days, checkpoint WAL, vacuum)
-memory_maintain({ operation: "full" });
+memory_admin({ operation: "full" });
 
 // Preview what would be archived
-memory_maintain({ operation: "archive", older_than_days: 60, dry_run: true });
+memory_admin({ operation: "archive", older_than_days: 60, dry_run: true });
 ```
 
 **Automatic maintenance** runs at session end:

package/dist/template/.opencode/skill/prd/SKILL.md

@@ -9,6 +9,10 @@ Create Product Requirements Documents suitable for RFC review by Principal Engin
 
 The PRD describes WHAT to build and WHY, not HOW or in WHAT ORDER.
 
+**Part of:** `development-lifecycle` skill (Phase 2: Specification)
+
+**Template:** `.opencode/memory/_templates/prd.md`
+
 ## Beads-Native Output (Recommended)
 
 When you are working on a Beads task (you have a bead id like `bd-...`), the PRD should live with the task artifacts:
@@ -17,16 +21,20 @@ When you are working on a Beads task (you have a bead id like `bd-...`), the PRD
 
 This keeps requirements + execution tasks colocated with the bead.
 
-If no bead id exists, fall back to writing `prd-<feature-name>.md` in the project root.
+If no bead id exists, create one first: `br create "Feature Name"`, then use the artifact path.
 
 ## Workflow
 
 1. Confirm if the user has an existing bead id.
    - If yes: use `.beads/artifacts/<bead-id>/prd.md`
-   - If no: write `prd-<feature-name>.md` in project root
-2. Ask clarifying questions (5–7 max).
-3. Explore codebase patterns and constraints.
-4. Write a PRD that includes a machine-convertible `## Tasks` section (see below).
+   - If no: create bead with `br create "Feature Name"`, then use artifact path
+2. Read template from `.opencode/memory/_templates/prd.md`
+3. Ask clarifying questions (5–7 max).
+4. Explore codebase patterns and constraints.
+5. Write a PRD following the template structure, including:
+   - Bead Metadata (dependencies, parallel, conflicts)
+   - Requirements with WHEN/THEN scenarios
+   - Machine-convertible `## Tasks` section
 
 ## Clarifying Questions
 
@@ -65,142 +73,57 @@ If no bead id exists, fall back to writing `prd-<feature-name>.md` in the projec
 
 ## Output Format
 
-Write a PRD in markdown using this structure.
-
-IMPORTANT: include a `## Tasks` section that `prd-task` can convert.
-
-```markdown
-# PRD: <Feature Name>
-
-**Bead:** <bd-...>  
-**Date:** <YYYY-MM-DD>
-
----
-
-## Problem Statement
-
-### What problem are we solving?
-
-Clear description of the problem. Include user impact and business impact.
-
-### Why now?
-
-What triggered this work? Cost of inaction?
-
-### Who is affected?
-
-- **Primary users:** Description
-- **Secondary users:** Description
-
----
-
-## Proposed Solution
-
-### Overview
-
-One paragraph describing what this feature does when complete.
-
-### User Experience (if applicable)
-
-How will users interact with this feature? Include user flows for primary scenarios.
-
----
-
-## End State
-
-When this PRD is complete, the following will be true:
-
-- [ ] Capability 1 exists and works
-- [ ] Capability 2 exists and works
-- [ ] All acceptance criteria pass
-- [ ] Tests cover the new functionality
-- [ ] Documentation is updated
-
----
-
-## Success Metrics
-
-### Quantitative
+**Read the template:** `.opencode/memory/_templates/prd.md`
 
-| Metric   | Current | Target | Measurement Method |
-| -------- | ------- | ------ | ------------------ |
-| Metric 1 | X       | Y      | How measured       |
+Follow the template structure which includes:
 
-### Qualitative
+- Bead Metadata (dependencies, parallel execution, conflicts)
+- Problem Statement with WHEN/THEN scenarios
+- Scope (In/Out)
+- Requirements (Functional + Non-Functional)
+- Success Criteria with verification commands
+- Technical Context and Affected Files
+- Tasks section with Metadata (depends_on, parallel, files)
 
-- User feedback criteria
-- Team/process improvements expected
+### Task Format (Critical)
 
----
-
-## Acceptance Criteria
-
-### Feature: <Name>
-
-- [ ] Criterion 1
-- [ ] Criterion 2
-
----
-
-## Technical Context
-
-### Existing Patterns
-
-- Pattern 1: `src/path/to/example.ts` - Why relevant
-
-### Key Files
-
-- `src/relevant/file.ts` - Description of relevance
-
----
-
-## Risks & Mitigations
-
-| Risk   | Likelihood   | Impact       | Mitigation      |
-| ------ | ------------ | ------------ | --------------- |
-| Risk 1 | High/Med/Low | High/Med/Low | How to mitigate |
+Tasks must include **Metadata** for dependency tracking:
 
----
-
-## Non-Goals (v1)
-
-Explicitly out of scope:
-
-- Thing we're not building - why deferred
-
----
+````markdown
+### <Task Title> [category]
 
-## Tasks
+<One sentence describing the end state>
 
-Each task must be written like:
+**Metadata:**
 
-### <Task Title> [category]
-
-One sentence describing the end state.
+```yaml
+depends_on: []
+parallel: true
+conflicts_with: []
+files: []
+```
+````
 
 **Verification:**
 
-- A command or manual check that proves it works
-- Another check
+- [Command or check]
 
-Example:
+```
 
-### Registration API [api]
+## Next Steps
 
-Users can register with email/password.
+After PRD is written, tell the user:
 
-**Verification:**
+```
 
-- `curl -X POST /api/auth/register ...` returns 201
-- Duplicate email returns 409
+PRD written: .beads/artifacts/<bead-id>/prd.md
 
----
+Next: Convert to executable tasks:
+skill({ name: "prd-task" })
 
-## Open Questions
+Or view the full lifecycle:
+skill({ name: "development-lifecycle" })
 
-| Question   | Owner | Due Date | Status        |
-| ---------- | ----- | -------- | ------------- |
-| Question 1 | Name  | Date     | Open/Resolved |
 ```
 
 ## Key Principles
@@ -210,3 +133,5 @@ Users can register with email/password.
 - Technical Context Enables Autonomy
 - Non-Goals Prevent Scope Creep
 - Risks & Alternatives Show Rigor
+- Include Metadata for parallel execution
+```

package/dist/template/.opencode/skill/prd-task/SKILL.md

@@ -11,6 +11,8 @@ Convert a markdown PRD into executable JSON format for autonomous task completio
 
 The PRD defines the **end state** via tasks with verification steps. The agent decides HOW to get there.
 
+**Part of:** `development-lifecycle` skill (Phase 3: Task Conversion)
+
 ## Beads-Native File Locations (Recommended)
 
 This template uses Beads artifacts (no `.opencode/state`).
@@ -66,9 +68,27 @@ Write JSON to `.beads/artifacts/<bead-id>/prd.json`.
         "Verify 201 response with user object",
         "Attempt duplicate email, verify 409"
       ],
-      "passes": false
+      "passes": false,
+      "metadata": {
+        "depends_on": [],
+        "parallel": true,
+        "conflicts_with": [],
+        "files": ["src/routes/auth.ts", "src/db/users.ts"]
+      }
     }
-  ]
+  ],
+  "context": {
+    "patterns": ["API routes: src/routes/"],
+    "keyFiles": ["src/db/schema.ts"],
+    "nonGoals": ["OAuth/social login"]
+  },
+  "beadMetadata": {
+    "depends_on": [],
+    "parallel": true,
+    "conflicts_with": [],
+    "blocks": [],
+    "estimated_hours": 4
+  }
 }
 ```
 
@@ -85,6 +105,25 @@ See `references/prd-schema.json`.
 - Text after title becomes `description`
 - Items under `**Verification:**` become `steps`
 - `passes` always starts `false`
+- Extract `**Metadata:**` yaml block for dependency info:
+  - `depends_on`: Task titles or IDs that must complete first
+  - `parallel`: Can run concurrently (default: true)
+  - `conflicts_with`: Tasks modifying same files
+  - `files`: Files this task will modify
+
+### Bead Metadata
+
+Extract the `## Bead Metadata` yaml block from the PRD header:
+
+```yaml
+depends_on: [] # Bead IDs
+parallel: true
+conflicts_with: [] # Bead IDs
+blocks: []
+estimated_hours: 2
+```
+
+Store in `beadMetadata` field in the JSON output.
 
 ### Steps Are Verification
 
@@ -122,7 +161,12 @@ PRD converted:
   - .beads/artifacts/<bead-id>/prd.json
   - .beads/artifacts/<bead-id>/progress.txt
 
-Next:
+Next: Create detailed implementation plan
+  skill({ name: "writing-plans" })
+
+Or start execution directly:
   /start <bead-id>
-  /complete-next-task <bead-id>
+
+Full lifecycle reference:
+  skill({ name: "development-lifecycle" })
 ```