opencodekit 0.12.2 → 0.12.3

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

@@ -1,526 +1,170 @@
 ---
-description: Create implementation plan with optional bead decomposition
-argument-hint: "<bead-id> [--create-beads] [--parallel]"
+description: Create implementation plan for a bead
+argument-hint: "<bead-id> [--create-beads]"
 agent: planner
 ---
 
-# Plan
+# Plan: $ARGUMENTS
 
-**Load skills:**
+You're creating an implementation plan. Design first, then execute.
 
-```typescript
-skill({ name: "beads" }); // For hierarchy and dependencies
-skill({ name: "writing-plans" }); // For plan structure
-```
-
-## Arguments
-
-| Argument         | Default  | Description                           |
-| ---------------- | -------- | ------------------------------------- |
-| `<bead-id>`      | required | The bead to plan                      |
-| `--create-beads` | false    | Create child beads for each plan task |
-| `--parallel`     | false    | Identify parallel execution tracks    |
-
-## Phase 1: Load Context
-
-```typescript
-bd_show({ id: "$ARGUMENTS" });
-```
-
-Read artifacts:
-
-```typescript
-read({ filePath: ".beads/artifacts/<bead-id>/spec.md" });
-read({ filePath: ".beads/artifacts/<bead-id>/research.md" });
-read({ filePath: ".beads/artifacts/<bead-id>/design.md" }); // May not exist
-```
-
-If spec.md missing: "Run `/create <bead-id>` first."
-If research.md missing and complexity > M: "Run `/research <bead-id>` first."
-If design.md exists: Resume from saved design options.
+## Load Context
 
-Reserve files while planning:
-
-```typescript
-bd_reserve({
-  paths: [
-    ".beads/artifacts/<bead-id>/design.md",
-    ".beads/artifacts/<bead-id>/plan.md",
-  ],
-  reason: "Planning $ARGUMENTS",
-  ttl: 1200,
-});
+```bash
+bd show $ARGUMENTS
+cat .beads/artifacts/$ARGUMENTS/spec.md
+cat .beads/artifacts/$ARGUMENTS/research.md 2>/dev/null
 ```
 
-## Phase 2: Analyze for Decomposition
+If spec.md missing: "Run `/create $ARGUMENTS` first."
+If complexity > M and no research: "Consider `/research $ARGUMENTS` first."
 
-Before generating options, analyze if this bead should be decomposed:
+## Analyze For Decomposition
 
-```
-DECOMPOSITION ANALYSIS
-━━━━━━━━━━━━━━━━━━━━━━
+Should this be one bead or multiple?
 
-Bead: <bead-id>
-Title: [title from bead]
-Current Type: [task/feature/epic]
+**Keep as single bead:**
 
-Complexity Signals:
-[✓/✗] Multiple domains (frontend + backend)
-[✓/✗] Multiple files in different areas
-[✓/✗] Natural phases (setup → implement → test)
-[✓/✗] Could benefit from parallel execution
-[✓/✗] Estimated > 50 tool calls
+- Single domain (just frontend OR just backend)
+- 2-3 files max
+- ~50 tool calls or less
+- No natural phases
 
-Recommendation: [DECOMPOSE / SINGLE PLAN]
+**Decompose into subtasks:**
 
-If DECOMPOSE: Will create Epic + child beads
-If SINGLE PLAN: Will create plan.md with task checklist
-```
+- Crosses domains (frontend + backend)
+- Multiple independent pieces
+- Natural phases (setup → implement → test)
+- Could benefit from parallel agents
 
-If `--create-beads` flag is set, proceed with decomposition.
-If complexity warrants decomposition, suggest it:
+If decomposition makes sense, ask: "This would benefit from subtasks. Create child beads?"
 
-```
-This bead would benefit from decomposition into subtasks.
+## Generate Design Options
 
-Benefits:
-• Parallel agent execution
-• Better context management
-• Clearer progress tracking
+Present 2-3 approaches:
 
-Create child beads? (yes/no)
 ```
+## Option A: [Name]
 
-## Phase 3: Generate Design Options
-
-Present 2-3 approaches with this format:
-
-```markdown
-## Design Options
-
-### Option A: [Name]
-
-**Approach:** [1-2 sentence description]
-
-**Changes:**
-
-- `src/foo.ts` - [what changes]
-- `src/bar.ts` - [what changes]
+Approach: [1-2 sentences]
 
-**Pros:** [bullet list]
-**Cons:** [bullet list]
+Changes:
+- `src/foo.ts` - [what]
+- `src/bar.ts` - [what]
 
-**Estimation:**
-
-- Tool calls: ~[N] (S=5-20, M=20-50, L=50-100, XL=needs decomposition)
-- Files touched: [N]
-- Risk: [low/medium/high]
-
-**Parallelization potential:** [High/Medium/Low]
+Pros: [list]
+Cons: [list]
+Effort: [S/M/L] (~N tool calls)
 
 ---
 
-### Option B: [Name]
+## Option B: [Name]
 
-[Same format]
+[same format]
 
 ---
 
-**Recommendation:** Option [A/B] because [reason].
+Recommendation: Option [A/B] because [reason].
 ```
 
-Save to `.beads/artifacts/<bead-id>/design.md` with status `Pending Approval`.
-
-## Phase 4: Get Approval
-
-**STOP and wait for human response.**
-
-```
-Pick an option (A/B/C), modify, or "none" to propose alternatives.
-```
+Save to `.beads/artifacts/$ARGUMENTS/design.md`.
 
-Do not proceed until user confirms.
+**STOP. Wait for user to pick an option.**
 
-## Phase 5: Create Plan with Task Contracts
+## Create Plan
 
-After approval, write `.beads/artifacts/<bead-id>/plan.md`:
+After approval, write `.beads/artifacts/$ARGUMENTS/plan.md`:
 
 ```markdown
-# Implementation Plan: [Title]
+# Plan: [Title]
 
-**Bead:** <bead-id>
-**Date:** <date>
-**Approach:** [selected option name]
-**Estimation:** ~[N] tool calls, [N] files
-**Decomposition:** [Yes - child beads created / No - single bead]
-
-## Dependency Graph
-```
-
-[Task 1] ──┬──> [Task 2a] ──┬──> [Task 4]
-│ │
-└──> [Task 2b] ──┘
-│
-└──> [Task 3] (can run parallel)
-
-````
-
-**Parallel Tracks:**
-- Track A: Tasks 1 → 2a → 4
-- Track B: Tasks 1 → 2b → 3 (independent after Task 1)
+**Bead:** $ARGUMENTS
+**Approach:** [selected option]
+**Estimate:** ~N tool calls
 
 ## Tasks
 
-### Task 1: [Title]
+### 1. [Task name]
 
-| Field         | Value                              |
-| ------------- | ---------------------------------- |
-| **Bead**      | [child-bead-id if created]         |
-| **Files**     | `src/foo.ts`                       |
-| **Input**     | [What this task receives/needs]    |
-| **Output**    | [What this task produces]          |
-| **Success**   | [Concrete verification criteria]   |
-| **Rollback**  | [How to undo if this fails]        |
-| **Depends**   | None                               |
-| **Effort**    | S (~10 tool calls)                 |
+Files: `src/foo.ts`
+Changes:
 
-**Changes:**
-- [ ] [Specific change 1]
-- [ ] [Specific change 2]
+- [ ] [specific change]
+- [ ] [specific change]
 
-**Verification:**
-```bash
-[Actual command to verify success]
-````
+Verify: `npm test -- foo.test.ts`
 
 ---
 
-### Task 2a: [Title]
+### 2. [Task name]
 
-| Field        | Value                            |
-| ------------ | -------------------------------- |
-| **Bead**     | [child-bead-id if created]       |
-| **Files**    | `src/bar.ts`                     |
-| **Input**    | Output from Task 1               |
-| **Output**   | [What this produces]             |
-| **Success**  | [Test passes, type checks, etc.] |
-| **Rollback** | `git checkout src/bar.ts`        |
-| **Depends**  | Task 1                           |
-| **Effort**   | M (~30 tool calls)               |
+Depends on: Task 1
+Files: `src/bar.ts`
+Changes:
 
-**Changes:**
+- [ ] [specific change]
 
-- [ ] [Specific change]
-
-**Verification:**
-
-```bash
-npm run test -- src/bar.test.ts
-```
+Verify: `npm test -- bar.test.ts`
 
 ---
 
-[Continue for all tasks...]
-
-## Escape Hatches
-
-- **Max iterations per task:** 3 attempts before human intervention
-- **Checkpoint after:** Tasks 2a, 3 (high-risk points)
-- **Abort if:** [Condition that means we should stop]
-
 ## Final Verification
 
-- [ ] All task verifications pass
-- [ ] `npm run type-check` passes
-- [ ] `npm run test` passes
-- [ ] Manual smoke test: [specific action]
-
-## Risks
-
-| Risk     | Likelihood | Impact | Mitigation      |
-| -------- | ---------- | ------ | --------------- |
-| [Risk 1] | Medium     | High   | [How to handle] |
-| [Risk 2] | Low        | Medium | [How to handle] |
-
-````
-
-## Phase 6: Create Child Beads (if --create-beads or user approved)
-
-For each task in the plan, create a child bead:
-
-```typescript
-// Get parent bead ID
-const parentId = "$ARGUMENTS";
-
-// Task 1: No dependencies
-const task1 = bd_add({
-  title: "[Task 1 title from plan]",
-  type: "task",
-  pri: 2,
-  parent: parentId,
-  desc: "[Task 1 description]",
-  tags: ["[domain]", "[size]"],
-});
-
-// Task 2a: Depends on Task 1
-const task2a = bd_add({
-  title: "[Task 2a title from plan]",
-  type: "task",
-  pri: 2,
-  parent: parentId,
-  deps: [task1.id],
-  desc: "[Task 2a description]",
-  tags: ["[domain]", "[size]"],
-});
-
-// Task 2b: Also depends on Task 1 (parallel with 2a)
-const task2b = bd_add({
-  title: "[Task 2b title from plan]",
-  type: "task",
-  pri: 2,
-  parent: parentId,
-  deps: [task1.id],
-  desc: "[Task 2b description]",
-  tags: ["[domain]", "[size]"],
-});
-
-// Task 3: Depends on Task 1 (parallel track)
-const task3 = bd_add({
-  title: "[Task 3 title from plan]",
-  type: "task",
-  pri: 2,
-  parent: parentId,
-  deps: [task1.id],
-  desc: "[Task 3 description]",
-  tags: ["[domain]", "[size]"],
-});
-
-// Task 4: Depends on 2a and 2b
-const task4 = bd_add({
-  title: "[Task 4 title from plan]",
-  type: "task",
-  pri: 2,
-  parent: parentId,
-  deps: [task2a.id, task2b.id],
-  desc: "[Task 4 description]",
-  tags: ["[domain]", "[size]"],
-});
-````
-
-### Update Plan with Bead IDs
-
-After creating beads, update plan.md to include bead IDs in each task table.
-
-### Visualize Dependency Graph
-
+- [ ] `npm test`
+- [ ] `npm run type-check`
 ```
-CHILD BEADS CREATED
-━━━━━━━━━━━━━━━━━━━
-
-Parent: <parent-id> "[Title]"
 
-<parent>.1 [Task 1] ──┬──> <parent>.2 [Task 2a] ──┬──> <parent>.5 [Task 4]
-     (READY)          │          │                │
-                      │          ▼                │
-                      └──> <parent>.3 [Task 2b] ──┘
-                      │
-                      └──> <parent>.4 [Task 3]
-                                (parallel track)
+## If Creating Child Beads
 
-READY NOW: <parent>.1
-PARALLEL AFTER .1: <parent>.2, <parent>.3, <parent>.4
-FINAL: <parent>.5
+With `--create-beads` flag or user approval:
 
-Run `bd ready` to see claimable work.
-```
-
-## Phase 7: Upgrade Parent to Epic (if needed)
+```bash
+# Task 1 (no blockers)
+bd create "[task 1 title]" -t task -p 2
 
-If parent was a `task` or `feature` and we created children, upgrade it:
+# Task 2 (blocked by task 1)
+bd create "[task 2 title]" -t task -p 2
+bd dep add bd-[task2] bd-[task1] --type blocks
 
-```typescript
-// Check current type
-const parent = bd_show({ id: parentId });
-
-if (parent.type !== "epic" && childBeadsCreated > 0) {
-  // Update parent to epic type
-  bd_msg({
-    subj: "Upgraded to Epic",
-    body: `${parentId} upgraded from ${parent.type} to epic with ${childBeadsCreated} subtasks`,
-    to: "all",
-    importance: "normal",
-    global: true,
-  });
-}
+# Visualize
+bd dep tree $ARGUMENTS
 ```
 
-## Phase 8: Generate ADR & Sync
-
-Create `.beads/artifacts/<bead-id>/adr.md`:
-
-```markdown
-# ADR: [Decision Title]
-
-**Status:** Accepted
-**Date:** <date>
-**Bead:** <bead-id>
-
-## Context
-
-[Problem statement from spec.md - why we needed to decide]
-
-## Decision
-
-We chose **[Option Name]** because:
-
-- [Reason 1]
-- [Reason 2]
-
-## Alternatives Considered
-
-- **[Option B]:** Rejected because [reason]
-- **[Option C]:** Rejected because [reason]
-
-## Decomposition Decision
-
-[If child beads created:]
-We decomposed this into [N] subtasks because:
-
-- [Reason: parallel execution, context management, etc.]
-
-Child beads: <parent>.1, <parent>.2, ...
-
-[If not decomposed:]
-We kept this as a single bead because:
-
-- [Reason: small scope, single domain, etc.]
+Update plan.md with bead IDs.
 
-## Consequences
-
-**Positive:**
-
-- [Benefit 1]
-- [Benefit 2]
-
-**Negative:**
-
-- [Tradeoff 1]
-- [Tradeoff 2]
-
-## Confirmation
-
-This decision is confirmed when:
-
-- [ ] Implementation complete per plan.md
-- [ ] All verification steps pass
-```
-
-Update bead and sync:
+## Sync
 
 ```typescript
-bd_msg({
-  subj: "Plan approved",
-  body: `Approach: [selected option]\nTasks: [count]\nChild beads: [yes/no]\nEstimate: ~[N] tool calls`,
-  to: "all",
-  importance: "normal",
-  global: true,
-});
-
-bd_release({ _: true });
-bd_sync({ reason: "Plan approved for $ARGUMENTS" });
+bd_sync({ reason: "Sync plan" });
 ```
 
 ## Output
 
-### Without Child Beads
+Without child beads:
 
 ```
-Plan Approved: <bead-id>
-━━━━━━━━━━━━━━━━━━━━━━━━
+Plan: $ARGUMENTS
 
-Approach: [selected option]
-Tasks: [count] (tracked in plan.md)
-Estimate: ~[N] tool calls
+Approach: [selected]
+Tasks: [count]
+Estimate: ~N tool calls
 
 Artifacts:
-- .beads/artifacts/<bead-id>/design.md (approved)
-- .beads/artifacts/<bead-id>/plan.md
-- .beads/artifacts/<bead-id>/adr.md
+- .beads/artifacts/$ARGUMENTS/design.md
+- .beads/artifacts/$ARGUMENTS/plan.md
 
-Next: /implement <bead-id>
+Next: /implement $ARGUMENTS
 ```
 
-### With Child Beads
+With child beads:
 
 ```
-Plan Approved: <bead-id> (Epic)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Approach: [selected option]
-Child beads created: [count]
+Plan: $ARGUMENTS (Epic)
 
 Subtasks:
-├── <bead>.1: [Task 1] [S] ← READY
-├── <bead>.2: [Task 2a] [M] ← blocked by .1
-├── <bead>.3: [Task 2b] [M] ← blocked by .1
-├── <bead>.4: [Task 3] [S] ← blocked by .1
-└── <bead>.5: [Task 4] [M] ← blocked by .2, .3
+├── bd-[x].1: [title] ← READY
+├── bd-[x].2: [title] ← blocked by .1
+└── bd-[x].3: [title] ← blocked by .2
 
-Parallel Tracks:
-• Track A: .1 → .2 → .5
-• Track B: .1 → .3 → .5
-• Track C: .1 → .4
-
-Artifacts:
-- .beads/artifacts/<bead-id>/design.md
-- .beads/artifacts/<bead-id>/plan.md
-- .beads/artifacts/<bead-id>/adr.md
-
-Next Steps:
-├── Start first task: /implement <bead>.1
-├── See ready work: bd ready
-└── See blocked tasks: bd_blocked()
-
-For parallel agents:
-├── Agent 1 (backend): claim <bead>.1
-├── Agent 2 (frontend): wait for .1, then claim .3
-└── Agent 3 (qa): wait for .2 and .3, then claim .5
-```
-
-## When to Create Child Beads
-
-| Scenario                        | Create Beads?                        |
-| ------------------------------- | ------------------------------------ |
-| Simple task, single domain      | No - use plan.md checklist           |
-| 2-3 tasks, same domain          | No - use plan.md checklist           |
-| 3+ tasks, multiple domains      | Yes - enables parallel agents        |
-| Tasks with complex dependencies | Yes - beads tracks dependencies      |
-| Long-running work (days)        | Yes - better progress tracking       |
-| Work that may span sessions     | Yes - beads persists across sessions |
-
-## Integration with Agent Workflow
-
-After plan creates child beads:
-
-```typescript
-// Any agent can check ready work
-bd_init({ team: "project", role: "backend" });
-bd_ready(); // Shows <parent>.1 as ready
-
-// Agent claims and works
-bd_claim(); // Gets <parent>.1
-// ... do the work ...
-bd_done({ id: "<parent>.1", msg: "Completed setup" });
-
-// Now <parent>.2, .3, .4 become ready (unblocked)
-// Multiple agents can claim them in parallel
-```
-
-## Examples
-
-```bash
-/plan bd-auth01                    # Plan without creating beads
-/plan bd-auth01 --create-beads     # Plan and create child beads
-/plan bd-auth01 --parallel         # Focus on parallel execution
-/plan bd-auth01 --create-beads --parallel  # Full decomposition
+Next: /implement bd-[x].1
 ```

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

@@ -212,8 +212,10 @@ bd_msg({
   importance: "normal",
   global: true,
 });
+```
 
-bd_sync({ reason: "PR created for $ARGUMENTS" });
+```typescript
+bd_sync({ reason: "Sync PR creation" });
 ```
 
 ## Output