opencodekit 0.15.21 → 0.16.1

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

@@ -20,6 +20,11 @@ You're creating an implementation plan with proper Epic → Task → Subtask hie
 
 ```typescript
 skill({ name: "beads" });
+skill({ name: "deep-research" });
+skill({ name: "executing-plans" });
+skill({ name: "writing-plans" });
+skill({ name: "subagent-driven-development" });
+skill({ name: "memory-system" });
 ```
 
 ```bash
@@ -37,28 +42,38 @@ cat .beads/artifacts/$ARGUMENTS/research.md 2>/dev/null || echo "No research fou
 
 **If complexity > M and no research:** "Consider `/research $ARGUMENTS` first for better planning."
 
+## Templates Reference
+
+Copy templates from `.opencode/memory/_templates/` to bead artifacts folder:
+
+```bash
+# Copy templates to bead folder
+BEAD_DIR=".beads/artifacts/$ARGUMENTS"
+mkdir -p "$BEAD_DIR"
+
+# Copy design template (we'll fill it in Phase 3)
+cp .opencode/memory/_templates/design.md "$BEAD_DIR/design.md"
+
+# Copy tasks template (we'll fill it in Phase 6)
+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    |
+
 ## Check Memory First (Semantic Search)
 
 Before subagent research, check what we already know:
 
 ```typescript
 // Find similar past plans
-memory -
-  search({
-    query: "[bead title/description]",
-    mode: "semantic",
-    type: "bead",
-    limit: 3,
-  });
+memory_search({ query: "[bead title/description]", limit: 3 });
 
 // Find related patterns and decisions
-memory -
-  search({
-    query: "[domain keywords]",
-    mode: "semantic",
-    type: "observation",
-    limit: 3,
-  });
+memory_search({ query: "[domain keywords] gotchas patterns", limit: 3 });
 ```
 
 Review findings for:
@@ -104,6 +119,12 @@ Task({
 
 **Integrate findings into your plan.**
 
+## Skill Routing
+
+- Use **deep-research** when the domain is unfamiliar or ambiguous.
+- Use **writing-plans** when producing a detailed, step-by-step implementation plan.
+- Use **executing-plans** only when a complete plan already exists and needs execution.
+
 ---
 
 ## Phase 2: Analyze for Decomposition
@@ -528,8 +549,7 @@ Next: /start bd-xxx1
 
 | Need                 | Command                  |
 | -------------------- | ------------------------ |
-| Create spec first    | `/create <bead-id>`      |
 | Research before plan | `/research <bead-id>`    |
 | Start first task     | `/start <first-task-id>` |
+| Ship the work        | `/ship <bead-id>`        |
 | View hierarchy       | `bd dep tree <bead-id>`  |
-| Import external plan | `/import-plan`           |

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

@@ -11,8 +11,23 @@ agent: build
 ```typescript
 skill({ name: "beads" }); // Session protocol
 skill({ name: "verification-before-completion" });
+skill({ name: "memory-system" });
 ```
 
+## Check Memory for Related Context
+
+Search for related decisions and patterns:
+
+```typescript
+// Find related decisions and patterns for this work
+memory_search({ query: "$ARGUMENTS [feature keywords]", limit: 3 });
+
+// Find any gotchas related to this area
+memory_search({ query: "[affected files/modules] gotchas", limit: 2 });
+```
+
+Include relevant context from memory in PR description.
+
 ## Options
 
 - `--draft`: Create as draft PR (for WIP or early feedback)

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

@@ -28,6 +28,9 @@ skill({ name: "source-code-research" });
 
 // For swarm coordination (if parallel research needed)
 skill({ name: "swarm-coordination" });
+
+// For memory context
+skill({ name: "memory-system" });
 ```
 
 ## Delegation Strategy

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

@@ -13,6 +13,7 @@ You're picking up where a previous session left off. Recover context, verify sta
 ```typescript
 skill({ name: "beads" });
 skill({ name: "beads-bridge" }); // For cross-session recovery
+skill({ name: "memory-system" });
 ```
 
 ## Verify The Task Exists
@@ -78,21 +79,10 @@ Search for relevant observations and past work:
 
 ```typescript
 // Find observations related to this bead
-memory -
-  search({
-    query: "$ARGUMENTS [bead title/description]",
-    mode: "semantic",
-    type: "observation",
-    limit: 5,
-  });
+memory_search({ query: "$ARGUMENTS [bead title/description]", limit: 5 });
 
 // Find similar past work
-memory -
-  search({
-    query: "[bead description keywords]",
-    mode: "semantic",
-    limit: 3,
-  });
+memory_search({ query: "[bead description keywords]", limit: 3 });
 ```
 
 **Review findings** - past observations may contain:
@@ -183,11 +173,11 @@ bd update $ARGUMENTS --status in_progress
 
 Then continue with implementation:
 
-| Condition               | Command                                                  |
-| ----------------------- | -------------------------------------------------------- |
-| Swarm was restored      | Continue monitoring with `/implement $ARGUMENTS --swarm` |
-| No swarm, standard work | `/implement $ARGUMENTS`                                  |
-| Need to re-plan         | `/plan $ARGUMENTS`                                       |
+| Condition               | Command                                  |
+| ----------------------- | ---------------------------------------- |
+| Swarm was restored      | Continue with `/ship $ARGUMENTS --swarm` |
+| No swarm, standard work | `/ship $ARGUMENTS`                       |
+| Need to re-plan         | `/plan $ARGUMENTS`                       |
 
 ## If Context Is Too Stale
 

package/dist/template/.opencode/command/review-codebase.md

@@ -11,8 +11,23 @@ subtask: true
 
 ```typescript
 skill({ name: "beads" });
+skill({ name: "memory-system" });
 ```
 
+## Check Memory for Context
+
+Search for existing patterns and gotchas before review:
+
+```typescript
+// Find related past reviews and findings
+memory_search({ query: "[path/module] review security", limit: 3 });
+
+// Find known gotchas for this area
+memory_search({ query: "[module keywords] gotchas patterns", limit: 3 });
+```
+
+Apply past learnings to the review - don't repeat known issues.
+
 ## Phase 1: Determine Scope
 
 Parse `$ARGUMENTS` to determine what to review:
@@ -205,3 +220,18 @@ Skip creating beads for Minor issues (just report them).
 - Vague feedback ("improve error handling" - WHERE? HOW?)
 - Skipping automated checks "to save time"
 - Not creating beads for real issues (they get forgotten)
+
+## Record Significant Findings
+
+For important findings worth remembering:
+
+```typescript
+observation({
+  type: "warning", // or "pattern", "bugfix"
+  title: "[Module] [Issue type] pattern detected",
+  narrative: "Found [issue] in [location], which can cause...",
+  facts: "[key facts about the issue]",
+  concepts: "[module], security, [issue keywords]",
+  confidence: "high",
+});
+```

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

@@ -0,0 +1,199 @@
+---
+description: Ship a bead - implement, verify, review, close
+argument-hint: "<bead-id> [--parallel] [--swarm]"
+agent: build
+---
+
+# Ship: $ARGUMENTS
+
+This command combines implementation and finish gates. It implements, verifies, runs review, then closes.
+
+## Load Skills
+
+```typescript
+skill({ name: "beads" });
+skill({ name: "test-driven-development" });
+skill({ name: "verification-before-completion" });
+skill({ name: "finishing-a-development-branch" });
+skill({ name: "receiving-code-review" });
+skill({ name: "swarm-coordination" });
+skill({ name: "beads-bridge" });
+skill({ name: "memory-system" });
+```
+
+## Check Memory for Context
+
+Search for related patterns and gotchas before shipping:
+
+```typescript
+// Find related patterns and decisions
+memory_search({ query: "$ARGUMENTS [feature keywords]", limit: 3 });
+
+// Find gotchas for affected modules
+memory_search({ query: "[affected modules] gotchas", limit: 3 });
+```
+
+Apply past learnings to avoid known issues.
+
+## Skill Routing
+
+- Use **systematic-debugging** when a gate fails and root cause is unclear.
+- Use **receiving-code-review** to triage review feedback after the review agent runs.
+
+## Verify Task & Claim
+
+```bash
+bd show $ARGUMENTS
+bd update $ARGUMENTS --status in_progress
+```
+
+## Pre-Flight Verification
+
+Run `/verify $ARGUMENTS --quick` to check:
+
+- All spec requirements addressed
+- All gates passing
+- No obvious contradictions
+
+If verification fails, fix issues before proceeding.
+
+## Implement (Keep It Focused)
+
+- Read before edit
+- Delegate research if unclear (Task → explore/scout)
+- Keep scope ≤ 3 files or create subtasks
+
+If the task is large (3+ independent subtasks), use swarm mode.
+
+## Run Verification Gates
+
+Detect project type:
+
+```bash
+ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null
+```
+
+**Node/TypeScript:**
+
+```bash
+npm run build 2>/dev/null || true
+npm test
+npm run lint 2>/dev/null || true
+npm run typecheck 2>/dev/null || true
+```
+
+**Rust:**
+
+```bash
+cargo build
+cargo test
+cargo clippy -- -D warnings
+```
+
+**Python:**
+
+```bash
+pytest
+ruff check .
+mypy . 2>/dev/null || true
+```
+
+**Go:**
+
+```bash
+go build ./...
+go test ./...
+golangci-lint run
+```
+
+If ANY gate fails, stop and fix before proceeding.
+
+## Stage Changes For Review
+
+```bash
+git add -A
+git status
+git diff --cached --stat
+```
+
+## Spawn Review Agent (After Tests)
+
+```typescript
+Task({
+  subagent_type: "review",
+  description: "Review changes for $ARGUMENTS",
+  prompt: `Review the staged changes for bead $ARGUMENTS.
+
+Context:
+- Use git status and git diff --cached to see changes
+- Focus on correctness, edge cases, and risks
+- Report issues with file:line references
+
+Return:
+- Summary of findings
+- Critical/High/Medium issues (if any)
+`,
+});
+```
+
+If review finds issues, fix them, re-run verification gates, then re-run review.
+
+## Verify Success Criteria
+
+```bash
+cat .beads/artifacts/$ARGUMENTS/spec.md
+```
+
+Ensure all criteria are met before closing.
+
+## Close Bead (Ask First)
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Close",
+      question: "Ship complete. Close bead $ARGUMENTS?",
+      options: [
+        { label: "Yes, close it (Recommended)", description: "All gates passed" },
+        { label: "No, keep open", description: "Need more work" },
+      ],
+    },
+  ],
+});
+```
+
+If confirmed:
+
+```bash
+bd close $ARGUMENTS --reason "Shipped: verification + review passed"
+bd sync
+```
+
+## Record Learnings (On Completion)
+
+Before ending, capture what was learned:
+
+```typescript
+// Record significant decisions or patterns discovered
+observation({
+  type: "feature", // or "decision", "pattern"
+  title: "$ARGUMENTS: [brief description]",
+  narrative: "Implemented [feature]. Key approach: [summary]...",
+  facts: "[key implementation details]",
+  concepts: "[domain keywords], [tech stack]",
+  bead_id: "$ARGUMENTS",
+  files_modified: "[key files changed]",
+  confidence: "high",
+});
+
+// If encountered gotchas worth remembering
+observation({
+  type: "warning",
+  title: "[Gotcha discovered during $ARGUMENTS]",
+  narrative: "While implementing, discovered that...",
+  concepts: "[relevant keywords]",
+  bead_id: "$ARGUMENTS",
+  confidence: "high",
+});
+```