opencodekit 0.16.4 → 0.16.6

package/dist/template/.opencode/skill/beads-bridge/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: beads-bridge
 description: >
-  Multi-agent task coordination using Beads Village plugin tools. Use when work spans multiple sessions,
+  Multi-agent task coordination using br (beads_rust) and OpenCode tools. Use when work spans multiple sessions,
   has dependencies, needs file locking, or requires agent coordination. Covers claim/reserve/done cycle,
   dependency management, hierarchical decomposition, and session protocols.
-version: "1.0.0"
+version: "2.0.0"
 license: MIT
 ---
 
@@ -12,23 +12,29 @@ license: MIT
 
 Bridge between Beads git-backed task tracking, OpenCode's native todo system, and swarm coordination.
 
+**Note:** `br` (beads_rust) is non-invasive and never executes git commands. After `br sync --flush-only`, you must manually run `git add .beads/ && git commit`.
+
 ## Overview
 
-**Beads Bridge = Beads + OpenCode Todos + Swarm Monitor**
+**Beads Bridge = Beads (br) + OpenCode Todos + Swarm Monitor**
 
-- **Beads**: Git-backed task tracking with dependency management
+- **Beads (br)**: Git-backed task tracking with dependency management
 - **OpenCode Todos**: Native session-scoped task lists for subagents
 - **Swarm Monitor**: Real-time progress tracking (visualization only)
 
 **Key Tools**:
 
-| Tool             | Purpose                                 | When to Use                              |
-| ---------------- | --------------------------------------- | ---------------------------------------- |
-| `beads-sync`     | Sync Beads ↔ OpenCode todos             | Start of session, before spawning swarms |
-| `swarm-monitor`  | Progress tracking (visualization)       | During swarm execution                   |
-| `swarm-plan`     | Task classification + dependency graphs | Before spawning workers                  |
-| `swarm-delegate` | Create delegation packets               | Assigning work to workers                |
-| `Task`           | Parallel subagent execution             | Spawning worker swarms                   |
+| Tool    | Purpose                     | When to Use                                          |
+| ------- | --------------------------- | ---------------------------------------------------- |
+| `swarm` | Unified swarm coordination  | All swarm operations (sync, monitor, plan, delegate) |
+| `Task`  | Parallel subagent execution | Spawning worker swarms                               |
+
+**swarm operations:**
+
+- `sync`: Sync Beads ↔ OpenCode todos (start of session, before spawning)
+- `monitor`: Progress tracking/visualization (during swarm execution)
+- `plan`: Task classification + dependency graphs (before spawning workers)
+- `delegate`: Create delegation packets (assigning work to workers)
 
 ## When to Use This Skill
 
@@ -46,8 +52,9 @@ Make Beads tasks visible to subagents:
 
 ```typescript
 // Push Beads to OpenCode todos
-const result = await beads_sync({
-  operation: "push",
+const result = await swarm({
+  operation: "sync",
+  action: "push",
   filter: "open", // or "in_progress", "all"
 });
 
@@ -61,8 +68,9 @@ Check current swarm progress:
 
 ```typescript
 // Check swarm status
-const status = await swarm_monitor({
-  operation: "status",
+const status = await swarm({
+  operation: "monitor",
+  action: "status",
   team_name: "api-refactor-swarm",
 });
 
@@ -70,8 +78,9 @@ const stats = JSON.parse(status).summary;
 console.log(`Workers: ${stats.total_workers}, Completed: ${stats.completed}`);
 
 // Render TUI for visualization
-const ui = await swarm_monitor({
-  operation: "render_block",
+const ui = await swarm({
+  operation: "monitor",
+  action: "render_block",
   team_name: "api-refactor-swarm",
 });
 console.log(ui);
@@ -83,8 +92,9 @@ For work that spans multiple sessions, use shared task lists:
 
 ```typescript
 // Create a shared list that persists across sessions
-const list = await beads_sync({
-  operation: "create_shared",
+const list = await swarm({
+  operation: "sync",
+  action: "create_shared",
   name: "api-refactor-swarm",
   tasks: JSON.stringify([
     { id: "task-1", content: "Refactor auth endpoint", status: "pending", priority: "high" },
@@ -93,8 +103,9 @@ const list = await beads_sync({
 });
 
 // Workers update the shared list as they complete work
-await beads_sync({
-  operation: "update_shared",
+await swarm({
+  operation: "sync",
+  action: "update_shared",
   list_id: list.list_id,
   tasks: JSON.stringify([{ id: "task-1", status: "completed" }]),
 });
@@ -106,8 +117,9 @@ Create persistent task lists that survive session boundaries:
 
 ```typescript
 // Create a shared list for a swarm
-const list = await beads_sync({
-  operation: "create_shared",
+const list = await swarm({
+  operation: "sync",
+  action: "create_shared",
   name: "api-refactor-swarm",
   tasks: JSON.stringify([
     { id: "task-1", content: "Refactor auth endpoint", status: "pending", priority: "high" },
@@ -118,7 +130,7 @@ const list = await beads_sync({
 
 // Share the list ID with workers
 console.log(`List ID: ${list.list_id}`);
-// Workers can access via: beads_sync({ operation: "get_shared", list_id: "..." })
+// Workers can access via: swarm({ operation: "sync", action: "get_shared", list_id: "..." })
 ```
 
 ### 5. Worker Updates to Shared List
@@ -127,8 +139,9 @@ Workers can update their task status:
 
 ```typescript
 // Worker completes a task
-await beads_sync({
-  operation: "update_shared",
+await swarm({
+  operation: "sync",
+  action: "update_shared",
   list_id: "shl_abc123",
   tasks: JSON.stringify([{ id: "task-1", status: "completed" }]),
 });
@@ -142,14 +155,15 @@ Full cycle from Beads task to swarm execution and back:
 
 ```typescript
 // 1. Start: Push Beads to todos
-await beads_sync({ operation: "push" });
+await swarm({ operation: "sync", action: "push" });
 
 // 2. Claim the parent Bead
 await bash("br update parent-task --status in_progress");
 
 // 3. Analyze and spawn swarm
-const analysis = await swarm_plan({
-  operation: "analyze",
+const analysis = await swarm({
+  operation: "plan",
+  action: "analyze",
   task: "Implement API refactor",
   files: "src/api/users.ts,src/api/posts.ts,src/api/auth.ts",
 });
@@ -158,26 +172,30 @@ const analysis = await swarm_plan({
 // ... spawn workers, monitor progress ...
 
 // 5. Complete: Pull completed todos back to Beads
-await beads_sync({ operation: "pull" });
+await swarm({ operation: "sync", action: "pull" });
 
 // 6. Clear swarm state
-await swarm_monitor({
-  operation: "clear",
+await swarm({
+  operation: "monitor",
+  action: "clear",
   team_name: "api-refactor-swarm",
 });
 
-// 7. Close parent Bead
+// 7. Close parent Bead and sync
 await bash("br close parent-task --reason 'Swarm completed all subtasks'");
+await bash("br sync --flush-only");
+await bash("git add .beads/ && git commit -m 'close parent-task'");
 ```
 
 ### Pattern B: Dependency-Aware Task Scheduling
 
-Use swarm-plan's dependency graph for proper ordering:
+Use swarm tool's dependency graph for proper ordering:
 
 ```typescript
 // Get full analysis with dependency graph
-const analysis = await swarm_plan({
-  operation: "analyze",
+const analysis = await swarm({
+  operation: "plan",
+  action: "analyze",
   task: "Refactor authentication system",
   files: "src/auth/service.ts,src/auth/types.ts,src/routes/auth.ts,src/middleware/auth.ts",
 });
@@ -212,8 +230,9 @@ When work needs to continue in a new session:
 
 ```typescript
 // End of session 1: Save state to memory and shared list
-await beads_sync({
-  operation: "update_shared",
+await swarm({
+  operation: "sync",
+  action: "update_shared",
   list_id: "api-refactor-swarm",
   tasks: JSON.stringify([
     { id: "worker-1", content: "Auth service", status: "completed" },
@@ -240,14 +259,20 @@ Next steps:
   mode: "replace",
 });
 
+// Sync beads before ending session
+await bash("br sync --flush-only");
+await bash("git add .beads/ && git commit -m 'session handoff'");
+
 // Start of session 2: Check status and continue
-const status = await swarm_monitor({
-  operation: "status",
+const status = await swarm({
+  operation: "monitor",
+  action: "status",
   team_name: "api-refactor-swarm",
 });
 
-const shared = await beads_sync({
-  operation: "get_shared",
+const shared = await swarm({
+  operation: "sync",
+  action: "get_shared",
   list_id: "api-refactor-swarm",
 });
 
@@ -267,28 +292,30 @@ console.log(`Continuing swarm with ${shared.tasks.length} tasks...`);
 
 ```
 SESSION START:
-  beads-sync({ operation: "push" })  // Make Beads visible to subagents
-  swarm-monitor({ operation: "status", team_name: "..." })  // Check swarm status
+  swarm({ operation: "sync", action: "push" })  // Make Beads visible to subagents
+  swarm({ operation: "monitor", action: "status", team_name: "..." })  // Check swarm status
 
 DURING WORK:
-  swarm-monitor({ operation: "progress_update", ... })  // Track worker progress
-  swarm-monitor({ operation: "render_block", ... })  // TUI visualization
-  beads-sync({ operation: "update_shared", ... })  // Cross-session updates
+  swarm({ operation: "monitor", action: "progress_update", ... })  // Track worker progress
+  swarm({ operation: "monitor", action: "render_block", ... })  // TUI visualization
+  swarm({ operation: "sync", action: "update_shared", ... })  // Cross-session updates
 
 SESSION END:
-  beads-sync({ operation: "pull" })  // Sync completed todos back to Beads
-  swarm-monitor({ operation: "clear", team_name: "..." })  // Cleanup swarm state
-  br sync --flush-only  // Export Beads changes to git
+  swarm({ operation: "sync", action: "pull" })  // Sync completed todos back to Beads
+  swarm({ operation: "monitor", action: "clear", team_name: "..." })  // Cleanup swarm state
+  br sync --flush-only  // Export Beads changes
+  git add .beads/ && git commit -m "..."  // Commit changes to git
 
 RECOVERY:
-  beads-sync({ operation: "get_shared", list_id: "..." })  // Get shared task list
-  swarm-monitor({ operation: "status", team_name: "..." })  // Check swarm status
+  swarm({ operation: "sync", action: "get_shared", list_id: "..." })  // Get shared task list
+  swarm({ operation: "monitor", action: "status", team_name: "..." })  // Check swarm status
 ```
 
 ## Rules
 
 1. **Always push Beads at session start** - Subagents need visibility via todoread
-2. **Use shared lists for long-running swarms** - Cross-session persistence via beads-sync
+2. **Use shared lists for long-running swarms** - Cross-session persistence via swarm sync
 3. **Pull completed todos back to Beads** - Keep tracking system in sync
 4. **Check swarm status before spawning** - Avoid duplicate work
 5. **Clear swarm state when done** - Cleanup after completion
+6. **Always sync and commit before session end** - `br sync --flush-only` then `git add .beads/ && git commit`

package/dist/template/.opencode/skill/brainstorming/SKILL.md

@@ -11,6 +11,10 @@ Help turn ideas into fully formed designs and specs through natural collaborativ
 
 Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.
 
+**Part of:** `development-lifecycle` skill (Phase 1: Ideation)
+
+**Output template:** `.opencode/memory/_templates/design.md`
+
 ## The Process
 
 **Understanding the idea:**
@@ -39,15 +43,25 @@ Start by understanding the current project context, then ask questions one at a
 
 **Documentation:**
 
-- Write the validated design to `.beads/artifacts/<bead-id>/design.md` using template from `.opencode/memory/_templates/design.md`
+- Write the validated design to `.beads/artifacts/<bead-id>/design.md`
+- Use template from `.opencode/memory/_templates/design.md`
 - Use elements-of-style:writing-clearly-and-concisely skill if available
 - Commit the design document to git
 
-**Implementation (if continuing):**
+**Next Phase (if continuing):**
+
+- Ask: "Ready to create the PRD?"
+- Load next skill: `skill({ name: "prd" })`
+- This moves to Phase 2: Specification
+
+**Alternative paths:**
+
+- Use `skill({ name: "using-git-worktrees" })` to create isolated workspace first
+- Use `skill({ name: "writing-plans" })` if skipping formal PRD
+
+**Full lifecycle reference:**
 
-- Ask: "Ready to set up for implementation?"
-- Use skill({ name: "using-git-worktrees" }) to create isolated workspace
-- Use skill({ name: "writing-plans" }) to create detailed implementation plan
+- Use `skill({ name: "development-lifecycle" })` to see all phases
 
 ## Key Principles
 

package/dist/template/.opencode/skill/context-engineering/SKILL.md

@@ -1,94 +1,61 @@
 ---
-description: Use when managing context window, deciding what to load/prune, or understanding AI adoption stages - covers constraint awareness and intent layer principles
+name: context-engineering
+description: Use when designing AGENTS.md hierarchies, understanding autonomous duration, or writing intent layers - covers principles for extending agent work capacity
 ---
 
-# Context Engineering Skill
+# Context Engineering
 
-## AI Adoption Stages
+Principles for maximizing agent effectiveness through context design.
 
-OpenCode operates at **Stage 5-6**:
+**For practical context tools (prune/distill/compress), use `context-management` skill.**
 
-- **Stage 5** (Agentic Verification): Agents run tests and iterate autonomously
-- **Stage 6** (Multi-Agent Orchestration): Parallel workstreams with coordination
+## Core Principle
 
-**Current constraint**: Planning and specification quality. Implementation capacity is not the bottleneck—how well you specify requirements is.
+**Autonomous Duration**: How long can an agent work before losing the plot?
 
-## Autonomous Duration
-
-The key metric: **How long can an agent work before losing the plot?**
-
-Extend autonomous duration by:
+Extend it by:
 
 - Binding tighter to intent (clear specs, constraints, invariants)
 - Providing systematic context (AGENTS.md hierarchy, memory files)
 - Verification loops (test → iterate → verify)
 
-## Greenfield vs Legacy
-
-| Type           | Context                    | Agent Performance             |
-| -------------- | -------------------------- | ----------------------------- |
-| **Greenfield** | Simple, fast prototypes    | Works well immediately        |
-| **Legacy**     | Complex, hidden invariants | Needs careful context loading |
-
-Codebase complexity is a primary difficulty knob. Context is how you pay it down.
-
 ## Three Context Constraints
 
-1. **Blind spots cause hallucinations** - If agent doesn't see specific context, it fills gaps with generic training priors. You only get the behavior you load.
-
-2. **Everything influences everything** - Noise-to-signal ratio matters. Irrelevant files degrade ALL output quality.
-
-3. **Window is finite** - Performance degrades BEFORE hitting hard token limits. Curate the smallest, highest-signal slice.
-
-## Practical Implications
-
-| Instead of              | Do This                                               |
-| ----------------------- | ----------------------------------------------------- |
-| Reading entire files    | Use `lsp_lsp_document_symbols` for outline            |
-| Loading whole documents | Read specific line ranges                             |
-| Flat file loading       | Navigate AGENTS.md hierarchy (progressive disclosure) |
-| Keeping completed work  | Prune context aggressively                            |
+1. **Blind spots cause hallucinations** - Agent fills gaps with generic priors
+2. **Everything influences everything** - Noise degrades ALL output quality
+3. **Window is finite** - Performance degrades BEFORE hard token limits
 
 ## Intent Layer Principles
 
 ### What Belongs in Each AGENTS.md
 
-- **Purpose & Scope** - What this area does. What it explicitly DOESN'T do.
-- **Entry Points & Contracts** - Main APIs, invariants, "all X goes through Y"
-- **Usage Patterns** - Canonical examples: "To add a rule, follow this pattern..."
-- **Anti-patterns** - Negative examples: "Never call X directly; go through Y"
-- **Dependencies & Downlinks** - What it connects to, pointers to child AGENTS.md
-- **Pitfalls** - Things that repeatedly confused agents/humans
+- **Purpose & Scope** - What this area does. What it DOESN'T do.
+- **Entry Points & Contracts** - Main APIs, invariants
+- **Usage Patterns** - Canonical examples
+- **Anti-patterns** - What NOT to do
+- **Dependencies & Downlinks** - Pointers to related context
 
 ### Key Mechanics
 
-| Principle                       | Meaning                                                       |
-| ------------------------------- | ------------------------------------------------------------- |
-| **Hierarchical loading**        | When a node loads, all ancestors load too (T-shaped view)     |
-| **Compression, not bloat**      | Good nodes compress code; 10k tokens for 20k code adds weight |
-| **Least Common Ancestor (LCA)** | Place shared knowledge at shallowest node covering all paths  |
-| **Downlinks for discovery**     | Point to related context without loading everything upfront   |
+| Principle                | Meaning                                                  |
+| ------------------------ | -------------------------------------------------------- |
+| **Hierarchical loading** | When node loads, all ancestors load too (T-shaped view)  |
+| **Compression**          | Good nodes compress code; don't add bloat                |
+| **LCA placement**        | Place shared knowledge at shallowest node covering paths |
+| **Downlinks**            | Point to related context without loading everything      |
 
-## Context Budget Guidelines
+## Practical Implications
 
-| Phase             | Target Context | Action                                    |
-| ----------------- | -------------- | ----------------------------------------- |
-| Starting work     | <50k tokens    | Load only essential AGENTS.md + task spec |
-| Mid-task          | 50-100k tokens | Prune completed reads, keep active files  |
-| Approaching limit | >100k tokens   | Aggressive pruning, extract key findings  |
-| Near capacity     | >150k tokens   | Consider session restart with handoff     |
+| Instead of              | Do This                                 |
+| ----------------------- | --------------------------------------- |
+| Reading entire files    | Use `lsp documentSymbol` for outline    |
+| Loading whole documents | Read specific line ranges               |
+| Flat file loading       | Navigate AGENTS.md hierarchy            |
+| Keeping completed work  | Prune aggressively (context-management) |
 
 ## Anti-Patterns
 
 ❌ Loading "everything that might be relevant"
 ❌ Keeping old file reads after editing complete
 ❌ Reading entire files when you only need a function
-❌ Ignoring AGENTS.md hierarchy (loading leaf without ancestors)
-
-## Best Practices
-
-✅ Start with minimum viable context
-✅ Use LSP tools for targeted information
-✅ Prune after each completed sub-task
-✅ Trust AGENTS.md hierarchy for discovery
-✅ Extract findings before pruning valuable reads
+❌ Ignoring AGENTS.md hierarchy

package/dist/template/.opencode/skill/context-management/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: context-management
+description: Use when context is growing large, needing to prune/distill tool outputs, or managing conversation size - covers DCP tools (prune, distill, compress) and context budgets
+---
+
+# Context Management (DCP)
+
+Manage conversation context to prevent degradation. Uses prune/distill/compress tools.
+
+## The Three Tools
+
+| Tool       | Purpose                       | When to Use                              |
+| ---------- | ----------------------------- | ---------------------------------------- |
+| `prune`    | Remove tool outputs (no save) | Noise, irrelevant reads, superseded info |
+| `distill`  | Extract key info, then remove | Large outputs with valuable details      |
+| `compress` | Collapse conversation range   | Completed phases, exploration done       |
+
+## When to Evaluate
+
+**DO evaluate context when:**
+
+- Accessed something irrelevant
+- Information superseded by newer outputs
+- Starting a new phase of work
+- Large tool outputs with valuable details
+- Phase complete (research, exploration, implementation)
+
+**DO NOT prune when:**
+
+- Output needed for upcoming edits
+- Contains files you'll reference when editing
+- Uncertain if you'll need it again
+
+## Tool Usage
+
+### Prune - Remove Noise
+
+```typescript
+prune({ ids: ["5", "8"] }); // IDs from <prunable-tools> list
+```
+
+### Distill - Preserve + Remove
+
+```typescript
+distill({
+  ids: ["10", "11"],
+  distillation: [
+    "auth.ts: validateToken(token: string) -> User|null, bcrypt 12 rounds",
+    "user.ts: interface User { id, email, permissions[], status }",
+  ],
+});
+```
+
+### Compress - Collapse Ranges
+
+```typescript
+compress({
+  input: [
+    "exact text from start", // Must exist VERBATIM
+    "exact text from end", // Must come AFTER start
+    "Topic Label", // 3-5 words
+    "Summary of accomplishments", // Replacement text
+  ],
+});
+```
+
+## Critical Rules
+
+**For prune/distill:**
+
+- IDs MUST come from current `<prunable-tools>` list
+- List refreshes after every tool use - don't cache IDs
+- Invalid IDs error: `"Invalid IDs provided"`
+
+**For compress:**
+
+- Start/end strings must match EXACTLY
+- Start must appear BEFORE end chronologically
+- Both strings must be unique (appear only once)
+
+## Protected Content
+
+Auto-protected from pruning:
+
+- `.env*` files
+- `AGENTS.md`
+- `.opencode/**` config
+- `.beads/**` tasks
+- `package.json`, `tsconfig.json`, `biome.json`
+
+## Context Budget Guidelines
+
+| Phase             | Target  | Action                                    |
+| ----------------- | ------- | ----------------------------------------- |
+| Starting work     | <50k    | Load only essential AGENTS.md + task spec |
+| Mid-task          | 50-100k | Prune completed reads, keep active files  |
+| Approaching limit | >100k   | Aggressive pruning, extract key findings  |
+| Near capacity     | >150k   | Session restart with handoff              |
+
+## DCP Commands (User)
+
+- `/dcp context` - Token usage breakdown
+- `/dcp stats` - Cumulative pruning statistics
+- `/dcp sweep` - Prune all tools since last user message
+- `/dcp sweep 10` - Prune last 10 tools
+
+## Quick Reference
+
+```
+PRUNE: Remove noise → prune({ ids: [...] })
+DISTILL: Save + remove → distill({ ids: [...], distillation: [...] })
+COMPRESS: Collapse phase → compress({ input: [start, end, topic, summary] })
+
+BUDGET: <50k start → 50-100k mid → >100k prune → >150k restart
+```

package/dist/template/.opencode/skill/deep-research/SKILL.md

@@ -110,8 +110,8 @@ Only if internal exploration doesn't answer the question:
 
 ```typescript
 // Official docs
-context7_resolve_library_id({ libraryName: "<lib>" });
-context7_query_docs({ libraryId: "<id>", topic: "<specific question>" });
+context7({ operation: "resolve", libraryName: "<lib>" });
+context7({ operation: "query", libraryId: "<id>", topic: "<specific question>" });
 
 // Real-world patterns
 codesearch({ query: "<API usage pattern>", tokensNum: 5000 });
@@ -284,8 +284,8 @@ grep({ pattern: "rateLimit", include: "*.ts" });
 glob({ pattern: "src/middleware/*.ts" });
 
 // Phase 4: External (if patterns unclear)
-context7_resolve_library_id({ libraryName: "express" });
-context7_query_docs({ libraryId: "/expressjs/express", topic: "middleware" });
+context7({ operation: "resolve", libraryName: "express" });
+context7({ operation: "query", libraryId: "/expressjs/express", topic: "middleware" });
 
 // Document findings
 write({