opencodekit 0.21.10 → 0.23.0

package/dist/template/.opencode/agent/plan.md

@@ -5,14 +5,12 @@ temperature: 0.2
 permission:
   write:
     "*": ask
-    ".beads/artifacts/*/*.md": allow
+    ".opencode/artifacts/**/*.md": allow
     ".opencode/memory/**/*.md": allow
-    ".opencode/plans/*.md": allow
   edit:
     "*": ask
-    ".beads/artifacts/*/*.md": allow
+    ".opencode/artifacts/**/*.md": allow
     ".opencode/memory/**/*.md": allow
-    ".opencode/plans/*.md": allow
   bash:
     "*": allow
     "rm*": deny
@@ -88,11 +86,11 @@ Planning follows a five-phase arc. Each phase has purpose; silence pockets allow
 
 | Phase         | Purpose                                     | Actions                                                                         | Silence Pocket                                      |
 | ------------- | ------------------------------------------- | ------------------------------------------------------------------------------- | --------------------------------------------------- |
-| **Ground**    | Establish in the problem space              | Read bead artifacts (`prd.md`, existing `plan.md`), check memory for prior work | Pause: "What do I actually know?"                   |
+| **Ground**    | Establish in the problem space              | Read plan artifacts (`spec.md`, existing `plan.md`), check memory for prior work | Pause: "What do I actually know?"                   |
 | **Calibrate** | Understand constraints and success criteria | Identify non-negotiables, define "done", assess risks                           | Assess: "Are requirements clear enough to proceed?" |
 | **Transform** | Decompose into executable tasks             | Create phases, define dependencies, assign complexity scores                    | None — active decomposition                         |
 | **Release**   | Write the actionable plan                   | Exact file paths, specific commands, verification steps                         | Review: "Can a stranger execute this?"              |
-| **Reset**     | Handoff and checkpoint                      | Save to `.opencode/plans/`, update memory, recommend next command               | Silent: "What was learned for next time?"           |
+| **Reset**     | Handoff and checkpoint                      | Save to `.opencode/artifacts/<slug>/`, update memory, recommend next command               | Silent: "What was learned for next time?"           |
 
 ## Goal-Backward Methodology
 
@@ -307,7 +305,6 @@ observation({
   narrative: "Phase 1 handles core logic, Phase 2 adds edge cases, Phase 3 polishes...",
   facts: "3 phases, core-first, 2-week timeline",
   concepts: "planning, decomposition, timeline",
-  bead_id: "<current-bead-id>",
 });
 ```
 
@@ -352,12 +349,6 @@ observation({
 
 ## Skills
 
-Always load:
-
-```typescript
-skill({ name: "beads" });
-```
-
 Load contextually:
 
 | Situation                              | Skill              |
@@ -389,11 +380,11 @@ When planning under constraint:
 
 ## Workflow
 
-1. **Ground**: Read bead artifacts (`prd.md`, `plan.md` if present); use `srcwalk map --scope src/` for codebase overview only when needed
+1. **Ground**: Read plan artifacts (`spec.md`, `plan.md` if present); use `srcwalk map --scope src/` for codebase overview only when needed
 2. **Calibrate**: Understand goal, constraints, and success criteria
 3. **Transform**: Launch parallel research (`task` subagents) when uncertainty remains; use `srcwalk find <symbol> --scope src/` for fast codebase discovery; decompose into phases/tasks with explicit dependencies
 4. **Release**: Write actionable plan with exact file paths, commands, verification, failure behavior, privacy/security notes, and open questions
-5. **Reset**: End with a concrete next command (`/ship <id>`, `/start <child-id>`, etc.)
+5. **Reset**: End with a concrete next command (`/ship`, `/plan`, etc.)
 
 **Code navigation:** Use srcwalk for AST-aware search and `map` for structural overview — see `code-search-patterns` skill.
 
@@ -462,7 +453,7 @@ How to confirm the entire plan succeeded.
 
 ## Next Command
 
-`/ship <id>` or `/start <child-id>`
+`/ship` or `/plan`
 ```
 
 > _"The body is architecture. The breath is wiring. The rhythm is survival."_  

package/dist/template/.opencode/agent/review.md

@@ -6,7 +6,6 @@ steps: 40
 tools:
   edit: false
   write: false
-  memory-update: false
   observation: false
   todowrite: false
   question: false

package/dist/template/.opencode/agent/scout.md

@@ -4,17 +4,16 @@ mode: subagent
 temperature: 0.2
 steps: 30
 tools:
-  memory-update: false
   observation: false
   todowrite: false
   question: false
 permission:
   write:
     "*": deny
-    ".beads/artifacts/*/*.md": allow
+    ".opencode/artifacts/**/*.md": allow
   edit:
     "*": deny
-    ".beads/artifacts/*/*.md": allow
+    ".opencode/artifacts/**/*.md": allow
   bash:
     "*": allow
     "rm*": deny

package/dist/template/.opencode/agent/vision.md

@@ -8,7 +8,6 @@ tools:
   write: false
   bash: false
   task: false
-  memory-update: false
   observation: false
   todowrite: false
 ---

package/dist/template/.opencode/artifacts/.active

@@ -0,0 +1 @@
+example

package/dist/template/.opencode/artifacts/example/plan.md

@@ -0,0 +1,12 @@
+# Implementation Plan
+
+## Discovery
+[Research findings]
+
+## Phases
+1. Phase 1 — [Description]
+2. Phase 2 — [Description]
+
+## Tasks
+- [ ] Task 1
+- [ ] Task 2

package/dist/template/.opencode/artifacts/example/progress.md

@@ -0,0 +1,4 @@
+# Progress Log
+
+<!-- Append-only checkpoint log for this feature. -->
+

package/dist/template/.opencode/artifacts/example/research.md

@@ -0,0 +1,4 @@
+# Research Findings
+
+<!-- External research for this feature. -->
+

package/dist/template/.opencode/artifacts/example/spec.md

@@ -0,0 +1,16 @@
+# Example Feature
+
+## Problem
+[What needs to be built/fixed]
+
+## Solution
+[How to solve it]
+
+## Affected Files
+- `src/path/to/file.ts`
+
+## Tasks
+- [ ] [Task] → Verify: `npm run typecheck`
+
+## Success Criteria
+- Verify: `npm run typecheck && npm run lint`

package/dist/template/.opencode/artifacts/todo.md

@@ -0,0 +1,5 @@
+# Active Tasks
+
+<!-- Session-scoped task list. Overwritten each session. -->
+
+- [ ] Current task

package/dist/template/.opencode/artifacts/verify.log

@@ -0,0 +1,4 @@
+# Verification Log
+
+<!-- Cross-session audit trail. Appended, never overwritten. -->
+

package/dist/template/.opencode/command/clarify.md

@@ -0,0 +1,46 @@
+---
+description: Reduce ambiguity before planning or implementation
+argument-hint: "<request> [--quick|--deep]"
+agent: build
+---
+
+# Clarify: $ARGUMENTS
+
+Reduce ambiguity before planning or implementation. Use when the request is real but still fuzzy.
+
+## Load Skills
+
+```typescript
+skill({ name: "brainstorming" });
+```
+
+## Parse Arguments
+
+| Argument | Default | Description |
+|---|---|---|
+| `<request>`            | required | Freeform request text                     |
+| `--quick` | false | Minimize to 1-3 high-leverage questions |
+| `--deep` | false | Cover non-goals, risks, interfaces, success criteria |
+
+**Mode rules:** Default → make next command obvious. `--quick` → 1-3 questions. `--deep` → exhaustive. `--deep` wins if both appear.
+
+## When to Use / Not Use
+
+**Use:** Request is fuzzy, scope unclear, multiple interpretations of "done," `/plan` would be premature because main decision is unresolved.  
+**Skip:** Request is specific enough to plan directly, task is mechanical, ambiguity is only about codebase facts you can inspect.
+
+## Core Rules
+
+- **Inspect first, ask second** — never ask for codebase facts you can discover directly
+- **One question at a time** — each must reduce a real ambiguity
+- **Prefer structured choices** (multiple choice, yes/no)
+- **Surface non-goals explicitly** — what should *not* change is as important as what should
+- **Stop once the next command is obvious**
+
+## Process
+
+1. Read request, identify unknowns blocking execution
+2. Search memory, check existing patterns
+3. Ask questions one at a time, resolve before next
+4. Surface non-goals and constraints
+5. Recommend next command: `/plan`, `/create`, `/ship`, or `/design`

package/dist/template/.opencode/command/commit.md

@@ -0,0 +1,53 @@
+---
+description: Create a well-structured conventional commit from staged or unstaged changes
+argument-hint: "[--all] [--amend] [message override]"
+agent: build
+---
+
+# Commit: $ARGUMENTS
+
+Create a well-structured conventional commit from current changes.
+
+## Load Skills
+
+```typescript
+skill({ name: "verification-before-completion" });
+```
+
+## Process
+
+### Phase 1: Inspect Changes
+
+```bash
+git status --short
+git diff --cached --stat   # if staged
+git diff --stat            # if unstaged
+```
+
+### Phase 2: Review Diffs
+
+Read each changed file. Look for:
+- Debug code, console.log, TODOs that should be resolved
+- Accidental changes outside scope
+- Missing error handling or edge cases
+
+### Phase 3: Construct Commit
+
+Format: `type(scope): description`
+
+Types: `feat` (feature), `fix` (bug), `test` (test-only), `refactor` (no behavior change), `chore` (config/tooling), `docs`, `style`, `perf`.
+
+### Phase 4: Commit
+
+```bash
+git add <files>    # stage specific files — never git add .
+git commit -m "type(scope): description
+
+- bullet points of key changes"
+```
+
+### Phase 5: Verify
+
+```bash
+git log --oneline -3
+```

package/dist/template/.opencode/command/create.md

@@ -1,34 +1,20 @@
 ---
-description: Create a bead with specification, claim it, and prepare workspace
-argument-hint: "<description> [--type epic|feature|task|bug] [--spec-only]"
+description: Create a specification with PRD, tasks, and workspace setup
+argument-hint: "<description>"
 agent: build
 ---
 
 # Create: $ARGUMENTS
 
-Create a bead, write its specification (PRD), claim it, set up the workspace, and convert to executable tasks — ready for `/ship`.
+Create a specification (PRD), set up workspace, and define executable tasks — ready for `/ship`.
 
-> **Workflow:** **`/create`** → `/ship <id>`
->
-> Use `--spec-only` to create the specification without claiming or setting up workspace.
-
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "memory-grounding" });
-skill({ name: "workspace-setup" });
-skill({ name: "prd" }); // PRD template guidance
-skill({ name: "prd-task" }); // PRD → executable tasks (Phase 8)
-```
+> **Workflow:** **`/create`** → `/ship`
 
 ## Parse Arguments
 
 | Argument        | Default       | Description                               |
 | --------------- | ------------- | ----------------------------------------- |
 | `<description>` | required      | What to build/fix (quoted string)         |
-| `--type`        | auto-detected | Override: epic, feature, task, bug        |
-| `--spec-only`   | false         | Create spec without claiming or workspace |
 
 ## Determine Input Type
 
@@ -36,13 +22,12 @@ skill({ name: "prd-task" }); // PRD → executable tasks (Phase 8)
 | ----------- | -------------------- | ----------------------------- |
 | Quoted text | `"description here"` | Create PRD from description   |
 | Short form  | Simple string        | Ask for more detail if needed |
-| `--type`    | Flag provided        | Use provided type             |
 
 ## Before You Create
 
-- **Be certain**: Only create beads you're confident have clear scope
+- **Be certain**: Only create specs you're confident have clear scope
 - **Don't over-spec**: If the description is vague, ask clarifying questions first
-- **Check duplicates**: Always run Phase 1 duplicate check
+- **Check duplicates**: Always check for existing work
 - **No implementation**: This command creates specs and workspace — don't write implementation code
 - **Verify PRD**: Before saving, verify all sections are filled (no placeholders)
 - **Flag uncertainty**: Use `[NEEDS CLARIFICATION]` markers for unknowns — never guess silently
@@ -53,30 +38,16 @@ skill({ name: "prd-task" }); // PRD → executable tasks (Phase 8)
 | --------- | -------------------------------------------- |
 | `explore` | Finding patterns in codebase, affected files |
 | `scout`   | External research, best practices            |
-| `br`      | Creating and managing beads                  |
 
 ## Phase 1: Duplicate Check
 
 ### Memory Search
 
-Follow the [memory-grounding](../skill/memory-grounding/SKILL.md) skill protocol. Focus on: duplicate bead detection, prior decisions.
-
-### Bead List Check
-
-```bash
-br list --status=open --status=in_progress
-```
-
-If a matching bead exists, stop and tell the user to use `/ship <id>` instead.
-
-## Phase 2: Classify Type
+Search memory for: prior decisions, similar work.
 
-If `--type` was provided, use it directly. Otherwise, suggest a type based on the description and ask the user to confirm:
+### Existing Work Check
 
-- **epic**: Multi-session, cross-domain (redesign, migrate, overhaul)
-- **feature**: New capability, scoped (add, implement, build, integrate)
-- **bug**: Something broken (fix, error, crash, not working)
-- **task**: Tactical change, clear scope (everything else)
+Check `.opencode/artifacts/.active` for existing work in progress. If active slug exists with a `spec.md`, ask user if they want to continue with `/ship` instead.
 
 ## Phase 3: Choose Research Depth
 
@@ -136,16 +107,19 @@ Based on research depth choice, spawn agents:
 
 **While agents run**, ask clarifying questions if the description lacks scope or expected outcome. For bugs, also ask for reproduction steps and expected vs actual behavior.
 
-## Phase 5: Create Bead
+## Phase 5: Initialize Plan
 
-Extract bead title and description from `$ARGUMENTS` before creating the bead.
+Extract title and description from `$ARGUMENTS`:
 
 - If user provided a single line, use it for both title and description.
 - If user provided multiple lines, use first line as title and full text as description.
 
+Derive a kebab-case slug from the title. This slug becomes the feature's namespace:
+
 ```bash
-BEAD_ID=$(br create --title "$TITLE" --description "$DESCRIPTION" --type $BEAD_TYPE --json | jq -r '.id')
-mkdir -p ".beads/artifacts/$BEAD_ID"
+SLUG=$(echo "$TITLE" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9 ]//g' | tr ' ' '-' | sed 's/--*/-/g; s/^-//; s/-$//')
+mkdir -p ".opencode/artifacts/$SLUG"
+echo "$SLUG" > ".opencode/artifacts/.active"
 ```
 
 ## Phase 6: Determine PRD Rigor
@@ -154,13 +128,12 @@ Not every change needs a full spec. Assess complexity to choose the right PRD le
 
 | Signal | Lite PRD | Full PRD |
 | --- | --- | --- |
-| Type | `bug`, `task` | `feature`, `epic` |
+| Scope | Simple, single-concern | Cross-cutting, multi-system |
 | Files affected | 1-3 | 4+ |
-| Scope | Clear, single-concern | Cross-cutting, multi-system |
 | Research depth | Skip or Minimal | Standard or Deep |
 | Description | "Fix X in Y" | "Implement X with Y and Z" |
 
-**Auto-detect:** If type is `bug` or `task` AND research was Skip/Minimal AND description is a single sentence → default to Lite.
+**Auto-detect:** If research was Skip/Minimal AND description is a single sentence → default to Lite.
 
 ### Lite PRD Format
 
@@ -190,7 +163,7 @@ For simple, well-scoped work (bugs, small tasks):
 
 For features and complex work, use the full template:
 
-Read the PRD template from `.opencode/memory/_templates/prd.md` and write it to `.beads/artifacts/$BEAD_ID/prd.md`.
+Read the PRD template and write it to the active feature's spec (`.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md`).
 
 ## Phase 7: Write PRD
 
@@ -214,7 +187,7 @@ Copy and fill the PRD template (lite or full) using context from Phase 4.
 
 ### Task Format
 
-Tasks must follow the `prd-task` skill format:
+Tasks must follow this format:
 
 - Title with `[category]` tag
 - One-sentence **end state** description (not step-by-step)
@@ -236,32 +209,22 @@ Before saving, verify:
 
 If any check fails, fix it — don't ask the user.
 
-## Phase 9: Claim and Prepare Workspace
-
-**If `--spec-only` was passed, skip to Phase 12 (Report).**
+## Phase 9: Prepare Workspace
 
 ### Workspace Check
 
 ```bash
 git status --porcelain
 git branch --show-current
-br list --status=in_progress
 ```
 
 - If uncommitted changes: ask user to stash, commit, or continue
-- If other tasks in progress: warn before claiming another
-
-### Claim Bead
-
-```bash
-br update $BEAD_ID --status in_progress
-```
 
 ### Create Branch
 
 ### Workspace Setup
 
-Follow the [workspace-setup](../skill/workspace-setup/SKILL.md) skill protocol.
+Set up the workspace: create branch, install deps if needed.
 
 Additionally offer a "Create worktree" option:
 
@@ -271,21 +234,16 @@ skill({ name: "using-git-worktrees" });
 
 ## Phase 10: Convert PRD to Tasks
 
-Use `prd-task` skill to convert PRD markdown → executable JSON (`prd.json`).
+Convert PRD markdown → executable JSON (`prd.json`).
 
 ## Phase 11: Report
 
 Output:
 
-1. Bead ID and type
-2. PRD location (`.beads/artifacts/$BEAD_ID/prd.md`)
-3. Summary: task count, success criteria count, affected files count
-4. Branch name and workspace (if claimed)
-5. Next step: `/ship $BEAD_ID` (or `/plan $BEAD_ID` for complex work)
-
-```bash
-br comments add $BEAD_ID "Created prd.md with [N] tasks, [M] success criteria"
-```
+1. Summary: task count, success criteria count, affected files count
+2. Branch name and workspace (if claimed)
+3. Active feature: `.opencode/artifacts/$(cat .opencode/artifacts/.active)/`
+4. Next step: `/ship` (or `/plan` for complex work)
 
 ---
 
@@ -294,5 +252,5 @@ br comments add $BEAD_ID "Created prd.md with [N] tasks, [M] success criteria"
 | Need               | Command      |
 | ------------------ | ------------ |
 | Research first     | `/research`  |
-| Plan after spec    | `/plan <id>` |
-| Implement and ship | `/ship <id>` |
+| Plan after spec    | `/plan`      |
+| Implement and ship | `/ship`      |

package/dist/template/.opencode/command/design.md

@@ -25,7 +25,6 @@ Design a component, page, or design system with a clear aesthetic point of view.
 
 ```typescript
 skill({ name: "frontend-design" }); // Design system guidance, anti-patterns, references
-skill({ name: "ux-quality-gates" }); // IA, forms, recovery, loading, usability gates
 ```
 
 ---
@@ -66,7 +65,7 @@ State these decisions explicitly:
 5. **State model** — empty, loading, error, success, disabled, and optimistic states required
 6. **Pattern selection** — form, table/list/grid, notification, modal, or navigation pattern if applicable
 
-Use the `ux-quality-gates` skill to keep these decisions concrete.
+Keep these decisions concrete and explicit.
 
 ---
 

package/dist/template/.opencode/command/explore.md

@@ -6,7 +6,7 @@ agent: plan
 
 # Explore: $ARGUMENTS
 
-Think through an idea, problem, or approach with structured alternatives and tradeoffs — before committing to a bead or plan.
+Think through an idea, problem, or approach with structured alternatives and tradeoffs — before committing to a plan.
 
 > **Workflow:** **`/explore`** → `/create` (if worth pursuing) or discard
 >
@@ -18,7 +18,6 @@ Think through an idea, problem, or approach with structured alternatives and tra
 
 ```typescript
 skill({ name: "brainstorming" }); // Collaborative refinement
-skill({ name: "memory-grounding" }); // Load past decisions
 ```
 
 ## Phase 1: Ground
@@ -134,8 +133,8 @@ Write the proposal as a structured document:
 `/create "[description based on chosen approach]"`
 ```
 
-**If a bead exists:** Save to `.beads/artifacts/$BEAD_ID/exploration.md`
-**If no bead:** Display inline, don't create files.
+**If a plan exists:** Save to `.opencode/artifacts/$(cat .opencode/artifacts/.active)/research.md`
+**If no plan:** Display inline, don't create files.
 
 ## Phase 6: Ask User
 

package/dist/template/.opencode/command/fix.md

@@ -0,0 +1,55 @@
+---
+description: Debug and fix a bug or failing test
+argument-hint: "<description of bug or error>"
+agent: build
+---
+
+# Fix: $ARGUMENTS
+
+Systematically debug and fix the reported issue.
+
+## Load Skills
+
+```typescript
+skill({ name: "root-cause-tracing" });
+skill({ name: "verification-before-completion" });
+```
+
+## Process
+
+### Phase 1: Reproduce
+
+```bash
+# Reproduce the issue with the exact steps or command
+```
+
+### Phase 2: Isolate
+
+- Search for the error message or symptom in the codebase
+- Trace the execution path to find the root cause
+- Read the 2-4 most relevant files
+- Distinguish symptom from root cause
+
+### Phase 3: Fix
+
+- Apply the minimal fix for the root cause
+- Do not add speculative guards, tolerant readers, or defensive copies
+- Prefer making the bad state impossible over handling all bad states
+
+### Phase 4: Verify
+
+```bash
+npm run typecheck
+npm run lint
+npm test            # or vitest relevant test
+```
+
+If verification fails twice on the same approach, escalate with learnings.
+
+## Output
+
+Report:
+1. Root cause (with file:line)
+2. Fix applied
+3. Verification results
+4. What else was considered and rejected

package/dist/template/.opencode/command/improve-architecture.md

@@ -0,0 +1,55 @@
+---
+description: Proactive architecture health check — find shallow modules, propose deep-module redesigns
+argument-hint: "[path|module|'all'] [--scope surface|deep]"
+agent: review
+---
+
+# Improve Architecture: $ARGUMENTS
+
+Proactive architecture health check. Find shallow modules and propose deep-module redesigns.
+
+## Load Skills
+
+```typescript
+skill({ name: "deep-module-design" });
+skill({ name: "verification-before-completion" });
+```
+
+## Architecture Check
+
+Apply Ousterhout's deep module principles:
+- **Small interface** — does this module expose more than it should?
+- **Information hiding** — are implementation details leaking?
+- **Pull complexity downward** — are callers doing work the module should own?
+
+## Process
+
+### Phase 1: Scan
+
+If path given, focus on that directory. If `all`, scan the full project.
+
+For each module, assess:
+- Lines of interface vs lines of implementation
+- Number of callers and how they use it
+- What knowledge is embedded but not encapsulated
+- What would break if the module were redesigned
+
+### Phase 2: Propose
+
+For each finding:
+
+| Module | Issue | Proposed Redesign | Effort | Risk |
+|---|---|---|---|---|
+| path/to/module | Shallow interface exposing internals | Encapsulate behind 3 functions | M | Low |
+
+### Phase 3: Prioritize
+
+Rank proposals by impact/effort ratio. Recommend top 1-3 changes worth making.
+
+## Output
+
+Report:
+1. Modules reviewed
+2. Findings (current issue, proposed redesign, effort, risk)
+3. Top recommendations
+4. Quick wins (S-effort changes)