opencodekit 0.13.0 → 0.13.2

package/README.md

@@ -251,10 +251,10 @@ You've successfully set up OpenCodeKit when:
 
 ---
 
-**OpenCodeKit v0.13.0**  
+**OpenCodeKit v0.13.2**  
 **Architecture**: Two-layer (Memory + Beads + Git)  
 **Package**: `npx opencodekit` to scaffold new projects  
-**New in v0.13.0**: Codex-inspired session continuity, compaction-safe context, UNCONFIRMED markers  
+**New in v0.13.2**: Multimodal support for gemini-claude models (image, PDF input)  
 **Ready for**: Daily production use
 
 Enjoy your streamlined agent system with clean phase transitions!

package/dist/index.js

@@ -750,7 +750,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "opencodekit",
-  version: "0.13.0",
+  version: "0.13.2",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   type: "module",
   repository: {

package/dist/template/.opencode/README.md

@@ -330,8 +330,8 @@ fi
 
 ---
 
-**OpenCodeKit v0.13.0**  
+**OpenCodeKit v0.13.2**  
 **Architecture:** Two-Layer (Memory + Beads + Git)  
-**New in v0.13.0:** Codex-inspired session continuity, compaction-safe context, UNCONFIRMED markers  
+**New in v0.13.2:** Multimodal support for gemini-claude models (image, PDF input)  
 **Package:** `npx opencodekit` to scaffold new projects  
 **Last Updated:** January 8, 2026

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

@@ -1,14 +1,21 @@
 ---
-description: Implement a bead - load context, make changes, verify
-argument-hint: "<bead-id>"
+description: Implement a bead - load context, delegate research, make changes, verify
+argument-hint: "<bead-id> [--parallel]"
 agent: build
 ---
 
 # Implement: $ARGUMENTS
 
-You're implementing a tracked task. Stay focused, verify as you go, hand off if you hit limits.
+You're implementing a tracked task. Stay focused, delegate research, verify as you go, hand off if you hit limits.
 
-## First: Load Context
+## Parse Arguments
+
+| Argument     | Default  | Description                               |
+| ------------ | -------- | ----------------------------------------- |
+| `<bead-id>`  | required | The bead to implement                     |
+| `--parallel` | false    | Run aggressive parallel subagent research |
+
+## First: Load Skills & Context
 
 ```typescript
 skill({ name: "beads" });
@@ -16,27 +23,54 @@ skill({ name: "test-driven-development" });
 skill({ name: "verification-before-completion" });
 ```
 
-Get the task details and check for messages:
+Get the task details and check hierarchy:
 
+```bash
+bd show $ARGUMENTS
+bd dep tree $ARGUMENTS 2>/dev/null || echo "No dependencies"
+bd list --status=in_progress  # See what else is active
 ```
-!`bd show $ARGUMENTS`
-!`bd list --status=in_progress`  # See what else is active
+
+Check for messages from other agents:
+
+```typescript
+bd - inbox({ n: 5, unread: true });
 ```
 
-Check git state. If dirty, ask whether to stash, commit, or continue:
+## Check Hierarchy Position
+
+Identify where this task sits:
+
+| Type      | Action                                      |
+| --------- | ------------------------------------------- |
+| `epic`    | Don't implement directly - work on subtasks |
+| `task`    | May implement or delegate to subtasks       |
+| `subtask` | Implement directly - this is leaf work      |
 
+**If this is an epic with subtasks:**
+
+```bash
+bd ready --json | grep -q "$ARGUMENTS"
 ```
-!`git status --porcelain`
-!`git branch --show-current`
+
+→ Work on ready subtasks instead: `/implement <subtask-id>`
+
+## Git State Check
+
+```bash
+git status --porcelain
+git branch --show-current
 ```
 
+If dirty, ask whether to stash, commit, or continue.
+
 Create a branch if not already on one for this task:
 
 ```bash
-git checkout -b $ARGUMENTS
+git checkout -b $ARGUMENTS 2>/dev/null || echo "Already on branch"
 ```
 
-Mark the task in progress:
+Mark the task in progress (if not already):
 
 ```bash
 bd update $ARGUMENTS --status in_progress
@@ -46,59 +80,163 @@ bd update $ARGUMENTS --status in_progress
 
 Check what context exists:
 
-```
-!`ls .beads/artifacts/$ARGUMENTS/ 2>/dev/null || echo "No artifacts"`
+```bash
+ls .beads/artifacts/$ARGUMENTS/ 2>/dev/null || echo "No artifacts"
 ```
 
-If `plan.md` exists, follow it step by step. If only `spec.md` exists, implement directly from requirements. If nothing exists, work from the bead description.
+| Found         | Action                               |
+| ------------- | ------------------------------------ |
+| `plan.md`     | Follow it step by step               |
+| `spec.md`     | Implement directly from requirements |
+| `research.md` | Use findings to guide implementation |
+| Nothing       | Work from bead description           |
 
 Check for previous session work:
 
 ```typescript
-list_sessions({ project: "current", limit: 3 });
-read_session({ session_reference: "last", project: "current" });
+search_session({ query: "$ARGUMENTS" });
+read_session({ session_reference: "last" });
+```
+
+## Parallel Subagent Research (if --parallel or complex task)
+
+**Delegation Pattern: Fire and Continue**
+
+For complex tasks, launch research subagents in parallel before diving into code:
+
+```typescript
+// Codebase patterns - find similar implementations
+Task({
+  subagent_type: "explore",
+  prompt: `For implementing $ARGUMENTS, find:
+    1. Similar patterns in this codebase (grep/ast-grep)
+    2. Related test files and testing patterns
+    3. Configuration or setup requirements
+    Return: File paths, code patterns, test approach`,
+  description: "Explore patterns for implementation",
+});
+
+// External best practices - library docs
+Task({
+  subagent_type: "scout",
+  prompt: `Research best practices for $ARGUMENTS:
+    1. Official documentation for libraries involved
+    2. Common implementation patterns (Context7, GitHub)
+    3. Known pitfalls or gotchas
+    Return: Code examples, API usage, warnings`,
+  description: "Scout external docs",
+});
+
+// Continue working immediately - don't wait for results
 ```
 
+**Subagent Rules:**
+| Agent | Use For | Can Do | Cannot Do |
+| -------- | ------------------------------ | ---------------- | ---------------- |
+| `explore`| Codebase search, patterns | Read, grep, glob | Edit, bd sync |
+| `scout` | External docs, best practices | Fetch, search | Edit, bd sync |
+| `review` | Code review, debugging | Read, analyze | Edit, bd sync |
+| `planner`| Architecture, decomposition | Read, plan | Edit, bd sync |
+
+**You (build agent) are the leader:**
+
+- Subagents return results to you
+- Only you modify files and update beads
+- Integrate subagent findings into your implementation
+
 ## Estimate Your Budget
 
 Look at the task complexity and set limits:
 
-- **Small** (~10 tool calls): Simple change, one file, clear path
-- **Medium** (~30 tool calls): Multiple files, some exploration needed
-- **Large** (~100 tool calls): Cross-cutting, needs research, checkpoint often
-- **XL**: Should be decomposed into smaller tasks first
+| Size   | Tool Calls | Scope                               |
+| ------ | ---------- | ----------------------------------- |
+| Small  | ~10        | Simple change, one file, clear path |
+| Medium | ~30        | Multiple files, some exploration    |
+| Large  | ~100       | Cross-cutting, needs checkpoints    |
+| XL     | Stop       | Decompose into subtasks first       |
+
+**If XL detected:**
+
+```
+This task is too large for a single session.
+Recommend: /plan $ARGUMENTS --create-beads
+```
 
-If you hit 80% of budget without finishing, create a handoff. Don't push past limits and produce garbage.
+If you hit 80% of budget without finishing, create a handoff. Don't push past limits.
+
+## Lock Files Before Editing
+
+For shared files or multi-agent coordination:
+
+```typescript
+bd - reserve({ paths: ["src/file-to-edit.ts"], ttl: 600 });
+```
+
+Release after completing edits:
+
+```typescript
+bd - release({ paths: ["src/file-to-edit.ts"] });
+```
 
 ## Do The Work
 
 Detect project type and know your verification commands:
 
-```
-!`ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null`
+```bash
+ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null
 ```
 
-Node/TypeScript: `npm test`, `npm run lint && npm run type-check`
-Rust: `cargo test`, `cargo clippy -- -D warnings`
-Python: `pytest`, `ruff check . && mypy .`
-Go: `go test ./...`, `golangci-lint run`
+| Project | Test Command    | Lint Command                        |
+| ------- | --------------- | ----------------------------------- |
+| Node/TS | `npm test`      | `npm run lint && npm run typecheck` |
+| Rust    | `cargo test`    | `cargo clippy -- -D warnings`       |
+| Python  | `pytest`        | `ruff check . && mypy .`            |
+| Go      | `go test ./...` | `golangci-lint run`                 |
 
 **Rules while implementing:**
 
-1. Read before edit. Always.
-2. Run verification after each logical change
-3. If something fails 3 times, stop and try a different approach
-4. Checkpoint commit after significant progress: `git commit -m "WIP: $ARGUMENTS - [step]"`
-5. If blocked on external dependency, create a new bead for it and move on
+1. **Read before edit.** Always.
+2. **Run verification** after each logical change
+3. **Delegate when stuck**: If blocked on understanding, launch `@explore` or `@scout`
+4. **Checkpoint** after significant progress: `git commit -m "WIP: $ARGUMENTS - [step]"`
+5. **Create child beads** for discovered subtasks:
+   ```bash
+   bd create "Discovered: [subtask]" -t subtask -p 2
+   bd dep add <new-id> $ARGUMENTS --type blocks
+   ```
+
+**Progress tracking** - every 10 tool calls:
 
-Track your progress. Every 10 tool calls, check: Am I on track? Should I checkpoint? Am I approaching budget?
+- Am I on track?
+- Should I checkpoint?
+- Am I approaching budget?
+- Need to delegate research?
+
+## Subtask Coordination (if parent task)
+
+If implementing a task with subtasks:
+
+```bash
+# Check which subtasks are ready
+bd ready --json | jq '.[] | select(.parent == "$ARGUMENTS")'
+
+# Work on ready subtasks in order
+# When subtask done:
+bd close <subtask-id> --reason "Completed: description"
+
+# Check if parent can close
+bd dep tree $ARGUMENTS
+```
+
+**Pattern: Complete subtasks before parent**
 
 ## Before Claiming Done
 
 Verify against success criteria in the spec:
 
-```
-!`cat .beads/artifacts/$ARGUMENTS/spec.md | grep -A 20 "Success Criteria"`
+```bash
+cat .beads/artifacts/$ARGUMENTS/spec.md | grep -A 20 "Success Criteria" || \
+cat .beads/artifacts/$ARGUMENTS/spec.md | grep -A 20 "Acceptance Criteria"
 ```
 
 Run each verification command. All must pass. No exceptions.
@@ -107,7 +245,7 @@ Run the full test suite one more time:
 
 ```bash
 # Whatever your project uses
-npm test && npm run type-check
+npm test && npm run typecheck
 ```
 
 ## Complete
@@ -126,9 +264,12 @@ git diff --cached --stat
 Implementation Complete: $ARGUMENTS
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
+Type: [epic/task/subtask]
 Tests: Pass ✓
 Changes: [files modified]
 
+Subtasks: [N completed / M total] (if applicable)
+
 Would you like me to:
 1. Commit these changes
 2. Show full diff first
@@ -144,10 +285,17 @@ git commit -m "$ARGUMENTS: [summary]"
 bd sync
 ```
 
-Suggest next step:
+Suggest next step based on hierarchy:
+
+| Situation            | Next Command                |
+| -------------------- | --------------------------- |
+| Subtask done         | `/implement <next-subtask>` |
+| All subtasks done    | `/finish <parent-task>`     |
+| Task done, no parent | `/finish $ARGUMENTS`        |
+| Need PR              | `/pr $ARGUMENTS`            |
 
 ```
-Next: /finish $ARGUMENTS
+Next: [recommended command]
 ```
 
 If gates fail, fix them. Don't proceed with broken code.
@@ -161,3 +309,11 @@ Hit budget limit or context getting too large? Create a handoff:
 ```
 
 Then start a fresh session. Don't grind past diminishing returns.
+
+## Release File Locks
+
+Before ending session:
+
+```typescript
+bd - release({ _: true }); // List and release all locks
+```