opencode-swarm-plugin 0.21.0 → 0.23.0

package/.turbo/turbo-build.log

@@ -0,0 +1,9 @@
+$ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
+Bundled 195 modules in 33ms
+
+  index.js  1.14 MB  (entry point)
+
+Bundled 196 modules in 32ms
+
+  plugin.js  1.12 MB  (entry point)
+

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# opencode-swarm-plugin
+
+## 0.23.0
+
+### Minor Changes
+
+- [`b66d77e`](https://github.com/joelhooks/opencode-swarm-plugin/commit/b66d77e484e9b7021b3264d1a7e8f54a16ea5204) Thanks [@joelhooks](https://github.com/joelhooks)! - Add changesets workflow and semantic memory test isolation
+
+  - OIDC publish workflow with GitHub Actions
+  - Changesets for independent package versioning
+  - TEST_SEMANTIC_MEMORY_COLLECTION env var for test isolation
+  - Prevents test pollution of production semantic-memory

package/README.md

@@ -1,6 +1,6 @@
 # opencode-swarm-plugin
 
-[![npm version](https://img.shields.io/npm/v/opencode-swarm-plugin.svg)](https://www.npmjs.com/package/opencode-swarm-plugin)
+OpenCode plugin for multi-agent swarm coordination with learning capabilities.
 
 ```
  ███████╗██╗    ██╗ █████╗ ██████╗ ███╗   ███╗
@@ -9,42 +9,16 @@
  ╚════██║██║███╗██║██╔══██║██╔══██╗██║╚██╔╝██║
  ███████║╚███╔███╔╝██║  ██║██║  ██║██║ ╚═╝ ██║
  ╚══════╝ ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝
-
-    \ ` - ' /
-   - .(o o). -
-    (  >.<  )        Break big tasks into small ones.
-     /|   |\         Spawn agents to work in parallel.
-    (_|   |_)        Learn from what works.
-      bzzzz...
 ```
 
-## What is this?
-
-You give it a task. It breaks it into pieces. It spawns agents to work on each piece simultaneously. They coordinate so they don't step on each other. When they're done, you have working code.
-
-```
-                            "Add OAuth"
-                                 │
-                                 ▼
-                    ┌────────────────────────┐
-                    │      COORDINATOR       │
-                    │  picks strategy, splits│
-                    └────────────────────────┘
-                                 │
-           ┌─────────────────────┼─────────────────────┐
-           ▼                     ▼                     ▼
-    ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
-    │  Worker A   │       │  Worker B   │       │  Worker C   │
-    │ auth/oauth  │       │ auth/session│       │ auth/tests  │
-    │   🔒 files  │       │   🔒 files  │       │   🔒 files  │
-    └─────────────┘       └─────────────┘       └─────────────┘
-           │                     │                     │
-           └─────────────────────┼─────────────────────┘
-                                 ▼
-                         working code
-```
+## Features
 
-The plugin learns from outcomes - what decomposition strategies work, which patterns fail, how long things take. Over time, it gets better at breaking down tasks.
+- **Swarm Coordination** - Break tasks into parallel subtasks, spawn worker agents
+- **Beads Integration** - Git-backed issue tracking with atomic epic creation
+- **Agent Mail** - Inter-agent messaging with file reservations
+- **Learning System** - Pattern maturity, anti-pattern detection, confidence decay
+- **Skills System** - Knowledge injection with bundled and custom skills
+- **Checkpointing** - Survive context compaction, resume from last checkpoint
 
 ## Install
 
@@ -55,160 +29,131 @@ swarm setup
 
 ## Usage
 
-```
+```bash
 /swarm "Add user authentication with OAuth"
 ```
 
-## How it decides to split work
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                     STRATEGY SELECTION                          │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  "refactor auth"  ──────►  FILE-BASED                          │
-│  "migrate to v2"           Group by directory structure         │
-│  "rename all X"            Minimize cross-directory deps        │
-│                                                                 │
-│  "add feature"    ──────►  FEATURE-BASED                       │
-│  "implement X"             Vertical slices (data→logic→UI)      │
-│  "build new"               Keep related components together     │
-│                                                                 │
-│  "fix bug"        ──────►  RISK-BASED                          │
-│  "security issue"          Tests FIRST                          │
-│  "critical"                Isolate risky changes                │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## What survives when context dies
-
-Swarms used to die when OpenCode compacted context. Not anymore.
+## Tools Provided
+
+### Beads (Issue Tracking)
+
+| Tool                | Purpose                               |
+| ------------------- | ------------------------------------- |
+| `beads_create`      | Create bead with type-safe validation |
+| `beads_create_epic` | Atomic epic + subtasks creation       |
+| `beads_query`       | Query with filters                    |
+| `beads_update`      | Update status/description/priority    |
+| `beads_close`       | Close with reason                     |
+| `beads_start`       | Mark in-progress                      |
+| `beads_ready`       | Get next unblocked bead               |
+| `beads_sync`        | Sync to git                           |
+
+### Swarm Mail (Agent Coordination)
+
+| Tool                     | Purpose                          |
+| ------------------------ | -------------------------------- |
+| `swarmmail_init`         | Initialize session               |
+| `swarmmail_send`         | Send message to agents           |
+| `swarmmail_inbox`        | Fetch inbox (context-safe)       |
+| `swarmmail_read_message` | Fetch one message body           |
+| `swarmmail_reserve`      | Reserve files for exclusive edit |
+| `swarmmail_release`      | Release reservations             |
+
+### Swarm (Task Orchestration)
+
+| Tool                           | Purpose                                         |
+| ------------------------------ | ----------------------------------------------- |
+| `swarm_select_strategy`        | Analyze task, recommend strategy                |
+| `swarm_decompose`              | Generate decomposition prompt (queries CASS)    |
+| `swarm_delegate_planning`      | Delegate planning to planner subagent           |
+| `swarm_validate_decomposition` | Validate response, detect conflicts             |
+| `swarm_plan_prompt`            | Generate strategy-specific decomposition prompt |
+| `swarm_subtask_prompt`         | Generate worker agent prompt                    |
+| `swarm_spawn_subtask`          | Prepare subtask for Task tool spawning          |
+| `swarm_evaluation_prompt`      | Generate self-evaluation prompt                 |
+| `swarm_init`                   | Initialize swarm session                        |
+| `swarm_status`                 | Get swarm progress by epic ID                   |
+| `swarm_progress`               | Report subtask progress to coordinator          |
+| `swarm_complete`               | Complete subtask (runs UBS scan, releases)      |
+| `swarm_record_outcome`         | Record outcome for learning                     |
+| `swarm_checkpoint`             | Save progress snapshot                          |
+| `swarm_recover`                | Resume from checkpoint                          |
+| `swarm_learn`                  | Extract learnings from outcome                  |
+| `swarm_broadcast`              | Send message to all active agents               |
+| `swarm_accumulate_error`       | Track recurring errors (3-strike system)        |
+| `swarm_check_strikes`          | Check if error threshold reached                |
+| `swarm_get_error_context`      | Get context for error pattern                   |
+| `swarm_resolve_error`          | Mark error pattern as resolved                  |
+
+### Skills (Knowledge Injection)
+
+| Tool            | Purpose                 |
+| --------------- | ----------------------- |
+| `skills_list`   | List available skills   |
+| `skills_use`    | Load skill into context |
+| `skills_read`   | Read skill content      |
+| `skills_create` | Create new skill        |
+
+## Bundled Skills
+
+Located in `global-skills/`:
+
+- **testing-patterns** - 25 dependency-breaking techniques, characterization tests
+- **swarm-coordination** - Multi-agent decomposition, file reservations
+- **cli-builder** - Argument parsing, help text, subcommands
+- **system-design** - Architecture decisions, module boundaries
+- **learning-systems** - Confidence decay, pattern maturity
+- **skill-creator** - Meta-skill for creating new skills
 
-```
-     Session 1                    Context                   Session 2
-         │                       Compacts                       │
-         ▼                          💥                          ▼
-┌─────────────────┐                                   ┌─────────────────┐
-│ swarm running   │                                   │ swarm_recover() │
-│ ├─ 25% ✓ saved  │                                   │       │         │
-│ ├─ 50% ✓ saved  │ ─────────────────────────────────►│       ▼         │
-│ └─ 75% ✓ saved  │      checkpoints survive          │ resume at 75%   │
-└─────────────────┘                                   └─────────────────┘
-```
-
-The plugin checkpoints at 25%, 50%, and 75% progress. Files reserved, progress tracked, context preserved.
-
-## Learning
-
-The plugin tracks outcomes and adjusts over time:
-
-```
-                    ┌─────────────────────────────────┐
-                    │         LEARNING LOOP           │
-                    └─────────────────────────────────┘
-                                    │
-        ┌───────────────────────────┼───────────────────────────┐
-        ▼                           ▼                           ▼
-┌───────────────┐           ┌───────────────┐           ┌───────────────┐
-│   OUTCOMES    │           │   PATTERNS    │           │ ANTI-PATTERNS │
-│               │           │               │           │               │
-│ fast+success  │           │  candidate    │           │ >60% failure  │
-│ = good signal │──────────►│      ↓        │──────────►│ = auto-invert │
-│               │           │  established  │           │               │
-│ slow+errors   │           │      ↓        │           │ "split by X"  │
-│ = bad signal  │           │    proven     │           │ becomes       │
-│               │           │               │           │ "DON'T split  │
-└───────────────┘           └───────────────┘           │  by X"        │
-                                                        └───────────────┘
-
-                    Confidence decays over 90 days
-                    unless patterns are revalidated
-```
-
-## Skills
-
-Skills are knowledge packages agents can load. Teach once, use everywhere.
+## Architecture
 
 ```
-skills_use(name="testing-patterns")    # Load testing knowledge
-skills_use(name="swarm-coordination")  # Load swarm workflow
+src/
+├── beads.ts           # Beads integration
+├── agent-mail.ts      # Agent Mail tools (legacy MCP wrapper)
+├── swarm-mail.ts      # Swarm Mail tools (new, uses swarm-mail package)
+├── swarm.ts           # Swarm orchestration tools
+├── swarm-orchestrate.ts # Coordinator logic
+├── swarm-decompose.ts # Decomposition strategies
+├── swarm-strategies.ts # Strategy selection
+├── skills.ts          # Skills system
+├── learning.ts        # Pattern maturity, outcomes
+├── anti-patterns.ts   # Anti-pattern detection
+├── structured.ts      # JSON parsing utilities
+├── mandates.ts        # Mandate system
+└── schemas/           # Zod schemas
 ```
 
-Bundled: `cli-builder`, `learning-systems`, `swarm-coordination`, `system-design`, `testing-patterns`, `skill-creator`
+## Dependencies
 
-Create your own in `.opencode/skills/` or `~/.config/opencode/skills/`.
+- [swarm-mail](../swarm-mail) - Event sourcing primitives (workspace dependency)
+- [@opencode-ai/plugin](https://www.npmjs.com/package/@opencode-ai/plugin) - OpenCode plugin API
+- [effect](https://effect.website) - Effect-TS for type-safe composition
+- [zod](https://zod.dev) - Schema validation
 
-## Architecture
+## Development
 
-Everything runs in-process. No external servers.
+```bash
+# From monorepo root
+bun turbo build --filter=opencode-swarm-plugin
+bun turbo test --filter=opencode-swarm-plugin
+bun turbo typecheck --filter=opencode-swarm-plugin
 
+# Or from this directory
+bun run build
+bun test
+bun run typecheck
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                         YOUR TASK                               │
-└─────────────────────────────────────────────────────────────────┘
-                                │
-                                ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  DECOMPOSITION         strategy selection, subtask creation     │
-└─────────────────────────────────────────────────────────────────┘
-                                │
-                                ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  BEADS                 git-backed issues for each subtask       │
-└─────────────────────────────────────────────────────────────────┘
-                                │
-                                ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  SWARM MAIL            agent coordination, file reservations    │
-└─────────────────────────────────────────────────────────────────┘
-                                │
-                                ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  PGLITE                embedded postgres, event-sourced state   │
-└─────────────────────────────────────────────────────────────────┘
-                                │
-                                ▼
-┌─────────────────────────────────────────────────────────────────┐
-│  LEARNING              outcomes feed back into decomposition    │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Dependencies
-
-| Required                                     | Optional                                                                                      |
-| -------------------------------------------- | --------------------------------------------------------------------------------------------- |
-| [OpenCode](https://opencode.ai)              | [CASS](https://github.com/Dicklesworthstone/coding_agent_session_search) - historical context |
-| [Beads](https://github.com/steveyegge/beads) | [UBS](https://github.com/Dicklesworthstone/ultimate_bug_scanner) - bug scanning               |
-|                                              | [semantic-memory](https://github.com/joelhooks/semantic-memory) - learning persistence        |
-
-Run `swarm doctor` to check status.
 
 ## CLI
 
-```
+```bash
 swarm setup     # Install and configure
 swarm doctor    # Check dependencies
 swarm init      # Initialize beads in project
 swarm config    # Show config file paths
 ```
 
-## Development
-
-```bash
-bun install
-bun test
-bun run build
-```
-
-## Credits
-
-Built on ideas from:
-
-- [MCP Agent Mail](https://github.com/Dicklesworthstone/mcp_agent_mail) - multi-agent coordination patterns
-- [Superpowers](https://github.com/obra/superpowers) - verification patterns and skill architecture
-- [Electric SQL](https://electric-sql.com) - durable streams and event sourcing
-
 ## License
 
 MIT