opencodekit 0.16.4 → 0.16.6

package/dist/template/.opencode/skill/prd-task/references/prd-schema.json

@@ -1,28 +1,124 @@
 {
-	"beadId": "bd-abc123",
-	"prdName": "user-authentication",
-	"tasks": [
-		{
-			"id": "functional-1",
-			"category": "functional",
-			"description": "User can register with email and password",
-			"steps": [
-				"POST /api/auth/register with valid email/password",
-				"Verify 201 response with user object",
-				"Verify password is not in response",
-				"Attempt duplicate email, verify 409 response",
-				"Attempt invalid email, verify 400 response"
-			],
-			"passes": false
+	"$schema": "http://json-schema.org/draft-07/schema#",
+	"title": "PRD Task Schema",
+	"description": "Executable task list converted from PRD markdown",
+	"type": "object",
+	"required": ["beadId", "tasks"],
+	"properties": {
+		"beadId": {
+			"type": "string",
+			"description": "Bead identifier (e.g., bd-abc123)"
+		},
+		"prdName": {
+			"type": "string",
+			"description": "Optional slug for the PRD"
+		},
+		"tasks": {
+			"type": "array",
+			"items": {
+				"type": "object",
+				"required": ["id", "category", "description", "steps", "passes"],
+				"properties": {
+					"id": {
+						"type": "string",
+						"description": "Task identifier (e.g., functional-1, api-2)"
+					},
+					"category": {
+						"type": "string",
+						"description": "Task category (e.g., functional, api, db, ui)"
+					},
+					"description": {
+						"type": "string",
+						"description": "One sentence describing the end state"
+					},
+					"steps": {
+						"type": "array",
+						"items": { "type": "string" },
+						"description": "Verification steps that prove the task is complete"
+					},
+					"passes": {
+						"type": "boolean",
+						"default": false,
+						"description": "Whether all verification steps pass"
+					},
+					"metadata": {
+						"type": "object",
+						"description": "Task dependency and execution metadata",
+						"properties": {
+							"depends_on": {
+								"type": "array",
+								"items": { "type": "string" },
+								"description": "Task IDs that must complete first"
+							},
+							"parallel": {
+								"type": "boolean",
+								"default": true,
+								"description": "Can run concurrently with other parallel tasks"
+							},
+							"conflicts_with": {
+								"type": "array",
+								"items": { "type": "string" },
+								"description": "Task IDs that modify same files (cannot parallelize)"
+							},
+							"files": {
+								"type": "array",
+								"items": { "type": "string" },
+								"description": "Files this task will modify"
+							}
+						}
+					}
+				}
+			}
+		},
+		"context": {
+			"type": "object",
+			"description": "Technical context from the PRD",
+			"properties": {
+				"patterns": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Existing codebase patterns to follow"
+				},
+				"keyFiles": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Key files to reference"
+				},
+				"nonGoals": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Explicitly out of scope items"
+				}
+			}
+		},
+		"beadMetadata": {
+			"type": "object",
+			"description": "Bead-level metadata from PRD",
+			"properties": {
+				"depends_on": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Bead IDs that must complete before this one"
+				},
+				"parallel": {
+					"type": "boolean",
+					"description": "Can run concurrently with other parallel beads"
+				},
+				"conflicts_with": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Bead IDs that modify same files"
+				},
+				"blocks": {
+					"type": "array",
+					"items": { "type": "string" },
+					"description": "Bead IDs waiting on this one"
+				},
+				"estimated_hours": {
+					"type": "number",
+					"description": "Time estimate for planning"
+				}
+			}
 		}
-	],
-	"context": {
-		"patterns": [
-			"API routes: src/routes/items.ts",
-			"Validation: src/lib/validate.ts",
-			"DB queries: src/db/queries/"
-		],
-		"keyFiles": ["src/db/schema.ts", "src/routes/index.ts"],
-		"nonGoals": ["OAuth/social login", "Password reset", "Email verification"]
 	}
 }

package/dist/template/.opencode/skill/swarm-coordination/SKILL.md

@@ -24,20 +24,23 @@ Coordinate multiple agents working on independent tasks in parallel using Kimi K
 
 **Key Tools**:
 
-| Tool             | Purpose                                | When to Use                  |
-| ---------------- | -------------------------------------- | ---------------------------- |
-| `swarm-plan`     | Task classification & dependency graph | Before spawning workers      |
-| `swarm-delegate` | Create delegation packets              | Assigning work to workers    |
-| `swarm-monitor`  | Progress tracking + todo persistence   | During swarm execution       |
-| `beads-sync`     | Sync Beads ↔ OpenCode todos            | Session start, cross-session |
+| Tool    | Purpose                    | When to Use          |
+| ------- | -------------------------- | -------------------- |
+| `swarm` | Unified swarm coordination | All swarm operations |
+
+**swarm operations:**
+
+- `plan`: Task classification & dependency graph (before spawning workers)
+- `delegate`: Create delegation packets (assigning work to workers)
+- `monitor`: Progress tracking + TUI visualization (during swarm execution)
+- `sync`: Sync Beads ↔ OpenCode todos (session start, cross-session)
 
 **Key Distinction**:
 
 - **Swarm**: Parallel execution of independent tasks with dynamic allocation
 - **Beads**: Task tracking and dependency management across sessions
 - **Task tool**: Spawning individual subagents for research/execution
-- **swarm-plan tool**: Task classification, dependency graphs, anti-serial-collapse
-- **swarm-monitor tool**: Progress tracking, TUI visualization, todo persistence
+- **swarm tool**: Unified operations for planning, monitoring, delegation, and sync
 
 **When to Use Swarm Coordination**:
 
@@ -62,7 +65,7 @@ Coordinate multiple agents working on independent tasks in parallel using Kimi K
 │  - Parses plan into tasks                                        │
 │  - Creates delegation packets                                    │
 │  - Spawns worker agents via Task tool                            │
-│  - Monitors progress via swarm-monitor                           │
+│  - Monitors progress via swarm tool                             │
 │  - Synthesizes final results                                     │
 └─────────────────────────────────────────────────────────────────┘
          │                    │                    │
@@ -93,7 +96,8 @@ Analyze the user's actual task to determine optimal swarm strategy:
 
 ```typescript
 // 1. Classify the task and build dependency graph
-const analysis = await swarm_plan({
+const analysis = await swarm({
+  operation: "plan",
   operation: "analyze",
   task: "<user's request from input>",
   files: "<detected files from glob/grep>",
@@ -110,7 +114,8 @@ const analysis = await swarm_plan({
 const plan = JSON.parse(analysis);
 
 // 2. Check for serial collapse
-const check = await swarm_plan({
+const check = await swarm({
+  operation: "plan",
   operation: "check",
   task: "<user's request>",
   files: String(plan.file_count),
@@ -135,10 +140,11 @@ Make Beads tasks visible to subagents:
 
 ```typescript
 // Push Beads to OpenCode todos (subagents see via todoread)
-await beads_sync({ operation: "push", filter: "open" });
+await swarm({ operation: "sync", operation: "push", filter: "open" });
 
 // Check for existing swarm state
-const status = await swarm_monitor({
+const status = await swarm({
+  operation: "monitor",
   operation: "status",
   team_name: "plan-implementation",
 });
@@ -147,7 +153,8 @@ const stats = JSON.parse(status).summary;
 if (stats.total_workers > 0) {
   console.log(`Found existing swarm with ${stats.total_workers} workers`);
   // Render current progress
-  const ui = await swarm_monitor({
+  const ui = await swarm({
+    operation: "monitor",
     operation: "render_block",
     team_name: "plan-implementation",
   });
@@ -160,7 +167,8 @@ if (stats.total_workers > 0) {
 For each task, create a delegation packet:
 
 ```typescript
-swarm_delegate({
+swarm({
+  operation: "delegate",
   bead_id: "task-1",
   title: "Implement auth service",
   expected_outcome: "Auth service with JWT tokens, tests pass",
@@ -199,7 +207,7 @@ Requirements:
 1. Follow all MUST DO constraints
 2. Avoid all MUST NOT DO items
 3. Run acceptance checks before claiming done
-4. Report progress via swarm-monitor`,
+4. Report progress via swarm monitor`,
     });
   });
 
@@ -216,14 +224,16 @@ Monitor with beautiful block UI, progress tracking, and auto-persistence:
 let allComplete = false;
 while (!allComplete) {
   // Option A: Render beautiful TUI block
-  const ui = await swarm_monitor({
+  const ui = await swarm({
+    operation: "monitor",
     operation: "render_block",
     team_name: "plan-implementation",
   });
   console.log(ui); // Markdown block with tables, emojis, progress
 
   // Option B: Get detailed status
-  const status = await swarm_monitor({
+  const status = await swarm({
+    operation: "monitor",
     operation: "status",
     team_name: "plan-implementation",
   });
@@ -246,7 +256,8 @@ When all workers complete:
 
 ```typescript
 // 1. Get final status
-const finalStatus = await swarm_monitor({
+const finalStatus = await swarm({
+  operation: "monitor",
   operation: "status",
   team_name: "plan-implementation",
 });
@@ -255,13 +266,10 @@ const finalStatus = await swarm_monitor({
 await bash("npm run typecheck && npm run lint && npm test");
 
 // 3. Pull completed todos back to Beads
-await beads_sync({ operation: "pull" });
+await swarm({ operation: "sync", operation: "pull" });
 
 // 4. Clear swarm data
-await swarm_monitor({
-  operation: "clear",
-  team_name: "plan-implementation",
-});
+await swarm({ operation: "monitor", operation: "clear", team_name: "plan-implementation" });
 
 // 5. Close parent bead
 await bash("br close parent-task --reason 'Swarm completed all subtasks'");
@@ -269,7 +277,7 @@ await bash("br close parent-task --reason 'Swarm completed all subtasks'");
 
 ## Dependency Graph Features
 
-The `swarm-plan` tool now includes full dependency graph analysis:
+The `swarm` tool's plan operation includes full dependency graph analysis:
 
 ### Structure
 
@@ -297,7 +305,8 @@ interface TaskNode {
 ### Usage
 
 ```typescript
-const analysis = await swarm_plan({
+const analysis = await swarm({
+  operation: "plan",
   operation: "analyze",
   task: "Refactor API layer",
   files: "src/api/users.ts,src/api/posts.ts,src/api/auth.ts",
@@ -362,7 +371,8 @@ read({ filePath: ".beads/artifacts/<task-id>/delegation.md" });
 ### 2. Announce Start with Progress
 
 ```typescript
-await swarm_monitor({
+await swarm({
+  operation: "monitor",
   operation: "progress_update",
   team_name: "plan-implementation",
   worker_id: "worker-1",
@@ -381,7 +391,8 @@ Report progress every 25%:
 
 ```typescript
 // At 25%, 50%, 75% completion
-await swarm_monitor({
+await swarm({
+  operation: "monitor",
   operation: "progress_update",
   team_name: "plan-implementation",
   worker_id: "worker-1",
@@ -405,7 +416,8 @@ npm test
 
 ```typescript
 // Mark as completed
-await swarm_monitor({
+await swarm({
+  operation: "monitor",
   operation: "progress_update",
   team_name: "plan-implementation",
   worker_id: "worker-1",
@@ -424,7 +436,8 @@ Workers report failures via progress updates with error status:
 
 ```typescript
 // Worker reports error via progress update
-await swarm_monitor({
+await swarm({
+  operation: "monitor",
   operation: "progress_update",
   team_name: "plan-implementation",
   worker_id: "worker-1",
@@ -437,7 +450,7 @@ await swarm_monitor({
 
 ### Leader Response
 
-1. Check worker status via `swarm_monitor({ operation: "status" })`
+1. Check worker status via `swarm({ operation: "monitor", operation: "status" })`
 2. Review error details in progress entries
 3. Decide: fix locally or reassign to new worker
 
@@ -447,7 +460,8 @@ Workers should report blockers via progress updates:
 
 ```typescript
 // Worker reports blocker via progress update
-await swarm_monitor({
+await swarm({
+  operation: "monitor",
   operation: "progress_update",
   team_name: "plan-implementation",
   worker_id: "worker-2",
@@ -472,20 +486,20 @@ await swarm_monitor({
 
 Swarm works on top of Beads:
 
-1. **Session start**: `beads-sync push` to make tasks visible
+1. **Session start**: `swarm sync push` to make tasks visible
 2. **Leader claims parent** bead
 3. **Workers claim child** beads (via delegation packets)
-4. **Progress tracked** via `swarm-monitor progress_update`
-5. **Completion syncs** back via `beads-sync pull`
+4. **Progress tracked** via `swarm monitor progress_update`
+5. **Completion syncs** back via `swarm sync pull`
 6. **Close parent** bead with `br close`
 
 ```typescript
 // Full integration workflow
-await beads_sync({ operation: "push" }); // Make Beads visible
+await swarm({ operation: "sync", action: "push" }); // Make Beads visible
 // ... spawn swarm ...
-await swarm_monitor({ operation: "render_block", team_name: "..." }); // Monitor progress
+await swarm({ operation: "monitor", action: "render_block", team_name: "..." }); // Monitor progress
 // ... monitor completion ...
-await beads_sync({ operation: "pull" }); // Sync completed back
+await swarm({ operation: "sync", action: "pull" }); // Sync completed back
 await bash("br close parent-task --reason 'Swarm completed'");
 ```
 
@@ -493,54 +507,58 @@ await bash("br close parent-task --reason 'Swarm completed'");
 
 ```
 SWARM LAUNCH (PARL):
-  0. SETUP: beads-sync({ operation: "push" })
+  0. SETUP: swarm({ operation: "sync", action: "push" })
      → Make Beads visible to subagents
-  1. ANALYZE: swarm-plan({ operation: "analyze", task: userRequest, files: detectedFiles })
+  1. ANALYZE: swarm({ operation: "plan", action: "analyze", task: userRequest, files: detectedFiles })
      → Get classification, phases, dependency_graph
-  2. CHECK: swarm-plan({ operation: "check", ... })
+  2. CHECK: swarm({ operation: "plan", action: "check", ... })
      → Detect/prevent serial collapse
-  3. DELEGATE: swarm_delegate({ ... })
+  3. DELEGATE: swarm({ operation: "delegate", ... })
      → Create packets for each worker
   4. SPAWN: Task({ subagent_type: "general" })
      → Launch workers using parallelizable_groups order
-  5. MONITOR: swarm_monitor({ operation: "render_block" })
+  5. MONITOR: swarm({ operation: "monitor", action: "render_block" })
      → Real-time TUI progress
   6. VERIFY: npm run typecheck && npm run lint && npm test
-  7. CLOSE: beads-sync({ operation: "pull" }) && br close <bead>
+  7. CLOSE: swarm({ operation: "sync", action: "pull" }) && br close <bead>
 
 WORKER EXECUTION:
   1. Read delegation packet
-  2. Report START: swarm_monitor({ operation: "progress_update", progress: 0, status: "working" })
+  2. Report START: swarm({ operation: "monitor", action: "progress_update", progress: 0, status: "working" })
   3. Execute with constraints
-  4. Report PROGRESS (every 25%): swarm_monitor({ operation: "progress_update", progress: 25/50/75 })
+  4. Report PROGRESS (every 25%): swarm({ operation: "monitor", action: "progress_update", progress: 25/50/75 })
   5. Run acceptance checks
-  6. Report DONE: swarm_monitor({ operation: "progress_update", progress: 100, status: "completed" })
+  6. Report DONE: swarm({ operation: "monitor", action: "progress_update", progress: 100, status: "completed" })
 
 COORDINATION:
-  - Progress: .beads/swarm-progress.jsonl (via swarm-monitor)
-  - Delegation: .beads/artifacts/<id>/delegation.md (via swarm-delegate)
-  - Analysis: swarm-plan tool for classification + dependency graphs
+  - Progress: .beads/swarm-progress.jsonl (via swarm monitor)
+  - Delegation: .beads/artifacts/<id>/delegation.md (via swarm delegate)
+  - Analysis: swarm tool for classification + dependency graphs
 
 RECOVERY:
-  - Check: swarm_monitor({ operation: "status" })
-  - Use shared task lists: beads_sync({ operation: "create_shared" })
+  - Check: swarm({ operation: "monitor", action: "status" })
+  - Use shared task lists: swarm({ operation: "sync", action: "create_shared" })
   - Continue with remaining workers
 
 SHUTDOWN:
-  - All workers done → swarm_monitor({ operation: "clear" })
+  - All workers done → swarm({ operation: "monitor", action: "clear" })
   - Run full test suite
-  - beads-sync({ operation: "pull" })
+  - swarm({ operation: "sync", action: "pull" })
   - Close parent bead
 ```
 
 ## Tools Reference
 
-| Tool               | Purpose                           | Key Operations                                                                |
-| ------------------ | --------------------------------- | ----------------------------------------------------------------------------- |
-| **swarm-plan**     | Task analysis + dependency DAG    | `analyze`, `classify`, `check`, `allocate`                                    |
-| **swarm-delegate** | Create delegation packets         | `swarm_delegate({ ... })`                                                     |
-| **swarm-monitor**  | Progress tracking + visualization | `progress_update`, `render_block`, `status`, `clear`                          |
-| **beads-sync**     | Beads ↔ OpenCode todos            | `push`, `pull`, `create_shared`, `get_shared`, `update_shared`, `list_shared` |
+| Tool      | Purpose                    | Key Operations                        |
+| --------- | -------------------------- | ------------------------------------- |
+| **swarm** | Unified swarm coordination | `plan`, `monitor`, `delegate`, `sync` |
+
+**swarm operations:**
+
+- `plan`: Task analysis + dependency DAG (actions: analyze, classify, check, allocate)
+- `delegate`: Create delegation packets
+- `monitor`: Progress tracking + visualization (actions: progress_update, render_block, status, clear)
+- `sync`: Beads ↔ OpenCode todos (actions: push, pull, create_shared, get_shared, update_shared, list_shared)
 
 ## Tmux Integration (Visual Swarm Monitoring)
 
@@ -681,7 +699,7 @@ This renders the beautiful TUI block and shows:
 
 1. **Leader spawns, workers execute** - Clear role separation
 2. **Delegation packets are contracts** - Workers follow them strictly
-3. **Progress tracking for coordination** - All status via swarm-monitor progress updates
+3. **Progress tracking for coordination** - All status via swarm monitor progress updates
 4. **Non-overlapping assignments** - Ensure workers edit different files
 5. **Acceptance checks required** - Workers verify before reporting done
 6. **Persist periodically** - Enable cross-session recovery

package/dist/template/.opencode/skill/tool-priority/SKILL.md

@@ -1,4 +1,5 @@
 ---
+name: tool-priority
 description: Use when choosing between tools or need tool reference - covers LSP, search, swarm, memory, and research tools with correct syntax
 ---
 
@@ -13,8 +14,8 @@ description: Use when choosing between tools or need tool reference - covers LSP
 3. **glob** - File discovery by name pattern
 4. **skill** - Load skills for specialized knowledge
 5. **task** - Parallel subagent execution
-6. **Swarm tools** - beads-sync, swarm-monitor, swarm-plan, swarm-delegate
-7. **Memory tools** - memory-search, memory-read, memory-update
+6. **Swarm tool** - swarm (plan, monitor, delegate, sync operations)
+7. **Memory tools** - memory-search, memory-read, memory-update, memory-admin
 8. **Research tools** - context7, websearch, codesearch, grepsearch
 9. **read/edit/write** - File operations (always read before edit)
 
@@ -94,12 +95,16 @@ Task({
 
 ### Swarm Coordination Tools
 
-| Tool               | Purpose                   | Key Operations                                       |
-| ------------------ | ------------------------- | ---------------------------------------------------- |
-| **beads-sync**     | Beads ↔ OpenCode sync     | `push`, `pull`, `create_shared`, `update_shared`     |
-| **swarm-monitor**  | Progress tracking         | `progress_update`, `render_block`, `status`, `clear` |
-| **swarm-plan**     | Task analysis             | `analyze`, `classify`, `check`, `allocate`           |
-| **swarm-delegate** | Create delegation packets | `swarm_delegate({ ... })`                            |
+| Tool      | Purpose                    | Key Operations                        |
+| --------- | -------------------------- | ------------------------------------- |
+| **swarm** | Unified swarm coordination | `plan`, `monitor`, `delegate`, `sync` |
+
+**swarm operations:**
+
+- `plan`: Task analysis (actions: analyze, classify, check, allocate)
+- `monitor`: Progress tracking (actions: progress_update, render_block, status, clear)
+- `delegate`: Create delegation packets for workers
+- `sync`: Beads ↔ OpenCode sync (actions: push, pull, create_shared, update_shared)
 
 ### Memory Tools
 
@@ -112,15 +117,19 @@ Task({
 
 ### Research Tools
 
-| Tool                            | Purpose                      | When to Use             |
-| ------------------------------- | ---------------------------- | ----------------------- |
-| **context7_resolve_library_id** | Resolve library name to ID   | Before querying docs    |
-| **context7_query_docs**         | Query official documentation | API reference, examples |
-| **websearch**                   | Recent info, troubleshooting | Docs not in Context7    |
-| **codesearch**                  | Real implementation patterns | GitHub code examples    |
-| **grepsearch**                  | Cross-repo patterns          | grep.app search         |
-| **webfetch**                    | Specific URL content         | User-provided links     |
-| **review (Task)**               | Second opinion               | Validate approach       |
+| Tool              | Purpose                      | When to Use             |
+| ----------------- | ---------------------------- | ----------------------- |
+| **context7**      | Library documentation lookup | API reference, examples |
+| **websearch**     | Recent info, troubleshooting | Docs not in Context7    |
+| **codesearch**    | Real implementation patterns | GitHub code examples    |
+| **grepsearch**    | Cross-repo patterns          | grep.app search         |
+| **webfetch**      | Specific URL content         | User-provided links     |
+| **review (Task)** | Second opinion               | Validate approach       |
+
+**context7 operations:**
+
+- `resolve`: Find library ID from name (e.g., "react" → "/reactjs/react.dev")
+- `query`: Get documentation for a library topic
 
 ## Workflow Pattern
 
@@ -244,14 +253,14 @@ SEARCHING:
 
 PARALLEL WORK:
   Task({ subagent_type: "explore", ... })       → Parallel subagent
-  beads_sync({ operation: "push" })             → Sync to todos
-  swarm_monitor({ operation: "progress_update" }) → Track progress
+  swarm({ operation: "sync", action: "push" }) → Sync to todos
+  swarm({ operation: "monitor", action: "progress_update" }) → Track progress
 
 RESEARCH:
-  context7_resolve_library_id({ libraryName: "..." })
-  context7_query_docs({ libraryId: "...", topic: "..." })
+  context7({ operation: "resolve", libraryName: "..." })
+  context7({ operation: "query", libraryId: "...", topic: "..." })
   websearch({ query: "..." })
-Task({ subagent_type: "review", description: "Second opinion", prompt: "Review the approach." })
+  Task({ subagent_type: "review", description: "Second opinion", prompt: "Review the approach." })
 
 MEMORY:
   memory_search({ query: "..." })               → Find past learnings