opencodekit 0.17.9 → 0.17.11

package/dist/index.js

@@ -759,7 +759,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "opencodekit",
-  version: "0.17.9",
+  version: "0.17.11",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   keywords: ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
   license: "MIT",
@@ -9244,21 +9244,21 @@ async function copyOpenCodeOnly(templateRoot, targetDir) {
 }
 var MODEL_PRESETS = {
   free: {
-    model: "opencode/kimi-k2.5-free",
+    model: "opencode/glm-5-free",
     agents: {
-      build: "opencode/kimi-k2.5-free",
-      plan: "opencode/kimi-k2.5-free",
+      build: "opencode/minimax-m2.5-free",
+      plan: "opencode/minimax-m2.5-free",
       review: "opencode/minimax-m2.5-free",
-      explore: "opencode/minimax-m2.5-free",
-      general: "opencode/minimax-m2.5-free",
-      looker: "opencode/kimi-k2.5-free",
-      vision: "opencode/kimi-k2.5-free",
-      scout: "opencode/minimax-m2.5-free",
-      painter: "opencode/kimi-k2.5-free"
+      explore: "opencode/glm-5-free",
+      general: "opencode/glm-5-free",
+      looker: "opencode/minimax-m2.5-free",
+      vision: "opencode/minimax-m2.5-free",
+      scout: "opencode/glm-5-free",
+      painter: "opencode/minimax-m2.5-free"
     }
   },
   recommend: {
-    model: "opencode/kimi-k2.5-free",
+    model: "opencode/minimax-m2.5-free",
     agents: {
       build: "github-copilot/claude-opus-4.6",
       plan: "openai/gpt-5.3-codex",
@@ -9266,7 +9266,7 @@ var MODEL_PRESETS = {
       explore: "proxypal/gemini-3-flash",
       general: "github-copilot/gpt-5.2-codex",
       looker: "proxypal/gemini-3-flash",
-      vision: "proxypal/gemini-3-pro-high",
+      vision: "proxypal/gemini-3.1-pro-high",
       scout: "proxypal/claude-sonnet-4-6",
       painter: "proxypal/gemini-3-pro-image"
     }

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

@@ -0,0 +1,143 @@
+---
+description: Extract and persist learnings from completed work into institutional memory
+argument-hint: "[bead-id]"
+---
+
+# Compound: $ARGUMENTS
+
+Capture what was learned. This is the flywheel step — each cycle makes the next cycle faster.
+
+> **Workflow:** `/plan` → `/ship` → `/review` → **`/compound`** → `/pr`
+>
+> Run after every completed task, review, or PR merge. The value compounds over time.
+
+## What This Does
+
+Extracts learnings from the just-completed work and stores them as structured observations in memory,
+so future Plan and Ship cycles start with institutional knowledge instead of blank slates.
+
+## Phase 1: Gather Evidence
+
+```bash
+# Get what changed
+git diff origin/main..HEAD --stat
+git log origin/main..HEAD --oneline
+
+# Get review comments if any
+br comments list $ARGUMENTS 2>/dev/null || echo "No bead"
+
+# Get bead context if provided
+br show $ARGUMENTS 2>/dev/null || echo "No bead specified"
+```
+
+Collect from all available sources:
+
+- Git diff (what files changed, what patterns were used)
+- Bead comments (review findings, decisions made)
+- Current session context (what was discovered, what was hard)
+- Any error messages that were solved
+
+## Phase 2: Classify Learnings
+
+For each finding, assign a type:
+
+| Type        | When to Use                                                | Example                                         |
+| ----------- | ---------------------------------------------------------- | ----------------------------------------------- |
+| `pattern`   | A reusable approach confirmed to work in this codebase     | "Always use X pattern for Y type of component"  |
+| `bugfix`    | A non-obvious bug and its root cause                       | "Bun doesn't support X, use Y instead"          |
+| `decision`  | An architectural or design choice with rationale           | "Chose JWT over sessions because..."            |
+| `gotcha`    | A footgun, constraint, or thing that looks wrong but isn't | "Don't modify dist/ directly, build overwrites" |
+| `discovery` | A non-obvious fact about the codebase or its dependencies  | "Build copies .opencode/ to dist/template/"     |
+| `warning`   | Something that will break if not followed                  | "Always run lint:fix before commit"             |
+
+**Quality bar:** Only record learnings that would save future-you 15+ minutes.
+Skip obvious things. Skip things already in AGENTS.md.
+
+## Phase 3: Store Observations
+
+For each learning worth keeping, create an observation:
+
+```typescript
+observation({
+  type: "pattern", // or bugfix, decision, gotcha, discovery, warning
+  title: "[Concise, searchable title — what someone would search for]",
+  narrative: "[What happened, why it matters, how to apply it]",
+  facts: "[comma, separated, key, facts]",
+  concepts: "[searchable, keywords, for, future, retrieval]",
+  files_modified: "[relevant/file.ts if applicable]",
+  confidence: "high", // high=verified, medium=likely, low=speculative
+});
+```
+
+**Minimum viable:** title + narrative. Everything else is bonus.
+
+## Phase 4: Check AGENTS.md / Skill Updates
+
+Ask: does this learning belong as a permanent rule?
+
+If YES (it's a codebase-level constraint everyone must follow):
+
+- Suggest updating `.opencode/memory/project/gotchas.md`
+- Or the relevant skill file if it's procedure-level
+
+If MAYBE (it's a pattern, not a rule):
+
+- The observation is sufficient
+- Don't pollute AGENTS.md with every finding
+
+**Rule:** AGENTS.md changes require user confirmation. Observations are automatic.
+
+## Phase 5: Search for Related Past Observations
+
+```typescript
+// Check if this updates or supersedes an older observation
+memory_search({ query: "[key concept from the finding]", limit: 3 });
+```
+
+If a newer finding contradicts or updates an older one, note it:
+
+```typescript
+observation({
+  type: "decision",
+  title: "...",
+  narrative: "...",
+  supersedes: "42", // ID of the older observation
+});
+```
+
+## Phase 6: Output Summary
+
+Report what was codified:
+
+```
+## Compound Summary
+
+**Work reviewed:** [brief description]
+**Learnings captured:** [N] observations
+
+| # | Type      | Title                        | Concepts               |
+|---|-----------|------------------------------|------------------------|
+| 1 | pattern   | ...                          | auth, jwt              |
+| 2 | gotcha    | ...                          | bun, build             |
+| 3 | bugfix    | ...                          | typecheck, strict-mode |
+
+**AGENTS.md updates suggested:** [yes/no - describe if yes]
+**Next recommended:** /pr  (or /plan <next-bead-id>)
+```
+
+## When Nothing to Compound
+
+If the work was trivial (a config change, 1-line fix with no surprises):
+
+> "Nothing worth compounding. Work was straightforward — no non-obvious patterns, bugs, or decisions encountered."
+
+Don't force observations. Quality over quantity.
+
+## Related Commands
+
+| Need                   | Command   |
+| ---------------------- | --------- |
+| Full chain             | `/lfg`    |
+| Review before compound | `/review` |
+| Ship the work          | `/ship`   |
+| Create PR              | `/pr`     |

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

@@ -0,0 +1,171 @@
+---
+description: Full autonomous chain - Plan → Ship → Review → Compound in one command
+argument-hint: "<bead-id> [--skip-plan]"
+---
+
+# LFG (Let's Fucking Go): $ARGUMENTS
+
+Full compound engineering cycle. One command, all four steps.
+
+> **When to use:** You have a bead in `in_progress` state with a PRD. You want maximum autonomous execution with minimum hand-holding.
+>
+> **Checkpoints happen** at decision points. Everything automatable is automated.
+
+## Parse Arguments
+
+| Argument      | Default  | Description                             |
+| ------------- | -------- | --------------------------------------- |
+| `<bead-id>`   | required | The bead to execute                     |
+| `--skip-plan` | false    | Skip planning if plan.md already exists |
+
+## Phase 0: Preflight
+
+```bash
+br show $BEAD_ID
+ls .beads/artifacts/$BEAD_ID/
+```
+
+Verify:
+
+- Bead exists and is `in_progress`
+- `prd.md` exists
+- If `plan.md` exists and `--skip-plan` not set: ask user whether to replan or use existing
+
+Report:
+
+```
+## LFG: <bead-id> — <title>
+
+Cycle: Plan → Ship → Review → Compound
+Review mode: [Standard 3-agent / Deep 5-agent]
+Plan: [create new / use existing]
+```
+
+## Step 1: PLAN
+
+Load and execute the `/plan` command for this bead:
+
+```typescript
+skill({ name: "writing-plans" });
+// Run full /plan flow including Phase 0 institutional research
+// Output: .beads/artifacts/$BEAD_ID/plan.md
+```
+
+Checkpoint if plan has major unknowns or architecture questions. Otherwise proceed automatically.
+
+## Step 2: WORK
+
+Execute the plan:
+
+```typescript
+skill({ name: "executing-plans" });
+// Load plan.md, execute wave-by-wave
+// Per-task commits after each task passes verification
+```
+
+Run verification after each wave:
+
+- `npm run typecheck`
+- `npm run lint`
+- `bun test` (if tests exist for changed areas)
+
+Checkpoint only at `checkpoint:human-verify` or `checkpoint:decision` tasks.
+
+## Step 3: REVIEW
+
+```bash
+BASE_SHA=$(git rev-parse origin/main 2>/dev/null || git rev-parse HEAD~$(git log --oneline | wc -l | tr -d ' '))
+HEAD_SHA=$(git rev-parse HEAD)
+```
+
+Load and run the review skill:
+
+```typescript
+skill({ name: "requesting-code-review" });
+```
+
+Dispatch 5 specialized agents in parallel.
+
+Wait for all agents to return. Synthesize findings.
+
+**Auto-fix rule:**
+
+- Critical issues → fix inline, re-verify, continue
+- Important issues → fix inline, continue
+- Minor issues → add to bead comments, continue
+
+If Critical issues cannot be auto-fixed:
+
+```
+## CHECKPOINT: Review Blocker
+
+Critical issue found that requires architectural decision:
+[description]
+
+Options:
+1. [option A]
+2. [option B]
+
+Awaiting your decision before continuing.
+```
+
+## Step 4: COMPOUND
+
+Load and run the compound command:
+
+```typescript
+// Run /compound $BEAD_ID
+// Extract learnings from the full cycle
+// Store observations to memory
+// Suggest AGENTS.md updates if conventions changed
+```
+
+## Step 5: Report & Next
+
+```
+## LFG Complete: <bead-id>
+
+### Cycle Summary
+
+| Step     | Status | Notes                        |
+|----------|--------|------------------------------|
+| Plan     | ✓      | [N] waves, [M] tasks         |
+| Work     | ✓      | [N] commits, [M] files       |
+| Review   | ✓      | [N] agents, [M] fixes        |
+| Compound | ✓      | [N] observations stored      |
+
+### Learnings Captured
+[list of observation titles]
+
+### Verification
+- typecheck: pass
+- lint: pass
+- tests: pass ([N] passing)
+
+### Next Steps
+- Review the changes: `git diff origin/main`
+- Create PR: `/pr`
+- Or continue with next bead: `/lfg <next-bead-id>`
+```
+
+## Swarm Mode (sLFG)
+
+For large plans with 6+ independent tasks, run Work step in swarm mode:
+
+```typescript
+skill({ name: "swarm-coordination" });
+// Dispatch parallel worker agents per wave
+// Leader monitors and synthesizes
+```
+
+Use when: plan has 2+ independent waves with no shared file mutations.
+
+## Related Commands
+
+| Need            | Command          |
+| --------------- | ---------------- |
+| Plan only       | `/plan <id>`     |
+| Ship only       | `/ship <id>`     |
+| Review only     | `/review`        |
+| Compound only   | `/compound <id>` |
+| Create PR after | `/pr`            |

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

@@ -36,6 +36,63 @@ skill({ name: "writing-plans" }); // TDD plan format
 - **Split signals**: Create child beads for complex work
 - **Vertical slices**: Each task should cover one feature end-to-end
 
+## Phase 0: Institutional Research (Mandatory)
+
+Before touching the PRD or planning anything, load what the codebase already knows.
+
+**This step is not optional.** Skipping it means planning in the dark.
+
+### Step 1: Search institutional memory
+
+```typescript
+// Search for past decisions, patterns, gotchas related to this work
+memory_search({ query: "<bead-title or feature keywords>", limit: 5 });
+memory_search({ query: "<key technical concept from bead>", type: "bugfix", limit: 3 });
+memory_read({ file: "handoffs/last" }); // Check last session context
+```
+
+If relevant observations found: incorporate them directly into the plan. Don't re-solve solved problems.
+
+### Step 2: Mine git history
+
+```bash
+# What has changed recently in affected areas?
+git log --oneline -20
+
+# Who wrote the relevant code and when?
+git log --oneline --follow -- <relevant-file-path>
+
+# What patterns appear in recent commits?
+git log --oneline --all | head -30
+```
+
+Look for:
+
+- Commit conventions (how this team names things)
+- Recent changes to files you'll touch (merge conflict risk)
+- How similar features were implemented before
+- Any "fix:", "revert:", "hotfix:" commits near your scope (footgun zones)
+
+### Step 3: Spawn learnings-researcher (if Level 2-3 work)
+
+```typescript
+task({
+  subagent_type: "explore",
+  description: "Search codebase for patterns related to this work",
+  prompt: `Search the codebase for patterns, conventions, and existing implementations related to: [FEATURE].
+
+  Run these searches:
+  - grep for relevant function names and patterns
+  - Find similar existing features
+  - Check test patterns for this domain
+  - Look for any TODO/FIXME comments in relevant files
+
+  Return: existing patterns to follow, files to be aware of, and any gotchas.`,
+});
+```
+
+**Only after completing Phase 0** do you proceed to planning. The research phases must use this context.
+
 ## Phase 1: Guards
 
 ```bash

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

@@ -58,6 +58,34 @@ ls .beads/artifacts/$ARGUMENTS/
 
 Read the PRD to extract goal and success criteria for the PR description.
 
+## Phase 2B: Pre-PR Review
+
+This is the last gate before code hits GitHub. Run it every time.
+
+Load the review skill:
+
+```typescript
+skill({ name: "requesting-code-review" });
+```
+
+Run **5 parallel agents**: security/correctness, performance/architecture, type-safety/tests, conventions/patterns, simplicity/completeness.
+
+```bash
+BASE_SHA=$(git rev-parse origin/main 2>/dev/null || git merge-base HEAD origin/main)
+HEAD_SHA=$(git rev-parse HEAD)
+```
+
+Fill placeholders:
+
+- `{WHAT_WAS_IMPLEMENTED}`: what this PR delivers (from git log summary)
+- `{PLAN_OR_REQUIREMENTS}`: PRD path or brief requirements
+- `{BASE_SHA}` / `{HEAD_SHA}`: from above
+
+**Gate rule:** All Critical issues must be resolved before pushing. No exceptions.
+Important issues: fix or document as known limitation in PR body.
+
+After fixing issues, re-run verification gates from Phase 1 if code was changed.
+
 ## Phase 3: Push and Confirm
 
 Show what will be pushed and ask the user:

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

@@ -245,31 +245,36 @@ If any gate fails, fix before proceeding.
 
 ## Phase 6: Review
 
-### 5A: Code Review
-
-Spawn review agent to check changes against the PRD:
+Load and run the review skill:
 
 ```typescript
-Task({
-  subagent_type: "review",
-  description: "Review changes for $ARGUMENTS",
-  prompt: `Review changes for bead $ARGUMENTS.
-
-Read PRD: .beads/artifacts/$ARGUMENTS/prd.md
-Review: git diff HEAD
+skill({ name: "requesting-code-review" });
+```
 
-Check:
-1. Changes satisfy PRD success criteria
-2. Correctness, edge cases, security
-3. No scope creep beyond PRD files
+Run **5 parallel agents**: security/correctness, performance/architecture, type-safety/tests, conventions/patterns, simplicity/completeness.
 
-Return: findings by severity, whether success criteria are met.`,
-});
+```bash
+BASE_SHA=$(git rev-parse origin/main 2>/dev/null || git rev-parse HEAD~1)
+HEAD_SHA=$(git rev-parse HEAD)
 ```
 
-If review finds critical issues → fix → re-run Phase 4 → re-review.
+Fill placeholders:
+
+- `{WHAT_WAS_IMPLEMENTED}`: bead title + brief summary of what changed
+- `{PLAN_OR_REQUIREMENTS}`: `.beads/artifacts/$ARGUMENTS/prd.md`
+- `{BASE_SHA}` / `{HEAD_SHA}`: from above
+
+Wait for all 5 agents to return. Synthesize findings.
+
+**Auto-fix rule:**
+
+- Critical issues → fix inline, re-run Phase 5 gates, continue
+- Important issues → fix inline, continue
+- Minor issues → add to bead comments, note for `/compound` step
+
+If review finds critical issues that require architectural decisions → stop → present options to user.
 
-### 5B: Goal-Backward Verification (if plan.md exists)
+### Goal-Backward Verification (if plan.md exists)
 
 Verify that tasks completed ≠ goals achieved:
 
@@ -328,7 +333,7 @@ br close $ARGUMENTS --reason "Shipped: all PRD tasks pass, verification + review
 br sync --flush-only
 ```
 
-Record significant learnings with `observation()`.
+Record significant learnings with `/compound $ARGUMENTS` after closing.
 
 ## Output
 

package/dist/template/.opencode/opencode.json

@@ -157,6 +157,10 @@
       "models": {
         "claude-haiku-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000,
             "type": "enabled"
@@ -181,6 +185,10 @@
         },
         "claude-opus-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000
           },
@@ -203,7 +211,7 @@
         "claude-opus-4.6": {
           "attachment": true,
           "limit": {
-            "context": 128000,
+            "context": 200000,
             "output": 64000
           },
           "options": {
@@ -248,8 +256,8 @@
         "claude-sonnet-4.6": {
           "attachment": true,
           "limit": {
-            "context": 128000,
-            "output": 32000
+            "context": 200000,
+            "output": 64000
           },
           "options": {
             "thinking": {
@@ -292,6 +300,10 @@
         },
         "claude-sonnet-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000
           },
@@ -313,6 +325,10 @@
         },
         "gpt-5.2": {
           "attachment": true,
+          "limit": {
+            "context": 400000,
+            "output": 128000
+          },
           "options": {
             "reasoningEffort": "medium",
             "reasoningSummary": "auto",
@@ -339,6 +355,10 @@
         },
         "gpt-5.2-codex": {
           "attachment": true,
+          "limit": {
+            "context": 400000,
+            "output": 128000
+          },
           "options": {
             "reasoningEffort": "medium",
             "reasoningSummary": "auto",
@@ -472,6 +492,37 @@
             "fast": {
               "disabled": true
             },
+            "xhigh": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "xhigh",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
+            "high": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "high",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
+            "medium": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "medium",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            }
+          }
+        },
+        "gpt-5.3-codex": {
+          "variants": {
+            "fast": {
+              "disabled": true
+            },
+            "xhigh": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "xhigh",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
             "high": {
               "include": ["reasoning.encrypted_content"],
               "reasoningEffort": "high",
@@ -498,47 +549,6 @@
             "top_p": 0.95
           },
           "reasoning": true
-        },
-        "kimi-k2.5-free": {
-          "limit": {
-            "context": 262144,
-            "output": 32768
-          },
-          "options": {
-            "interleaved": {
-              "field": "reasoning_content"
-            },
-            "thinking": {
-              "budgetTokens": 8192,
-              "reasoning_effort": "high",
-              "type": "enabled"
-            }
-          },
-          "reasoning": true,
-          "temperature": true,
-          "tool_call": true,
-          "variants": {
-            "high": {
-              "interleaved": {
-                "field": "reasoning_content"
-              },
-              "options": {
-                "reasoning_effort": "high",
-                "thinkingBudget": 16384,
-                "type": "enabled"
-              }
-            },
-            "max": {
-              "interleaved": {
-                "field": "reasoning_content"
-              },
-              "options": {
-                "reasoning_effort": "high",
-                "thinkingBudget": 32768,
-                "type": "enabled"
-              }
-            }
-          }
         }
       }
     },

package/dist/template/.opencode/package.json

@@ -11,7 +11,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.2.6"
+    "@opencode-ai/plugin": "1.2.10"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",