opencodekit 0.17.10 → 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.10",
+  version: "0.17.11",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   keywords: ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
   license: "MIT",

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/skill/requesting-code-review/SKILL.md

@@ -1,115 +1,202 @@
 ---
 name: requesting-code-review
-description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements - dispatches review subagent to review implementation against plan or requirements before proceeding
+description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements - dispatches 5 parallel specialized review agents for comprehensive multi-angle review
 ---
 
 # Requesting Code Review
 
-Dispatch review subagent to catch issues before they cascade.
+Dispatch 5 parallel specialized review agents. One generic reviewer is not review — it's a checkbox.
 
-**Core principle:** Review early, review often.
+**Core principle:** All 5 angles, every time. No tiers, no exit ramps.
 
 ## When to Request Review
 
 **Mandatory:**
 
-- After each task in subagent-driven development
-- After completing major feature
+- After completing a feature / task batch before moving to next
 - Before merge to main
 
-**Optional but valuable:**
+**Not a review use case:**
 
-- When stuck (fresh perspective)
-- Before refactoring (baseline check)
-- After fixing complex bug
+- When stuck on an approach → ask one agent a specific question directly
+- TDD RED commits (failing test commits are supposed to fail — don't review non-shippable state)
 
 ## How to Request
 
-**1. Get git SHAs:**
+### Step 1: Get git context
 
 ```bash
-BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
+BASE_SHA=$(git rev-parse origin/main 2>/dev/null || git rev-parse HEAD~1)
 HEAD_SHA=$(git rev-parse HEAD)
 ```
 
-**2. Dispatch review subagent:**
+### Step 2: Dispatch all 5 agents in parallel
 
-Use Task tool with review agent type, fill template at `review.md`
+No tiering. 5 agents always. They run simultaneously — wall-clock cost is the same as 1.
 
-**Placeholders:**
+```typescript
+task({
+  subagent_type: "review",
+  description: "Security + correctness review",
+  prompt: `Review this implementation for security vulnerabilities and correctness issues.
 
-- `{WHAT_WAS_IMPLEMENTED}` - What you just built
-- `{PLAN_OR_REQUIREMENTS}` - What it should do
-- `{BASE_SHA}` - Starting commit
-- `{HEAD_SHA}` - Ending commit
-- `{DESCRIPTION}` - Brief summary
+What was implemented: {WHAT_WAS_IMPLEMENTED}
+Requirements: {PLAN_OR_REQUIREMENTS}
 
-**3. Act on feedback:**
+Run:
+  git diff {BASE_SHA}..{HEAD_SHA}
 
-- Fix Critical issues immediately
-- Fix Important issues before proceeding
-- Note Minor issues for later
-- Push back if reviewer is wrong (with reasoning)
+Check for:
+- Security vulnerabilities (injection, auth bypass, secrets exposure, input validation)
+- Logic errors, off-by-one, null/undefined access
+- Missing error handling on async operations
+- Data integrity issues
 
-## Example
+Return: CRITICAL / IMPORTANT / MINOR findings with file:line references.`,
+});
 
-```
-[Just completed Task 2: Add verification function]
+task({
+  subagent_type: "review",
+  description: "Performance + architecture review",
+  prompt: `Review this implementation for performance and architectural concerns.
 
-You: Let me request code review before proceeding.
+What was implemented: {WHAT_WAS_IMPLEMENTED}
 
-BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
-HEAD_SHA=$(git rev-parse HEAD)
+Run:
+  git diff {BASE_SHA}..{HEAD_SHA}
+
+Check for:
+- N+1 queries, unnecessary loops, missing indexes
+- Over-engineering (abstraction not earned by use cases)
+- Coupling that will make future changes painful
+- Missing caching where obviously needed
+- Bundle size regressions (if frontend)
+
+Return: CRITICAL / IMPORTANT / MINOR findings with file:line references.`,
+});
+
+task({
+  subagent_type: "review",
+  description: "Type safety + test coverage review",
+  prompt: `Review this implementation for type safety and test quality.
+
+What was implemented: {WHAT_WAS_IMPLEMENTED}
+
+Run:
+  git diff {BASE_SHA}..{HEAD_SHA}
+
+Check for:
+- Type safety holes (any casts, unsafe assertions, missing generics)
+- Tests that only test mocks instead of real behavior
+- Missing edge case tests (null, empty, boundary values)
+- Tests that would pass even if the implementation was wrong
+- Coverage gaps on critical paths
+
+Return: CRITICAL / IMPORTANT / MINOR findings with file:line references.`,
+});
+
+task({
+  subagent_type: "review",
+  description: "Conventions + patterns review",
+  prompt: `Review this implementation against codebase conventions.
+
+What was implemented: {WHAT_WAS_IMPLEMENTED}
+
+Run:
+  git diff {BASE_SHA}..{HEAD_SHA}
+  git log --oneline -10
+
+Check for:
+- Inconsistent naming vs rest of codebase
+- Patterns that diverge from established codebase patterns
+- Missing or wrong use of shared utilities already in the codebase
+- File organization that doesn't match project structure
+- Documentation drift (code does X, docs say Y)
+
+Return: CRITICAL / IMPORTANT / MINOR findings with file:line references.`,
+});
+
+task({
+  subagent_type: "review",
+  description: "Simplicity + completeness review",
+  prompt: `Review this implementation for simplicity and completeness.
 
-[Dispatch review subagent]
-  WHAT_WAS_IMPLEMENTED: Verification and repair functions for conversation index
-  PLAN_OR_REQUIREMENTS: Task 2 from docs/plans/deployment-plan.md
-  BASE_SHA: a7981ec
-  HEAD_SHA: 3df7661
-  DESCRIPTION: Added verifyIndex() and repairIndex() with 4 issue types
-
-[Subagent returns]:
-  Strengths: Clean architecture, real tests
-  Issues:
-    Important: Missing progress indicators
-    Minor: Magic number (100) for reporting interval
-  Assessment: Ready to proceed
-
-You: [Fix progress indicators]
-[Continue to Task 3]
+What was implemented: {WHAT_WAS_IMPLEMENTED}
+Requirements: {PLAN_OR_REQUIREMENTS}
+
+Run:
+  git diff {BASE_SHA}..{HEAD_SHA}
+
+Check for:
+- Dead code (unreachable branches, unused variables, commented-out code)
+- Requirements that were specified but not implemented
+- Complexity that could be deleted without losing value
+- TODOs left in production code paths
+
+Return: CRITICAL / IMPORTANT / MINOR findings with file:line references.`,
+});
 ```
 
-## Integration with Workflows
+### Step 3: Synthesize findings
 
-**Subagent-Driven Development:**
+After all 5 agents return:
 
-- Review after EACH task
-- Catch issues before they compound
-- Fix before moving to next task
+```markdown
+## Review Summary
 
-**Executing Plans:**
+**Agents run:** 5
+**Critical:** [N] — BLOCK, fix before proceeding
+**Important:** [N] — Fix in this PR
+**Minor:** [N] — Track as improvements
 
-- Review after each batch (3 tasks)
-- Get feedback, apply, continue
+### Critical Issues
 
-**Ad-Hoc Development:**
+[List with file:line, description, suggested fix]
 
-- Review before merge
-- Review when stuck
+### Important Issues
+
+[List with file:line, description]
+
+### Assessment
+
+[ ] Ready to proceed [ ] Fix required first
+```
+
+### Step 4: Act on findings
+
+| Severity      | Action                                   |
+| ------------- | ---------------------------------------- |
+| **Critical**  | Fix immediately before any other work    |
+| **Important** | Fix in this PR before merge              |
+| **Minor**     | Note in bead comments, fix later or skip |
+
+Push back if reviewer is wrong — show code/tests that prove it works.
+
+## Placeholders Reference
+
+| Placeholder              | What to fill                            |
+| ------------------------ | --------------------------------------- |
+| `{WHAT_WAS_IMPLEMENTED}` | Brief description of the feature/fix    |
+| `{PLAN_OR_REQUIREMENTS}` | Link to plan.md or requirements summary |
+| `{BASE_SHA}`             | Starting commit SHA                     |
+| `{HEAD_SHA}`             | Ending commit SHA                       |
+
+## Integration with Workflows
 
-## Red Flags
+| Command | When review runs                      |
+| ------- | ------------------------------------- |
+| `/ship` | After all tasks complete + gates pass |
+| `/pr`   | Mandatory gate before push to GitHub  |
+| `/lfg`  | Between work and compound steps       |
 
-**Never:**
+All Critical issues must be resolved before proceeding. No exceptions.
 
-- Skip review because "it's simple"
-- Ignore Critical issues
-- Proceed with unfixed Important issues
-- Argue with valid technical feedback
+## After Review: Compound
 
-**If reviewer wrong:**
+Run `/compound` after fixing review findings to capture:
 
-- Push back with technical reasoning
-- Show code/tests that prove it works
-- Request clarification
+- What the review caught (patterns to watch for)
+- What false positives were dismissed (and why)
+- Any codebase conventions discovered during review
 
-See template at: requesting-code-review/review.md
+This is how the review step feeds the compound flywheel.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.17.10",
+	"version": "0.17.11",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",