opencodekit 0.16.4 → 0.16.6

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

@@ -1,26 +1,30 @@
 ---
-description: Create a specification for a bead using templates
-argument-hint: "<bead-id> [--prd] [--proposal]"
+description: Create a bead with specification from a description
+argument-hint: "<description> [--type epic|feature|task|bug]"
 agent: build
 ---
 
 # Create: $ARGUMENTS
 
-Create structured artifacts for a bead using templates. This is the first step before planning.
+Create a bead and its artifacts from a description. Auto-classifies bead type based on keywords.
+
+> **Lifecycle context:** Ideation → Design → **Specification** → Task Conversion → Planning → Implementation → Verification
+>
+> **Workflow:** `/create` → `/start <id>` → `/ship <id>` → `/verify <id>`
 
 ## Parse Arguments
 
-| Argument     | Default  | Description                          |
-| ------------ | -------- | ------------------------------------ |
-| `<bead-id>`  | required | The bead to create artifacts for     |
-| `--prd`      | false    | Use PRD template (combined format)   |
-| `--proposal` | false    | Create proposal.md first (for epics) |
+| Argument        | Default       | Description                                |
+| --------------- | ------------- | ------------------------------------------ |
+| `<description>` | required      | What you want to build/fix (quoted string) |
+| `--type`        | auto-detected | Override type: epic, feature, task, bug    |
 
 ## Load Skills
 
 ```typescript
+skill({ name: "development-lifecycle" }); // Phase guidance
 skill({ name: "beads" });
-skill({ name: "brainstorming" });
+skill({ name: "prd" }); // PRD template guidance
 skill({ name: "memory-system" });
 ```
 
@@ -30,7 +34,7 @@ Search for similar specs and patterns before creating:
 
 ```typescript
 // Find similar past specs
-memory_search({ query: "[bead title/description]", limit: 3 });
+memory_search({ query: "[description keywords]", limit: 3 });
 
 // Find related patterns and conventions
 memory_search({ query: "[domain keywords] spec requirements", limit: 3 });
@@ -42,60 +46,100 @@ Review findings for:
 - Patterns and conventions already established
 - Gotchas to avoid in this domain
 
-## Load Bead Context
+---
+
+## Phase 1: Classify Bead Type
 
-```bash
-br show $ARGUMENTS
+**Auto-classification based on description keywords:**
+
+| Keywords in Description                                         | Classified As |
+| --------------------------------------------------------------- | ------------- |
+| "redesign", "overhaul", "migrate", "new system", "platform"     | `epic`        |
+| "add", "implement", "create", "build", "new feature", "support" | `feature`     |
+| "fix", "bug", "broken", "error", "crash", "issue", "failing"    | `bug`         |
+| Default (none of above)                                         | `task`        |
+
+```typescript
+function classifyBeadType(description: string): "epic" | "feature" | "task" | "bug" {
+  const desc = description.toLowerCase();
+
+  // Epic indicators (large scope)
+  if (/redesign|overhaul|migrate|new system|platform|architecture/.test(desc)) {
+    return "epic";
+  }
+
+  // Bug indicators
+  if (/fix|bug|broken|error|crash|issue|failing|doesn't work|not working/.test(desc)) {
+    return "bug";
+  }
+
+  // Feature indicators
+  if (/add|implement|create|build|new feature|support|enable|integrate/.test(desc)) {
+    return "feature";
+  }
+
+  // Default to task
+  return "task";
+}
 ```
 
-Check what artifacts already exist:
+**User can override with `--type` flag.**
+
+---
+
+## Phase 2: Create Bead
 
 ```bash
-ls .beads/artifacts/$ARGUMENTS/ 2>/dev/null || echo "No artifacts yet"
+# Create the bead with classified type
+BEAD_ID=$(br create "$DESCRIPTION" --type $BEAD_TYPE --json | jq -r '.id')
+echo "Created bead: $BEAD_ID"
 ```
 
 ---
 
-## Phase 1: Setup Artifact Directory
+## Phase 3: Setup Artifact Directory
 
 ```bash
-BEAD_DIR=".beads/artifacts/$ARGUMENTS"
+BEAD_DIR=".beads/artifacts/$BEAD_ID"
 mkdir -p "$BEAD_DIR"
 ```
 
 ---
 
-## Phase 2: Choose Template
-
-Based on flags and bead type:
+## Phase 4: Choose Artifacts (Auto-Detection)
 
-| Flag         | Template Used | Best For                      |
-| ------------ | ------------- | ----------------------------- |
-| `--prd`      | `prd.md`      | Quick features, smaller scope |
-| `--proposal` | `proposal.md` | Epics, major changes          |
-| (default)    | `spec.md`     | Standard task specifications  |
+**Artifact selection based on bead type:**
 
-### Copy Template
+| Bead Type | Auto-Created             | Rationale                            |
+| --------- | ------------------------ | ------------------------------------ |
+| `epic`    | `proposal.md` + `prd.md` | Major work needs high-level proposal |
+| `feature` | `proposal.md` + `prd.md` | Scoped work benefits from proposal   |
+| `task`    | `prd.md`                 | Tactical work, skip proposal         |
+| `bug`     | `prd.md`                 | Clear problem, skip proposal         |
 
 ```bash
-# Default: Copy spec template
-cp .opencode/memory/_templates/spec.md "$BEAD_DIR/spec.md"
+# Determine if proposal is needed
+NEEDS_PROPOSAL=false
+if [ "$BEAD_TYPE" = "epic" ] || [ "$BEAD_TYPE" = "feature" ]; then
+  NEEDS_PROPOSAL=true
+fi
 
-# If --prd flag
+# Always create PRD
 cp .opencode/memory/_templates/prd.md "$BEAD_DIR/prd.md"
 
-# If --proposal flag (for epics)
-cp .opencode/memory/_templates/proposal.md "$BEAD_DIR/proposal.md"
-cp .opencode/memory/_templates/spec.md "$BEAD_DIR/spec.md"
+# Create proposal if needed (epic/feature)
+if [ "$NEEDS_PROPOSAL" = "true" ]; then
+  cp .opencode/memory/_templates/proposal.md "$BEAD_DIR/proposal.md"
+fi
 ```
 
 ---
 
-## Phase 3: Gather Context for Spec
+## Phase 5: Gather Context for Spec
 
-### Ask Clarifying Questions
+### Ask Clarifying Questions (if needed)
 
-Before writing the spec, understand what needs to be built:
+If description is vague, ask for more details:
 
 ```typescript
 question({
@@ -107,8 +151,7 @@ question({
     },
     {
       header: "Users",
-      question:
-        "Who will use this? (developers, end users, API consumers, etc.)",
+      question: "Who will use this? (developers, end users, API consumers, etc.)",
       options: [
         { label: "Developers", description: "Internal tooling or API" },
         { label: "End users", description: "Customer-facing feature" },
@@ -132,7 +175,7 @@ If user provides enough context, delegate to explore agent:
 Task({
   subagent_type: "explore",
   description: "Find similar patterns",
-  prompt: `Find patterns in codebase related to: [bead title/description]
+  prompt: `Find patterns in codebase related to: [description]
     - Similar implementations
     - Existing conventions
     - Test patterns used
@@ -142,58 +185,22 @@ Task({
 
 ---
 
-## Phase 4: Fill In Template
-
-### For spec.md (default)
-
-Fill in the template with WHEN/THEN scenarios:
-
-```markdown
-# Specification
-
-**Bead:** $ARGUMENTS
-**Proposal:** N/A
-**Date:** [today]
-
-## Requirements
-
-### [Requirement from user input]
-
-Brief description of what must be true.
-
-#### Scenarios
-
-**WHEN** [user/system does action]
-**THEN** [expected outcome]
-
-**WHEN** [edge case condition]
-**THEN** [expected behavior]
-
-## Non-Functional Requirements
-
-- **Performance:** [from constraints]
-- **Security:** [from constraints]
-- **Compatibility:** [from constraints]
-
-## Out of Scope
-
-- [Explicitly excluded capability]
-```
+## Phase 6: Fill In Template
 
-### For prd.md (--prd flag)
+### For prd.md
 
 Fill in the PRD template with goal, scope, and tasks:
 
 ```markdown
 # Beads PRD Template
 
-**Bead:** $ARGUMENTS
+**Bead:** $BEAD_ID
 **Created:** [today]
 **Status:** Draft
 
 ## Goal
 
-[From user input - what are we building and why]
+[From description and clarifying questions]
 
 ## Scope
 
@@ -221,34 +228,76 @@ Fill in the PRD template with goal, scope, and tasks:
 - [Command or check]
 ```
 
+### For proposal.md (epic/feature)
+
+Fill in high-level proposal first:
+
+```markdown
+# Proposal: [Title]
+
+**Bead:** $BEAD_ID
+**Date:** [today]
+
+## Problem Statement
+
+[What problem are we solving?]
+
+## Proposed Solution
+
+[High-level approach]
+
+## Scope
+
+### In-Scope
+
+- [Major deliverable]
+
+### Out-of-Scope
+
+- [Explicitly excluded]
+
+## Timeline
+
+| Phase   | Duration | Deliverables |
+| ------- | -------- | ------------ |
+| Phase 1 | X weeks  | ...          |
+
+## Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+| ---- | ---------- | ------ | ---------- |
+| ...  | ...        | ...    | ...        |
+```
+
 ---
 
-## Phase 5: Validate Spec
+## Phase 7: Validate PRD
 
-Before saving, validate the spec:
+Before saving, validate the PRD:
 
-- [ ] All requirements have WHEN/THEN scenarios?
-- [ ] Scenarios are testable (not vague)?
+- [ ] Goal is clear and measurable?
+- [ ] Success criteria have verification commands?
+- [ ] Tasks have end state descriptions (not steps)?
 - [ ] Out of scope is defined?
-- [ ] Non-functional requirements addressed?
+- [ ] Dependencies identified (if any)?
 
 If validation fails, ask user for missing information.
 
 ---
 
-## Phase 6: Save and Report
+## Phase 8: Save and Report
 
 Save the filled template to the bead artifacts folder.
 
 ```bash
-# Verify file was created
-cat "$BEAD_DIR/spec.md"
+# Verify files were created
+ls -la "$BEAD_DIR/"
 ```
 
 Update bead with note:
 
 ```bash
-bd note $ARGUMENTS "Created spec.md with [N] requirements"
+br comments add $BEAD_ID "Created prd.md with [N] tasks defined"
 ```
 
 ## Record Learning (If Significant)
@@ -261,7 +310,7 @@ observation({
   title: "[Domain] spec pattern for [type of feature]",
   narrative: "When creating specs for [this type], include...",
   concepts: "[domain keywords]",
-  bead_id: "$ARGUMENTS",
+  bead_id: "$BEAD_ID",
   confidence: "medium",
 });
 ```
@@ -271,18 +320,21 @@ observation({
 ## Output
 
 ```
-Created: $ARGUMENTS
+Created: $BEAD_ID
 ━━━━━━━━━━━━━━━━━━━
 
+Description: [original description]
+Type: [classified type] (auto-detected | --type override)
+
 Artifacts:
-├── .beads/artifacts/$ARGUMENTS/spec.md [NEW]
-└── .beads/artifacts/$ARGUMENTS/proposal.md [if --proposal]
+├── .beads/artifacts/$BEAD_ID/prd.md [NEW]
+└── .beads/artifacts/$BEAD_ID/proposal.md [if epic/feature]
 
-Requirements: [N] defined
-Scenarios: [N] WHEN/THEN pairs
+Tasks: [N] defined
+Success Criteria: [N] with verification
 
-Next: /research $ARGUMENTS (optional)
-      /plan $ARGUMENTS
+Next: /plan $BEAD_ID (convert PRD to implementation plan)
+      /start $BEAD_ID (if simple, skip planning)
 ```
 
 ---
@@ -290,22 +342,28 @@ Next: /research $ARGUMENTS (optional)
 ## Examples
 
 ```bash
-# Create standard spec
-/create bd-feat-auth
+# Auto-classified as 'feature' (creates proposal + prd)
+/create "Add user authentication with OAuth"
+
+# Auto-classified as 'bug' (creates prd only)
+/create "Fix login page not loading on mobile"
+
+# Auto-classified as 'epic' (creates proposal + prd)
+/create "Redesign the entire dashboard UI"
 
-# Create PRD (combined format)
-/create bd-feat-auth --prd
+# Auto-classified as 'task' (creates prd only)
+/create "Update dependencies to latest versions"
 
-# Create proposal first (for epics)
-/create bd-epic-redesign --proposal
+# Override type explicitly
+/create "Refactor auth module" --type feature
 ```
 
 ---
 
 ## Related Commands
 
-| Need               | Command                |
-| ------------------ | ---------------------- |
-| Research first     | `/research $ARGUMENTS` |
-| Plan after spec    | `/plan $ARGUMENTS`     |
-| Create bead itself | `br create "Title"`    |
+| Need            | Command              |
+| --------------- | -------------------- |
+| Research first  | `/research $BEAD_ID` |
+| Plan after spec | `/plan $BEAD_ID`     |
+| Start working   | `/start $BEAD_ID`    |

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

@@ -7,10 +7,14 @@ subtask: true
 
 # Design: $ARGUMENTS
 
+> **Lifecycle context:** Ideation → **Design** → Specification → Task Conversion → Planning → Implementation → Verification
+
 ## Load Beads Skill
 
 ```typescript
+skill({ name: "development-lifecycle" }); // Phase guidance
 skill({ name: "beads" });
+skill({ name: "frontend-design" }); // Design system guidance
 skill({ name: "memory-system" });
 ```
 
@@ -74,7 +78,7 @@ read({ filePath: "src/styles/globals.css" });
 
 ## Phase 2: Aesthetic Direction (DECISION GATE)
 
-skill({ name: "frontend-design" })
+> **frontend-design skill already loaded above** - provides detailed design system guidance
 
 **BEFORE any design work, you MUST state:**
 

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

@@ -76,16 +76,18 @@ If a swarm is active for this task, note its state for recovery:
 const teamName = "$ARGUMENTS-swarm";
 
 // Check if swarm is active
-const status = await swarm_monitor({
-  operation: "status",
+const status = await swarm({
+  operation: "monitor",
+  action: "status",
   team_name: teamName,
 });
 
 const stats = JSON.parse(status);
 if (stats.summary?.total_workers > 0) {
   // Render current state for handoff
-  const ui = await swarm_monitor({
-    operation: "render_block",
+  const ui = await swarm({
+    operation: "monitor",
+    action: "render_block",
     team_name: teamName,
   });
   console.log(`✓ Swarm active (${stats.summary.total_workers} workers)`);

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

@@ -203,7 +203,7 @@ Populate from Phase 2 detection:
 If user said yes to beads:
 
 ```bash
-bd init  # or equivalent initialization
+br init  # Initialize beads_rust task tracking
 ```
 
 Create `.beads/` directory structure for task tracking.

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

@@ -8,6 +8,8 @@ agent: plan
 
 You're creating an implementation plan with proper Epic → Task → Subtask hierarchy and subagent research.
 
+> **Lifecycle context:** Ideation → Design → Specification → Task Conversion → **Planning** → Implementation → Verification
+
 ## Parse Arguments
 
 | Argument         | Default  | Description                               |
@@ -19,6 +21,7 @@ You're creating an implementation plan with proper Epic → Task → Subtask hie
 ## Load Skills & Context
 
 ```typescript
+skill({ name: "development-lifecycle" }); // Phase guidance
 skill({ name: "beads" });
 skill({ name: "deep-research" });
 skill({ name: "executing-plans" });
@@ -34,11 +37,11 @@ br show $ARGUMENTS
 Check for existing artifacts:
 
 ```bash
-cat .beads/artifacts/$ARGUMENTS/spec.md 2>/dev/null || echo "No spec found"
+cat .beads/artifacts/$ARGUMENTS/prd.md 2>/dev/null || echo "No PRD found"
 cat .beads/artifacts/$ARGUMENTS/research.md 2>/dev/null || echo "No research found"
 ```
 
-**If spec.md missing:** "Run `/create $ARGUMENTS` first to create a specification."
+**If prd.md missing:** "Create a PRD first using `/create \"description\"` command."
 
 **If complexity > M and no research:** "Consider `/research $ARGUMENTS` first for better planning."
 
@@ -58,11 +61,11 @@ cp .opencode/memory/_templates/design.md "$BEAD_DIR/design.md"
 cp .opencode/memory/_templates/tasks.md "$BEAD_DIR/tasks.md"
 ```
 
-| Template    | Purpose                        | Phase Used |
-| ----------- | ------------------------------ | ---------- |
-| `spec.md`   | WHEN/THEN behavioral scenarios | Input      |
-| `design.md` | Architecture decision records  | Phase 3    |
-| `tasks.md`  | Numbered implementation steps  | Phase 6    |
+| Template    | Purpose                       | Phase Used |
+| ----------- | ----------------------------- | ---------- |
+| `prd.md`    | Goal, scope, success criteria | Input      |
+| `design.md` | Architecture decision records | Phase 3    |
+| `tasks.md`  | Numbered implementation steps | Phase 6    |
 
 ## Check Memory First (Semantic Search)
 
@@ -288,41 +291,41 @@ With user approval or `--create-beads` flag:
 PARENT=$ARGUMENTS
 
 # Task 1 (no blockers - starts immediately)
-br create "[Task 1 title]" -t task -p 2
+br create "[Task 1 title]" --type task --priority 2
 # Capture: bd-xxx1
 
 # Link to parent
 br dep add bd-xxx1 $PARENT
 
 # Task 2 (blocked by Task 1)
-br create "[Task 2 title]" -t task -p 2
+br create "[Task 2 title]" --type task --priority 2
 # Capture: bd-xxx2
 
 br dep add bd-xxx2 $PARENT
-br dep add bd-xxx2 bd-xxx1 --type blocks
+br dep add bd-xxx2 bd-xxx1  # bd-xxx2 blocked by bd-xxx1
 
 # Task 3 (blocked by Task 2)
-br create "[Task 3 title]" -t task -p 2
+br create "[Task 3 title]" --type task --priority 2
 # Capture: bd-xxx3
 
 br dep add bd-xxx3 $PARENT
-br dep add bd-xxx3 bd-xxx2 --type blocks
+br dep add bd-xxx3 bd-xxx2  # bd-xxx3 blocked by bd-xxx2
 ```
 
 ### Create Subtasks (for complex tasks)
 
 ```bash
 # For Task 2, create subtasks:
-br create "[Subtask 2.1 title]" -t subtask -p 2
+br create "[Subtask 2.1 title]" --type subtask --priority 2
 # Capture: bd-xxx2.1
 
 br dep add bd-xxx2.1 bd-xxx2
 
-br create "[Subtask 2.2 title]" -t subtask -p 2
+br create "[Subtask 2.2 title]" --type subtask --priority 2
 # Capture: bd-xxx2.2
 
 br dep add bd-xxx2.2 bd-xxx2
-br dep add bd-xxx2.2 bd-xxx2.1 --type blocks  # Sequential dependency
+br dep add bd-xxx2.2 bd-xxx2.1  # Sequential dependency
 ```
 
 ### Verify Hierarchy
@@ -422,7 +425,7 @@ $ARGUMENTS (Epic/Task)
 
 ## Final Verification
 
-- [ ] All acceptance criteria from spec.md met
+- [ ] All acceptance criteria from prd.md met
 - [ ] Full test suite: `npm test`
 - [ ] Type check: `npm run typecheck`
 - [ ] Lint: `npm run lint`
@@ -533,13 +536,13 @@ Next: /start bd-xxx1
 
 ## Subagent Delegation Summary
 
-| Phase              | Subagent   | Purpose                              |
-| ------------------ | ---------- | ------------------------------------ |
-| Research           | `@explore` | Find codebase patterns               |
-| Research           | `@scout`   | Find best practices                  |
-| Design options     | None       | Planner creates                      |
-| Hierarchy creation | None       | Planner uses `bd` CLI                |
-| Implementation     | `@build`   | Delegated via `/start`, `/implement` |
+| Phase              | Subagent   | Purpose                         |
+| ------------------ | ---------- | ------------------------------- |
+| Research           | `@explore` | Find codebase patterns          |
+| Research           | `@scout`   | Find best practices             |
+| Design options     | None       | Planner creates                 |
+| Hierarchy creation | None       | Planner uses `br` CLI           |
+| Implementation     | `@build`   | Delegated via `/start`, `/ship` |
 
 **Key Rule:** Planner is read-only. Creates structure and artifacts. Build agent executes.
 

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

@@ -9,6 +9,10 @@ subtask: true
 
 You're gathering information before implementation. Find answers, document findings, stop when done.
 
+> **Lifecycle context:** Ideation → Design → **Research (optional)** → Specification → Planning → Implementation → Verification
+>
+> Research can happen at any phase when you need external information or codebase understanding.
+
 ## Depth Levels
 
 - `--quick` (~10 tool calls): Single question, API syntax lookup
@@ -18,6 +22,8 @@ You're gathering information before implementation. Find answers, document findi
 ## Load Skills Based on Depth
 
 ```typescript
+skill({ name: "development-lifecycle" }); // Phase guidance
+
 // For --thorough mode, load the deep-research skill
 if (thorough) {
   skill({ name: "deep-research" });
@@ -42,8 +48,9 @@ skill({ name: "memory-system" });
 
 ```typescript
 // Analyze if research benefits from parallelization
-const analysis = await swarm_plan({
-  operation: "analyze",
+const analysis = await swarm({
+  operation: "plan",
+  action: "analyze",
   task: "Research " + $ARGUMENTS,
   files: "<detected files or leave empty for external research>",
 });
@@ -86,7 +93,7 @@ For comprehensive research across multiple domains, use parallel agents:
 // Option A: Simple parallel (2-3 agents)
 // Launch both in parallel
 task({ subagent_type: "explore", prompt: "LSP analysis of..." });
-context7_resolve_library_id({ libraryName: "<lib>" });
+context7({ operation: "resolve", libraryName: "<lib>" });
 grepsearch({ query: "<pattern>", language: "TypeScript" });
 
 // Option B: Swarm mode for complex multi-domain research
@@ -115,7 +122,7 @@ Return: Documentation, code examples, best practices`,
 ### Load Bead Details
 
 !`br show $ARGUMENTS`
-!`cat .beads/artifacts/$ARGUMENTS/spec.md`
+!`cat .beads/artifacts/$ARGUMENTS/prd.md`
 
 Extract questions that need answering from spec.
 
@@ -182,8 +189,8 @@ Return file:line references.`,
 ### External Docs
 
 ```typescript
-context7_resolve_library_id({ libraryName: "<lib>", query: "<question>" });
-context7_query_docs({ libraryId: "<id>", query: "<specific question>" });
+context7({ operation: "resolve", libraryName: "<lib>", query: "<question>" });
+context7({ operation: "query", libraryId: "<id>", topic: "<specific question>" });
 ```
 
 ### Source Code (When Docs Insufficient)