opencodekit 0.12.1 → 0.12.3

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

@@ -1,310 +1,146 @@
 ---
-description: Implement a bead - setup workspace, execute changes, verify
+description: Implement a bead - load context, make changes, verify
 argument-hint: "<bead-id>"
 agent: build
 ---
 
-# Implement
+# Implement: $ARGUMENTS
 
-**Load skills:**
+You're implementing a tracked task. Stay focused, verify as you go, hand off if you hit limits.
+
+## First: Load Context
 
 ```typescript
-skill({ name: "beads" }); // Session protocol and hierarchy
+skill({ name: "beads" });
 skill({ name: "test-driven-development" });
 skill({ name: "verification-before-completion" });
 ```
 
-For large tasks with 3+ phases, also load: `skill({ name: "subagent-driven-development" })`
-
-## Phase 1: Setup Workspace
-
-```typescript
-bd_init({ team: "project", role: "<your-role>" });
-bd_show({ id: "$ARGUMENTS" });
-```
-
-**Check for messages from other agents:**
+Get the task details and check for messages:
 
-```typescript
-bd_inbox({ n: 5, unread: true, global: true });
+```bash
+bd show $ARGUMENTS
+bd list --status=in_progress  # See what else is active
 ```
 
-Review any coordination messages before starting.
-
-Check git state:
+Check git state. If dirty, ask whether to stash, commit, or continue:
 
 ```bash
 git status --porcelain
 git branch --show-current
 ```
 
-If uncommitted changes exist, ask: "Stash, commit, or continue?"
-
-Create branch if not on bead branch:
+Create a branch if not already on one for this task:
 
 ```bash
-git checkout -b <bead-id>
-```
-
-**Claim the task:**
-
-```typescript
-bd_claim({ reason: "Starting implementation of <bead-id>" });
-```
-
-This registers you in the workspace. If another agent is working on the same task, you'll be notified.
-
-## Phase 2: Load Context & Estimation
-
-**Check for previous session work:**
-
-```typescript
-list_sessions({ project: "current", limit: 3 });
+git checkout -b $ARGUMENTS
 ```
 
-If recent session exists:
-
-```typescript
-read_session({ session_reference: "last", project: "current" });
-```
-
-Review what was already attempted/completed.
-
-**Load artifacts:**
-
-```bash
-ls .beads/artifacts/<bead-id>/ 2>/dev/null || echo "No artifacts yet"
-```
-
-**Extract estimation from spec/plan:**
-
-Look for estimate tag (S/M/L/XL) and set budget:
-
-| Estimate | Tool Call Budget | Checkpoint Frequency |
-| -------- | ---------------- | -------------------- |
-| S        | ~10              | End only             |
-| M        | ~30              | Every 10 calls       |
-| L        | ~100             | Every 20 calls       |
-| XL       | Decomposed       | Every step           |
-
-```
-Implementation Budget:
-━━━━━━━━━━━━━━━━━━━━━
-
-Estimate: [S/M/L] (~[N] tool calls)
-Budget: [N] tool calls
-Checkpoint: Every [N] calls
-```
-
-**Determine mode:**
-
-- **If `plan.md` exists:** Follow the plan step-by-step (Planned Mode)
-- **If `research.md` exists but no plan:** Ask user "Create plan first? Or implement directly?"
-- **If only `spec.md` exists:** Read spec and implement directly (Quick Mode)
-- **If no artifacts:** Read bead description and implement based on that
-
-Check for handoffs:
+Mark the task in progress:
 
 ```bash
-ls .beads/artifacts/<bead-id>/handoffs/ 2>/dev/null
+bd update $ARGUMENTS --status in_progress
 ```
 
-If handoff exists, load latest and continue from checkpoint.
-
-## Phase 3: Detect Project Type
+## Load Artifacts
 
-Check which project files exist:
+Check what context exists:
 
 ```bash
-ls package.json Cargo.toml pyproject.toml setup.py Makefile go.mod 2>/dev/null || true
+ls .beads/artifacts/$ARGUMENTS/ 2>/dev/null || echo "No artifacts"
 ```
 
-| Project Type       | Test Command    | Lint Command                         |
-| ------------------ | --------------- | ------------------------------------ |
-| Node.js/TypeScript | `npm test`      | `npm run lint && npm run type-check` |
-| Rust               | `cargo test`    | `cargo clippy -- -D warnings`        |
-| Python             | `pytest`        | `ruff check . && mypy .`             |
-| Go                 | `go test ./...` | `golangci-lint run`                  |
-| Make-based         | `make test`     | `make lint`                          |
+If `plan.md` exists, follow it step by step. If only `spec.md` exists, implement directly from requirements. If nothing exists, work from the bead description.
 
-Report:
-
-```
-Implementing: <bead-id>
-━━━━━━━━━━━━━━━━━━━━━━
-
-Project: [detected type]
-Mode: [Quick/Planned]
-Estimate: [S/M/L] (~[N] tool calls)
-```
-
-## Phase 4: Implementation
-
-### Check Locks & Reserve Files
-
-```typescript
-bd_reservations({ reason: "Checking for conflicts before implementation" });
-```
-
-If files you need are locked:
-
-- Wait for lock to expire, or
-- Coordinate via `bd_msg`, or
-- Work on different files
-
-Reserve files before editing:
+Check for previous session work:
 
 ```typescript
-bd_reserve({
-  paths: ["src/auth.ts", "src/utils/**"],
-  reason: "Implementing <bead-id>",
-  ttl: 600,
-});
+list_sessions({ project: "current", limit: 3 });
+read_session({ session_reference: "last", project: "current" });
 ```
 
-### Escape Hatches
+## Estimate Your Budget
 
-Set limits before starting:
+Look at the task complexity and set limits:
 
-| Condition                      | Action                                |
-| ------------------------------ | ------------------------------------- |
-| Step fails 3x                  | Stop, analyze, try different approach |
-| Tests fail 5x consecutively    | Pause, ask human for guidance         |
-| Budget 80% exhausted           | Checkpoint commit, reassess scope     |
-| Budget exhausted               | `/handoff` with progress summary      |
-| Blocked on external dependency | Create blocker bead, move on          |
+- **Small** (~10 tool calls): Simple change, one file, clear path
+- **Medium** (~30 tool calls): Multiple files, some exploration needed
+- **Large** (~100 tool calls): Cross-cutting, needs research, checkpoint often
+- **XL**: Should be decomposed into smaller tasks first
 
-### With Plan (Planned Mode)
+If you hit 80% of budget without finishing, create a handoff. Don't push past limits and produce garbage.
 
-For each unchecked step in plan.md:
+## Do The Work
 
-1. **Check rollback point** from plan (if exists)
-2. Make changes to listed files
-3. Run step verification command
-4. If fails 3x: Use rollback, try different approach
-5. Mark step complete: `- [x]`
-6. **Checkpoint commit** (if L/XL or significant change)
+Detect project type and know your verification commands:
 
 ```bash
-git add <files> && git commit -m "WIP: <bead-id> - Step N complete"
-```
-
-### Without Plan (Quick Mode)
-
-1. Read spec requirements and success criteria
-2. Identify files to change
-3. Make minimal, focused changes
-4. Run verification after each logical change
-5. Keep changes atomic and reviewable
-
-### Gate Rules
-
-| Gate       | On Failure                          |
-| ---------- | ----------------------------------- |
-| Type check | Fix before proceeding               |
-| Tests      | Fix before proceeding (max 3 tries) |
-| Lint       | Auto-fix if possible, else note     |
-
-### Track Progress
-
-After every 10 tool calls (or per checkpoint frequency):
-
+ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null
 ```
-Progress: <bead-id>
-━━━━━━━━━━━━━━━━━━
 
-Tool calls: [N]/[budget]
-Steps: [completed]/[total]
+Node/TypeScript: `npm test`, `npm run lint && npm run type-check`
+Rust: `cargo test`, `cargo clippy -- -D warnings`
+Python: `pytest`, `ruff check . && mypy .`
+Go: `go test ./...`, `golangci-lint run`
 
-Recent changes:
-- src/foo.ts:15 - [what changed]
+**Rules while implementing:**
 
-Verification: Test ✓ | Lint ✓ | Types ✓
+1. Read before edit. Always.
+2. Run verification after each logical change
+3. If something fails 3 times, stop and try a different approach
+4. Checkpoint commit after significant progress: `git commit -m "WIP: $ARGUMENTS - [step]"`
+5. If blocked on external dependency, create a new bead for it and move on
 
-Continue? (yes/pause/stop)
-```
+Track your progress. Every 10 tool calls, check: Am I on track? Should I checkpoint? Am I approaching budget?
 
-If "pause" or "stop": Run `/handoff <bead-id>`.
+## Before Claiming Done
 
-## Phase 5: Pre-Completion Verification
-
-Before claiming done, verify against spec success criteria:
+Verify against success criteria in the spec:
 
 ```bash
-cat .beads/artifacts/<bead-id>/spec.md | grep -A 20 "Success Criteria"
+cat .beads/artifacts/$ARGUMENTS/spec.md | grep -A 20 "Success Criteria"
 ```
 
-For each criterion:
-
-- [ ] Run the verification command listed
-- [ ] Confirm it passes
-- [ ] Document result
+Run each verification command. All must pass. No exceptions.
 
-```
-Success Criteria Check:
-━━━━━━━━━━━━━━━━━━━━━━
+Run the full test suite one more time:
 
-- [x] [Criterion 1] - Verify: `npm test auth` ✓
-- [x] [Criterion 2] - Verify: `curl localhost:3000/health` ✓
-- [ ] [Criterion 3] - Verify: [command] ✗ (needs fix)
+```bash
+# Whatever your project uses
+npm test && npm run type-check
 ```
 
-**Do not proceed until all criteria pass.**
-
-## Phase 6: Update Memory (if needed)
+## Complete
 
-If you encountered unexpected issues:
+If all gates pass:
 
-```typescript
-memory -
-  update({
-    file: "project/gotchas",
-    content: "## [Issue Title]\n\n[What happened and how to avoid it]",
-    mode: "append",
-  });
+```bash
+git add -A
+git commit -m "$ARGUMENTS: [summary]"
 ```
 
-## Phase 7: Complete
-
-Release file reservations:
-
 ```typescript
-bd_release({ _: true });
+bd_sync({ reason: "Sync implementation progress" });
 ```
 
-Run full verification suite:
+Report what was done and suggest next step:
 
-```bash
-[project-specific test command]
-[project-specific lint command]
 ```
+Done: $ARGUMENTS
 
-Sync with other agents:
-
-```typescript
-bd_sync({ reason: "Implementation complete for <bead-id>" });
+Changes: [files modified]
+Tests: Pass
+Next: /finish $ARGUMENTS
 ```
 
-**Final report:**
+If gates fail, fix them. Don't proceed with broken code.
 
-If all pass:
+## If You Can't Finish
 
-```
-Implementation Complete: <bead-id>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Tool calls: [actual]/[budget] ([over/under] by [N])
-All gates passed ✓
-All success criteria verified ✓
+Hit budget limit or context getting too large? Create a handoff:
 
-Next: /finish <bead-id>
 ```
-
-If any fail:
-
+/handoff $ARGUMENTS "Stopped at [step]. Next: [what to do]"
 ```
-Gate failed: [which one]
-Retries: [N]/3
 
-Fix issues before running /finish.
-```
+Then start a fresh session. Don't grind past diminishing returns.

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

@@ -1,254 +1,106 @@
 ---
-description: Analyze GitHub issue and create bead for tracking
+description: Import GitHub issue as tracked bead
 argument-hint: "<issue-number>"
 agent: build
 ---
 
-# Analyze Issue: $ARGUMENTS
+# Issue: $ARGUMENTS
 
-## Load Beads Skill
+You're importing a GitHub issue into beads for tracking.
 
-```typescript
-skill({ name: "beads" });
-```
-
-## Phase 1: Check for Duplicates
-
-Before creating, search for existing similar beads:
+## Check For Duplicates
 
-```typescript
-// Search for similar issues
-bd_search({ query: "[keywords from issue title]" });
-
-// Or list recent beads
-bd_ls({ status: "all", limit: 20 });
+```bash
+bd list --status=all | grep -i "[keywords from issue]"
 ```
 
-If similar bead exists:
+If similar bead exists, link to it instead of creating duplicate.
 
-- Link as related, or
-- Add to existing bead, or
-- Confirm this is intentionally separate
-
-## Phase 2: Fetch GitHub Issue
+## Fetch The Issue
 
 ```bash
-gh issue view $ARGUMENTS --json title,body,labels,state,assignees,milestone
+gh issue view $ARGUMENTS --json title,body,labels,state
 ```
 
 Extract:
 
-- **Title**: Issue title
-- **Labels**: For tag mapping
-- **Body**: For analysis
-
-## Phase 3: Analysis
-
-Parse the issue content:
-
-| Field        | Extract From                    |
-| ------------ | ------------------------------- |
-| **Problem**  | What's broken/needed?           |
-| **Expected** | What should happen?             |
-| **Current**  | What happens now?               |
-| **Steps**    | How to reproduce?               |
-| **Files**    | Mentioned files or components   |
-| **Labels**   | bug, feature, enhancement, etc. |
-
-## Phase 4: Map Labels & Priority
-
-**Label → Tag mapping:**
-
-| GitHub Label  | Bead Tag |
-| ------------- | -------- |
-| bug           | bug      |
-| enhancement   | feature  |
-| feature       | feature  |
-| documentation | docs     |
-| frontend, ui  | fe       |
-| backend, api  | be       |
-| mobile        | mobile   |
-| devops, infra | devops   |
-| testing       | qa       |
+- **Title** - issue title
+- **Labels** - for type/priority mapping
+- **Body** - problem description, reproduction steps
 
-**Priority mapping:**
+## Map Labels
 
-| GitHub Signal             | Bead Priority |
-| ------------------------- | ------------- |
-| critical, P0, blocker     | 0             |
-| high, P1, urgent          | 1             |
-| medium, P2 (default)      | 2             |
-| low, P3                   | 3             |
-| backlog, P4, nice-to-have | 4             |
+| GitHub Label         | Bead Type | Priority |
+| -------------------- | --------- | -------- |
+| bug                  | bug       | 1        |
+| feature, enhancement | feature   | 2        |
+| critical, blocker    | -         | 0        |
+| low, backlog         | -         | 4        |
 
-## Phase 5: Estimate Complexity
+## Create The Bead
 
-Based on issue analysis:
-
-| Signals                               | Estimate | Next Step  |
-| ------------------------------------- | -------- | ---------- |
-| Single file, obvious fix, clear repro | S (~10)  | /implement |
-| Few files, clear scope, known area    | M (~30)  | /implement |
-| Multiple files, needs investigation   | L (~100) | /research  |
-| Vague, architectural, cross-cutting   | XL       | Decompose  |
-
-## Phase 6: Create Tracking Bead
-
-Reserve spec file:
-
-```typescript
-bd_reserve({
-  paths: [".beads/artifacts/<bead-id>/spec.md"],
-  reason: "Creating issue bead",
-  ttl: 600,
-});
-```
-
-Create bead with mapped values:
-
-```typescript
-bd_add({
-  title: "<issue title>",
-  type: "[bug|feature|task]", // from label mapping
-  pri: [0 - 4], // from priority mapping
-  tags: ["[role]", "[estimate]"], // e.g., ["fe", "M"]
-  desc: "GitHub Issue #$ARGUMENTS",
-});
+```bash
+bd create "[issue title]" -t [type] -p [priority]
 ```
 
-## Phase 7: Create Spec
+## Create Spec
 
-Use `.opencode/memory/_templates/prd.md` as base structure.
-
-Save to `.beads/artifacts/<bead-id>/spec.md`:
+Write `.beads/artifacts/<bead-id>/spec.md`:
 
 ```markdown
 # [Issue Title]
 
 **Bead:** <bead-id>
+**GitHub:** #$ARGUMENTS
 **Created:** [date]
-**Status:** To Do
-**GitHub Issue:** #$ARGUMENTS
-**Estimate:** [S/M/L/XL] (~[N] tool calls)
 
 ## Goal
 
-[What exactly are we fixing/building and why?]
-
-## Scope
-
-**In-Scope:**
+[What we're fixing/building from issue body]
 
-- [Files to change]
-- [Specific functionality to fix/add]
+## Reproduction
 
-**Out-of-Scope:**
-
-- [What we are NOT touching]
-
-## User Flow
-
-1. [How user encounters the issue]
-2. [Expected behavior after fix]
+[Steps from issue if bug]
 
 ## Success Criteria
 
-- [ ] [Criterion 1]
-  - Verify: `[actual command to test]`
-- [ ] [Criterion 2]
-  - Verify: `[actual command to test]`
-- [ ] No regression in related functionality
+- [ ] [From issue acceptance criteria]
+  - Verify: `[command]`
+- [ ] No regression
   - Verify: `npm test`
 
 ## Constraints
 
-**Must:**
-
-- [Required constraint from issue]
-
-**Never:**
-
-- [Anti-pattern or forbidden action]
-
-## Dependencies
-
-- [List any prerequisites or blocking tasks]
-
-## Notes
-
-- **Risks/edge cases:** [What could go wrong]
-- **Testing strategy:** [How to verify fix]
-- **Related issues:** [Link to related GitHub issues]
+[From issue if any]
 ```
 
-## Phase 8: Comment on GitHub Issue
-
-Add bead reference back to GitHub:
+## Comment On GitHub
 
 ```bash
 gh issue comment $ARGUMENTS --body "Tracking: \`<bead-id>\`
 
-Estimate: [S/M/L/XL]
+Estimate: [S/M/L]
 Next: [/implement or /research]"
 ```
 
-## Phase 9: Assign Role (optional)
-
-For multi-agent workflows:
+## Sync
 
 ```typescript
-bd_assign({ id: "<bead-id>", role: "[fe/be/mobile/devops/qa]", notify: true });
+bd_sync({ reason: "Sync imported issue" });
 ```
 
-## Phase 10: Sync & Report
+## Output
 
-```typescript
-bd_release({ _: true });
-bd_sync({ reason: "Created bead for issue #$ARGUMENTS" });
 ```
-
-```
-Issue Imported: #$ARGUMENTS
-━━━━━━━━━━━━━━━━━━━━━━━━━━
+Imported: #$ARGUMENTS
 
 Bead: <bead-id>
 Type: [bug/feature/task]
 Priority: [0-4]
-Estimate: [S/M/L/XL] (~[N] tool calls)
-
-Labels mapped: [list]
-Tags: [list]
-
 Spec: .beads/artifacts/<bead-id>/spec.md
-GitHub: Commented with bead reference ✓
-```
-
-**Next steps by estimate:**
-
-| Estimate | Command                |
-| -------- | ---------------------- |
-| S/M      | `/implement <bead-id>` |
-| L        | `/research <bead-id>`  |
-| XL       | Decompose first        |
-
-## Discovered Work
 
-If analysis reveals additional issues:
-
-```typescript
-bd_add({
-  title: "<discovered issue>",
-  type: "task",
-  pri: 2,
-  parent: "<parent-bead-id>",
-  tags: ["[role]", "[estimate]"],
-});
-```
-
-Report discovered work:
-
-```
-Discovered Work:
-- <child-bead-id>: [title] ([estimate])
-- <child-bead-id>: [title] ([estimate])
+Next:
+- S/M estimate: /implement <bead-id>
+- L estimate: /research <bead-id>
+- XL: Decompose first
 ```

package/dist/template/.opencode/command/new-feature.md

@@ -39,7 +39,7 @@ bd_ls({ status: "all", limit: 20, offset: 0 })
 
 # Analyze codebase structure
 glob pattern="src/**/*.{ts,tsx,py}"
-lsp_workspace_symbols({ query: "[relevant-terms]" })
+lsp_lsp_workspace_symbols({ query: "[relevant-terms]" })
 
 # Check recent changes in related areas
 git log --oneline -10 -- src/[relevant-path]/