opencodekit 0.21.10 → 0.23.0

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

@@ -1,31 +1,46 @@
 ---
-description: Initialize core project setup (AGENTS.md + tech-stack detection only)
-argument-hint: "[--deep]"
+description: Initialize project setup — AGENTS.md, planning context, user profile, and tech stack
+argument-hint: "[--deep] [--context|--user|--all]"
 agent: build
 ---
 
 # Init: $ARGUMENTS
 
-Core project setup. Creates AGENTS.md and detects tech stack. Run once per project.
+Initialize project setup. Run once per project. Supports three modes via argument flags.
 
-> **Next steps:** `/init-user` for personalization, `/init-context` for GSD planning workflow
+> **Next step for fresh projects:** `/plan` to create first implementation plan.  
+> **Next step for brownfield:** `/review-codebase` for deep codebase analysis.
 
 ## Load Skills
 
 ```typescript
-skill({ name: "index-knowledge" });
+skill({ name: "brainstorming" });
+skill({ name: "verification-before-completion" });
 ```
 
-## Options
+## Parse Arguments
 
-| Argument | Default | Description                               |
-| -------- | ------- | ----------------------------------------- |
-| `--deep` | false   | Comprehensive research (~100+ tool calls) |
+| Argument | Default | Description |
+|---|---|---|
+| `--deep` | false | Comprehensive research for AGENTS.md (~100+ tool calls) |
+| `--context` | false | Init planning context (roadmap, state) |
+| `--user` | false | Init user profile |
+| `--all` | false | Full init: AGENTS.md + context + user profile |
 
-## Phase 1: Detect Project
+**Mode rules:**
+- No flags (default): Core project setup — AGENTS.md + tech stack only
+- `--context`: Planning context (roadmap.md, state.md)
+- `--user`: User profile (user.md)
+- `--all`: Everything
+- `--deep` applies to AGENTS.md generation only
 
-Detect and validate:
+---
+
+## Mode 1: Core Setup (Default)
 
+### Phase 1: Detect Project
+
+Detect and validate:
 - Package manager and dependencies (with versions)
 - Build, test, lint, dev commands — **validate each actually works**
 - CI/CD configuration
@@ -34,82 +49,84 @@ Detect and validate:
 
 With `--deep`: Also analyze git history, source patterns, subsystem candidates.
 
-## Phase 2: Preview Detection
+### Phase 2: Preview Detection
 
-After detecting project, show summary and ask for confirmation:
+Show detected summary and ask for confirmation before writing.
 
-```typescript
-question({
-  questions: [
-    {
-      header: "Preview",
-      question: `Detected: ${detectedTechStack}. Create AGENTS.md?`,
-      options: [
-        { label: "Yes, create it (Recommended)" },
-        { label: "Show me what you'll write first" },
-        { label: "Cancel" },
-      ],
-    },
-  ],
-});
-```
+### Phase 3: Create AGENTS.md
+
+Create `./AGENTS.md` — target <60 lines (max 150). Include:
+- Tech stack with versions, file structure, validated commands
+- Code example from actual codebase
+- Testing conventions, boundaries, gotchas
+
+**Principles:** Examples > explanations. Pointers > copies. If AGENTS.md exists, improve it — don't overwrite blindly.
 
-**If "Show me":** Display detected values without writing files, then ask again.
+### Phase 4: Create tech-stack.md
 
-## Phase 3: Create AGENTS.md
+Write detected values to `.opencode/memory/project/tech-stack.md`. Persist with memory update.
 
-Create `./AGENTS.md` — **target <60 lines** (max 150). Follow the `index-knowledge` skill format:
+---
+
+## Mode 2: Planning Context (`--context`)
+
+Initialize project planning context with roadmap and state files.
 
-- Tech stack with versions
-- File structure
-- Commands (validated)
-- Code example from actual codebase (5-10 lines)
-- Testing conventions
-- Boundaries (always/ask-first/never)
-- Gotchas
+### Phase 1: Discovery
 
-**Principles**: Examples > explanations. Pointers > copies. If AGENTS.md exists, improve it — don't overwrite blindly.
+If `--brownfield` (detected from existing codebase), run parallel codebase analysis:
+- `explore` for architecture patterns
+- `explore` for data flow
+- `explore` for domain boundaries
 
-## Phase 4: Create tech-stack.md
+If greenfield, skip to requirements gathering.
 
-From template `.opencode/memory/_templates/tech-stack.md`:
+### Phase 2: Requirements Gathering
 
-Read the template from `.opencode/memory/_templates/tech-stack.md` and write it to `.opencode/memory/project/tech-stack.md`.
+Ask questions to define:
+- Project vision and goals (1-2 sentences each)
+- Target users and their needs
+- Core features (what must exist)
+- Technical constraints
+- Success criteria
 
-Fill detected values:
+### Phase 3: Create Files
 
-- Framework, language, runtime
-- Styling, components, design system
-- Database, ORM, state management
-- Testing tools
-- Verification commands
+- `.opencode/memory/project/roadmap.md` — vision, goals, user personas, feature roadmap, constraints, success criteria
+- `.opencode/memory/project/state.md` — current status, active decisions, known issues, next priorities
+- Update `.opencode/opencode.json` instructions to include roadmap.md and state.md
+
+---
 
-## Phase 5: Subsystems (--deep only)
+## Mode 3: User Profile (`--user`)
 
-Identify candidates for nested AGENTS.md:
+Create personalized user profile at `.opencode/memory/project/user.md`.
 
-- `packages/*/` in monorepos
-- `frontend/` vs `backend/` directories
-- Significantly different subsystem patterns
+### Phase 1: Gather Preferences
 
-Ask user before creating nested files.
+Ask questions about:
+- **Identity**: Name, role, experience level
+- **Communication**: Verbosity preference, feedback style, update frequency
+- **Workflow**: Branch strategy, commit style, review expectations, test expectations
+- **Technical**: Preferred tools, avoided patterns, dev environment
 
-## Phase 6: Verify and Report
+### Phase 2: Create user.md
 
-Verify:
+Write to `.opencode/memory/project/user.md` with the captured preferences.
 
-- [ ] AGENTS.md is <60 lines (or justified)
-- [ ] Commands validated and work
-- [ ] Boundaries include Never rules
-- [ ] Code example from actual codebase
-- [ ] tech-stack.md created
+### Phase 3: Update opencode.json
+
+Ensure user.md is in `instructions[]` as one of the 4 auto-injected files (user.md, tech-stack.md, project.md, git-context.md).
+
+> **Warning:** Do not add more files to `instructions[]` unless essential. Per-prompt injection of too many files causes session OOM. Use `memory-search({ file: "..." })` for on-demand access.
+
+---
 
-Output:
+## Output
 
-1. Files created (with line counts)
-2. Tech stack detected
-3. Commands validated (yes/no)
-4. Suggested next steps:
-   - `/init-user` — Create user profile
-   - `/init-context` — Set up GSD planning workflow
-   - `/review-codebase` — Deep codebase analysis
+Report what was created:
+1. AGENTS.md (if core setup ran)
+2. tech-stack.md (if core setup ran)
+3. roadmap.md + state.md (if `--context`)
+4. user.md (if `--user`)
+5. Recommended next command: `/plan`, `/review-codebase`, or `/resume`

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

@@ -1,41 +1,27 @@
 ---
-description: Create detailed implementation plan with TDD steps for a bead
-argument-hint: "<bead-id> [--create-beads]"
+description: Create detailed implementation plan with TDD steps
 agent: plan
 ---
 
-# Plan: $ARGUMENTS
+# Plan
 
 Create a detailed implementation plan with TDD steps. Optional deep-planning between `/create` and `/ship`.
 
-> **Workflow:** `/create` → **`/plan <id>`** (optional) → `/ship <id>`
+> **Workflow:** `/create` → **`/plan`** (optional) → `/ship`
 >
-> Bead MUST be `in_progress` with `prd.md`. Use `/create` first.
->
-> **When to use:** Complex tasks where PRD verification steps aren't enough guidance. Skip for simple tasks.
-
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "memory-grounding" });
-skill({ name: "writing-plans" }); // TDD plan format
-// For user-facing UI work: skill({ name: "ux-quality-gates" });
-```
+> **When to use:** Complex tasks where spec verification steps aren't enough guidance. Skip for simple tasks.
 
 ## Parse Arguments
 
-| Argument         | Default  | Description                       |
-| ---------------- | -------- | --------------------------------- |
-| `<bead-id>`      | required | The bead to plan                  |
-| `--create-beads` | false    | Create child beads for each phase |
+| Argument | Default  | Description                       |
+| -------- | -------- | --------------------------------- |
+| none     | —        | Plan based on current spec        |
 
 ## Before You Plan
 
 - **Be certain**: Only create tasks you're confident about
-- **Don't over-plan**: If the PRD is clear, trust it
+- **Don't over-plan**: If the spec is clear, trust it
 - **Budget context**: Target ~50% context per execution
-- **Split signals**: Create child beads for complex work
 - **Vertical slices**: Each task should cover one feature end-to-end
 
 ## Phase 0: Institutional Research (Mandatory)
@@ -46,7 +32,7 @@ Before touching the PRD or planning anything, load what the codebase already kno
 
 ### Step 1: Search institutional memory
 
-Follow the [memory-grounding](../skill/memory-grounding/SKILL.md) skill protocol. Focus on: bugfixes, existing plans (ask user before overwriting).
+Search memory for: bugfixes, existing plans (ask user before overwriting).
 
 If relevant observations found: incorporate them directly into the plan. Don't re-solve solved problems.
 
@@ -92,17 +78,10 @@ task({
 
 ## Phase 1: Guards
 
-```bash
-br show $ARGUMENTS
-```
-
-Read `.beads/artifacts/$ARGUMENTS/` to check what artifacts exist.
-
 Verify:
 
-- Bead is `in_progress`
-- `prd.md` exists
-- If `plan.md` already exists, ask user: overwrite or skip?
+- `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` exists (if not, tell user to run `/create` first)
+- If `.opencode/artifacts/$(cat .opencode/artifacts/.active)/plan.md` already exists, ask user: overwrite or skip?
 
 ## Phase 2: Discovery Assessment
 
@@ -243,7 +222,7 @@ Assess size to determine plan structure:
 | ------------- | --------- | ---------------------------------------- |
 | S (1-3 files) | 2-4 tasks | Single plan, no phases                   |
 | M (3-8 files) | 5-8 tasks | 2-3 phases                               |
-| L (8+ files)  | 9+ tasks  | Create child beads with `--create-beads` |
+| L (8+ files)  | 9+ tasks  | Split into separate plans for each subsystem |
 
 ## Phase 6: Dependency Graph & Wave Assignment
 
@@ -272,14 +251,14 @@ Wave 3: C (depends on B)
 
 ## Phase 7: Write Plan
 
-Write `.beads/artifacts/$ARGUMENTS/plan.md` following the `writing-plans` skill format:
+Write `.opencode/artifacts/$(cat .opencode/artifacts/.active)/plan.md`:
 
 ### Required Plan Header
 
 ```markdown
 # [Feature] Implementation Plan
 
-> **For Claude:** REQUIRED SUB-SKILL: Use skill({ name: "executing-plans" }) to implement this plan task-by-task.
+> **For Claude:** Implement this plan task-by-task.
 
 **Goal:** [Outcome-shaped goal from PRD]
 
@@ -361,15 +340,18 @@ Scan `plan.md` content for these patterns:
 ### Check Process
 
 ```bash
+ACTIVE_SLUG=$(cat .opencode/artifacts/.active 2>/dev/null)
+if [ -z "$ACTIVE_SLUG" ]; then echo "No active feature."; exit 1; fi
+ARTIFACT_DIR=".opencode/artifacts/$ACTIVE_SLUG"
 # Scan plan for violation patterns (fixed-string mode to avoid regex false positives)
-grep -inF "git add ." .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF "git add -A" .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF -- "--no-verify" .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF "force push" .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF -- "--force" .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF "reset --hard" .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF "checkout ." .beads/artifacts/$ARGUMENTS/plan.md
-grep -inF "clean -fd" .beads/artifacts/$ARGUMENTS/plan.md
+grep -inF "git add ." "$ARTIFACT_DIR/plan.md"
+grep -inF "git add -A" "$ARTIFACT_DIR/plan.md"
+grep -inF -- "--no-verify" "$ARTIFACT_DIR/plan.md"
+grep -inF "force push" "$ARTIFACT_DIR/plan.md"
+grep -inF -- "--force" "$ARTIFACT_DIR/plan.md"
+grep -inF "reset --hard" "$ARTIFACT_DIR/plan.md"
+grep -inF "checkout ." "$ARTIFACT_DIR/plan.md"
+grep -inF "clean -fd" "$ARTIFACT_DIR/plan.md"
 ```
 
 Also check:
@@ -400,16 +382,7 @@ If violations found:
 Violations resolved. Plan is compliant.
 ```
 
-## Phase 9: Create Child Beads (if --create-beads or L size)
-
-For large work, create child beads for each plan phase:
-
-```bash
-CHILD=$(br create "[Phase title]" --type task --json | jq -r '.id')
-br dep add $CHILD $ARGUMENTS
-```
-
-## Phase 10: Report
+## Phase 9: Report
 
 Output:
 
@@ -419,18 +392,15 @@ Output:
 4. **Dependency Waves:** [N] waves for parallel execution
 5. **Task count:** [N] tasks, [M] TDD steps
 6. **Files affected:** [List]
-7. **Plan location:** `.beads/artifacts/$ARGUMENTS/plan.md`
-8. **Child bead hierarchy:** (if created)
-9. **Next step:** `/ship $ARGUMENTS`
+7. **Plan location:** `.opencode/artifacts/$(cat .opencode/artifacts/.active)/plan.md`
+8. **Next step:** `/ship`
 
-```bash
-br comments add $ARGUMENTS "Created plan.md: Level [N] discovery, [X] waves, [Y] tasks, [Z] TDD steps"
-```
+---
 
 ## Related Commands
 
 | Need           | Command      |
 | -------------- | ------------ |
 | Create spec    | `/create`    |
-| Execute plan   | `/ship <id>` |
+| Execute plan   | `/ship`      |
 | Research first | `/research`  |

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

@@ -1,6 +1,6 @@
 ---
-description: Create and submit pull request with bead traceability
-argument-hint: "[bead-id] [--draft]"
+description: Create and submit a pull request
+argument-hint: "[--draft]"
 agent: build
 ---
 
@@ -9,18 +9,14 @@ agent: build
 ## Load Skills
 
 ```typescript
-skill({ name: "beads" });
-skill({ name: "memory-grounding" });
-skill({ name: "verification-gates" });
 skill({ name: "verification-before-completion" });
 ```
 
 ## Parse Arguments
 
-| Argument    | Default  | Description        |
-| ----------- | -------- | ------------------ |
-| `<bead-id>` | optional | Link PR to bead    |
-| `--draft`   | false    | Create as draft PR |
+| Argument  | Default | Description        |
+| --------- | ------- | ------------------ |
+| `--draft` | false   | Create as draft PR |
 
 ## Phase 1: Pre-PR Verification
 
@@ -30,7 +26,7 @@ git status --porcelain
 
 If uncommitted changes exist, ask whether to commit first.
 
-Follow the [verification-gates](../skill/verification-gates/SKILL.md) skill protocol. All gates must pass before creating the PR.
+All gates must pass before creating the PR.
 
 Check `package.json` scripts, `Makefile`, or `justfile` for project-specific commands first — prefer those over generic defaults.
 
@@ -40,7 +36,7 @@ If any gate fails, stop. Fix errors first, then run `/pr` again.
 
 ### Memory Grounding
 
-Follow the [memory-grounding](../skill/memory-grounding/SKILL.md) skill protocol. Include relevant findings in the PR description.
+Search memory for relevant findings to include in the PR description.
 
 ### Git Context
 
@@ -50,27 +46,13 @@ git log main...HEAD --oneline
 git diff main...HEAD --stat
 ```
 
-If bead ID provided:
-
-```bash
-br show $ARGUMENTS
-```
-
-Read `.beads/artifacts/$ARGUMENTS/` to check what artifacts exist.
-
-Read the PRD to extract goal and success criteria for the PR description.
+Read `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` 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.
+Run **5 parallel agents** for review: 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)
@@ -147,7 +129,7 @@ EOF
 
 If `--draft`, add `--draft` flag.
 
-If bead ID provided, add artifacts section linking to `.beads/artifacts/$ARGUMENTS/prd.md`.
+Add a link to `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` for requirements context.
 
 ## Output
 

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

@@ -0,0 +1,65 @@
+---
+description: Refactor code for clarity, performance, or maintainability
+argument-hint: "<file or path> [--scope minimal|moderate|aggressive]"
+agent: build
+---
+
+# Refactor: $ARGUMENTS
+
+Improve code quality without changing external behavior.
+
+## Load Skills
+
+```typescript
+skill({ name: "verification-before-completion" });
+```
+
+## Parse Arguments
+
+| Argument | Default | Description |
+|---|---|---|
+| `<file or path>` | required | File or directory to refactor |
+| `--scope` | minimal | `minimal` (rename/restructure), `moderate` (extract modules), `aggressive` (redesign) |
+
+## When to Refactor
+
+- Module has grown beyond its original purpose
+- Tests are hard to write because of tight coupling
+- Similar logic appears in multiple places
+- Files have crossed 300+ lines with unclear boundaries
+
+## Process
+
+### Phase 1: Assess
+
+1. Read all files in scope
+2. Identify: duplication, shallow interfaces, unclear naming, mixed concerns
+3. Plan the refactor — show plan if >3 files would change
+
+### Phase 2: Lock Behavior
+
+- If the module has tests, they must still pass after refactor
+- If no tests exist, run existing verification (typecheck, lint)
+- No behavior changes in a refactor — external API must be preserved
+
+### Phase 3: Execute
+
+- One change at a time, verify after each
+- Prefer small commits with clear messages
+- `refactor(scope): what changed`
+
+### Phase 4: Verify
+
+```bash
+npm run typecheck
+npm run lint
+npm test
+```
+
+## Output
+
+Report:
+1. What changed and why
+2. Files modified
+3. Verification results
+4. What was left for future refactors

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

@@ -1,6 +1,6 @@
 ---
-description: Research a topic or bead before implementation
-argument-hint: "<topic-or-bead-id> [--quick|--thorough]"
+description: Research a topic before implementation
+argument-hint: "<topic> [--quick|--thorough]"
 agent: scout
 ---
 
@@ -10,39 +10,23 @@ Gather information before implementation. Find answers, document findings, stop
 
 > Research can happen at any phase when you need external information or codebase understanding.
 
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "memory-grounding" });
-// For --thorough mode:
-skill({ name: "deep-research" });
-```
-
 ## Parse Arguments
 
 | Argument         | Default  | Description                         |
 | ---------------- | -------- | ----------------------------------- |
-| Topic or bead ID | required | What to research                    |
+| Topic            | required | What to research                    |
 | `--quick`        | false    | ~10 tool calls, single question     |
 | `--thorough`     | false    | ~100+ calls, comprehensive analysis |
 
 Default depth: ~30 tool calls for moderate exploration.
 
-## Determine Input Type
-
-| Input Type | Detection                   | Action                            |
-| ---------- | --------------------------- | --------------------------------- |
-| Bead ID    | Matches `br-xxx` or numeric | Research within that bead context |
-| Topic      | String                      | Standalone research               |
-
 ## Before You Research
 
 - **Be certain**: Only research what you need for implementation
 - **Don't over-research**: Stop when you have enough to proceed
 - **Use source priority**: Codebase → Docs → Source → GitHub → Web
 - **Verify confidence**: Medium+ confidence required before stopping
-- **Document findings**: Write to research.md for beads, report for topics
+- **Document findings**: Write to `.opencode/artifacts/$(cat .opencode/artifacts/.active)/research.md` or report directly
 
 ## Available Tools
 
@@ -57,17 +41,11 @@ Default depth: ~30 tool calls for moderate exploration.
 
 ## Phase 1: Load Context
 
-If argument is a bead ID:
-
-```bash
-br show $ARGUMENTS
-```
-
-Read PRD if it exists and extract questions that need answering.
+Read `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` if it exists and extract questions that need answering.
 
 ### Memory Search (Required)
 
-Follow the [memory-grounding](../skill/memory-grounding/SKILL.md) skill protocol. Use findings to: skip already-answered questions, narrow scope to gaps only, avoid contradicting prior decisions without justification.
+Search memory for existing findings. Use them to: skip already-answered questions, narrow scope to gaps only, avoid contradicting prior decisions without justification.
 
 ## Phase 2: Research
 
@@ -102,7 +80,7 @@ Follow the [memory-grounding](../skill/memory-grounding/SKILL.md) skill protocol
 
 ## Phase 4: Document
 
-Write findings to `.beads/artifacts/$ARGUMENTS/research.md` (if bead) or report directly (if topic):
+Write findings to `.opencode/artifacts/$(cat .opencode/artifacts/.active)/research.md` (if plan exists) or report directly (if topic):
 
 - Questions asked → answered/partial/unanswered with confidence
 - Key findings with sources (file paths, docs)

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

@@ -1,19 +1,11 @@
 ---
 description: Review code for quality, security, and compliance
-argument-hint: "[path|bead-id|pr-number|'all'] [--quick|--thorough]"
+argument-hint: "[path|pr-number|'all'] [--quick|--thorough]"
 agent: review
 ---
 
 # Review: $ARGUMENTS
 
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "requesting-code-review" });
-skill({ name: "verification-gates" });
-```
-
 ## Determine Input Type
 
 | Input Type            | Detection                    | Action                     |
@@ -22,6 +14,7 @@ skill({ name: "verification-gates" });
 | Commit hash (40-char) | SHA pattern                  | `git show <hash>`          |
 | Branch name           | String, not matching above   | `git diff main...HEAD`     |
 | PR URL/number         | Contains "github.com" or "#" | `gh pr diff`               |
+| Current plan          | `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md`    | Review against spec        |
 
 ## Before You Review
 
@@ -54,22 +47,22 @@ For each changed file:
 - Read the full file to understand context
 - Don't rely on diff alone — code that looks wrong in isolation may be correct
 
-If bead provided, read `.beads/artifacts/$ID/prd.md` to review against spec.
+If plan exists, read `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` to review against spec.
 
 ## Phase 2: Determine Scope
 
 | Input                    | Scope                 | How to Get Code           |
 | ------------------------ | --------------------- | ------------------------- |
 | File/directory path      | That path only        | `read` or `glob` + `read` |
-| Bead ID (e.g., `br-123`) | Implementation vs PRD | `br show` then `git diff` |
+| Current plan             | Implementation vs spec | Read `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` then `git diff` |
 | PR number (e.g., `#45`)  | PR changes            | `gh pr diff 45`           |
 | `all` or empty           | Recent changes        | `git diff main...HEAD`    |
 
-If bead provided, read `.beads/artifacts/$ID/prd.md` to review against spec.
+If plan exists, read `.opencode/artifacts/$(cat .opencode/artifacts/.active)/spec.md` to review against spec.
 
 ## Phase 3: Automated Checks
 
-Follow the [verification-gates](../skill/verification-gates/SKILL.md) skill protocol.
+Use the `verification-before-completion` skill to run gates.
 
 Check `package.json` scripts, `Makefile`, or `justfile` for project-specific commands first — prefer those over generic defaults.