opencodekit 0.12.1 → 0.12.3

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

@@ -1,337 +1,167 @@
 ---
-description: Finish a bead - hard gates, commit, close
+description: Finish a bead - verify, commit, close
 argument-hint: "<bead-id>"
 agent: build
 ---
 
-# Finish
+# Finish: $ARGUMENTS
 
-**Load skills:**
+You're closing out a task. This is the quality gate. No shortcuts.
+
+## Load Skills
 
 ```typescript
-skill({ name: "beads" }); // Session protocol
+skill({ name: "beads" });
 skill({ name: "verification-before-completion" });
-skill({ name: "finishing-a-development-branch" });
 ```
 
-## Phase 1: Load Bead & Check Messages
+## Verify The Task Exists
 
-```typescript
-bd_show({ id: "$ARGUMENTS" });
-bd_inbox({ n: 5, unread: true, global: false });
+```bash
+bd show $ARGUMENTS
 ```
 
-Review any messages about this bead before proceeding.
+If not found, stop. Check `bd list --status=all` for the correct ID.
 
-Verify status is `in-progress` or `open`.
+## Run All Gates
 
-## Phase 2: Detect Project Type
-
-Check which project files exist to determine verification commands:
+Detect your project type and run everything:
 
 ```bash
-ls package.json Cargo.toml pyproject.toml setup.py Makefile go.mod 2>/dev/null || true
+ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null
 ```
 
-| Project Type       | Build            | Test            | Lint                          |
-| ------------------ | ---------------- | --------------- | ----------------------------- |
-| Node.js/TypeScript | `npm run build`  | `npm test`      | `npm run lint && type-check`  |
-| Rust               | `cargo build`    | `cargo test`    | `cargo clippy -- -D warnings` |
-| Python             | -                | `pytest`        | `ruff check . && mypy .`      |
-| Go                 | `go build ./...` | `go test ./...` | `golangci-lint run`           |
-| Make-based         | `make build`     | `make test`     | `make lint`                   |
-
-Check if each command actually exists before running.
-
-## Phase 3: Hard Gates (MUST ALL PASS)
-
-Run detected verification commands. Skip any that don't exist.
+**Node/TypeScript:**
 
+```bash
+npm run build 2>/dev/null || true
+npm test
+npm run lint 2>/dev/null || true
+npm run type-check 2>/dev/null || true
 ```
-Finish Gates: <bead-id>
-━━━━━━━━━━━━━━━━━━━━━━
 
-Project: [detected type]
+**Rust:**
 
-Build:      [✓/✗/skipped]
-Tests:      [✓/✗/skipped]
-Lint:       [✓/✗/skipped]
-Type check: [✓/✗/skipped]
+```bash
+cargo build
+cargo test
+cargo clippy -- -D warnings
 ```
 
-**If ANY gate fails: STOP.**
-
-```
-Cannot finish: [gate name] failed.
+**Python:**
 
-Fix errors and run /finish again.
+```bash
+pytest
+ruff check .
+mypy . 2>/dev/null || true
 ```
 
-Do not proceed. Do not offer workarounds.
-
-## Phase 4: Verify Success Criteria
-
-Read spec:
+**Go:**
 
 ```bash
-cat .beads/artifacts/<bead-id>/spec.md
+go build ./...
+go test ./...
+golangci-lint run
 ```
 
-Check each success criterion with its verification command:
-
-```
-Success Criteria:
-━━━━━━━━━━━━━━━━
-
-- [x] [Criterion 1]
-      Verify: `[command]` ✓
-- [x] [Criterion 2]
-      Verify: `[command]` ✓
-- [ ] [Criterion 3] - NOT MET
-      Verify: `[command]` ✗
-      Reason: [what failed]
-```
+If ANY gate fails, stop. Fix it first. Don't close broken work.
 
-**If any criterion not met: STOP.**
+## Verify Success Criteria
 
-```
-Cannot finish: Success criteria not met.
+Read the spec and check each criterion:
 
-Missing:
-- [Criterion] - [what's needed]
+```bash
+cat .beads/artifacts/$ARGUMENTS/spec.md
 ```
 
-## Phase 5: Verify ADR (for L/XL tasks)
+For each success criterion listed, run its verification. All must pass. If something's missing, go back and implement it.
 
-Check if spec indicated L/XL complexity:
+## Commit Everything
 
 ```bash
-cat .beads/artifacts/<bead-id>/adr.md 2>/dev/null || echo "No ADR"
-```
-
-For L/XL tasks, ADR should exist documenting the design decision.
+git add -A
+git status
+git commit -m "$ARGUMENTS: [what was done]
 
-If missing and was L/XL: Warn but don't block.
+- [change 1]
+- [change 2]
 
-## Phase 6: Calculate Estimation Accuracy
+Closes: $ARGUMENTS"
+```
 
-Extract estimate from spec/plan and compare to actual:
+## Close The Task
 
+```typescript
+bd_done({ id: "$ARGUMENTS", msg: "Completed: [1-line summary]" });
 ```
-Estimation Accuracy:
-━━━━━━━━━━━━━━━━━━━
 
-Estimated: [S/M/L] (~[N] tool calls)
-Actual: [N] tool calls
-Variance: [+/-N%] ([over/under]estimated)
-```
+This closes the task, releases any file locks, and syncs with git. Task is done.
 
-**Learning signals:**
+## Create Review (Optional But Recommended)
 
-- > 50% over: Task was harder than expected. Document why in review.
-- > 50% under: Task was easier. Consider if similar tasks should be estimated lower.
-- Within 20%: Good estimate. Pattern worth remembering.
+If this was non-trivial work, document what happened:
 
-## Phase 7: Create Review
+```bash
+mkdir -p .beads/artifacts/$ARGUMENTS
+```
 
-Write `.beads/artifacts/<bead-id>/review.md`:
+Write `.beads/artifacts/$ARGUMENTS/review.md`:
 
 ```markdown
-# Review: [Title]
-
-**Bead:** <bead-id>
-**Completed:** <date>
-
-## Estimation Accuracy
+# Review: $ARGUMENTS
 
-| Metric    | Value                |
-| --------- | -------------------- |
-| Estimated | [S/M/L] (~[N] calls) |
-| Actual    | [N] calls            |
-| Variance  | [+/-N%]              |
+**Completed:** [date]
 
-**Why variance?** [If significant, explain]
+## What Changed
 
-## Changes Made
-
-| File         | Change        |
-| ------------ | ------------- |
-| `src/foo.ts` | [description] |
-| `src/bar.ts` | [description] |
+- [file]: [what and why]
 
 ## What Worked
 
-- [Thing that went well]
-
-## What Was Difficult
-
-- [Challenge encountered and how resolved]
-
-## What Was Skipped
-
-- [Thing intentionally not done and why]
+- [thing that went smoothly]
 
-## Lessons Learned
+## What Was Hard
 
-- [Pattern worth documenting]
-- [Gotcha to remember]
+- [challenge and how you solved it]
 
-## Test Coverage
+## Lessons
 
-- [New tests added]
-- [Existing tests modified]
-
-## Success Criteria
-
-- [x] [Criterion 1]
-- [x] [Criterion 2]
+- [anything worth remembering]
 ```
 
-## Phase 8: Create Observation (if notable findings)
+## Record Learnings
 
-If you discovered something worth remembering:
+If you discovered patterns or gotchas worth remembering:
 
 ```typescript
 observation({
-  type: "learning", // or: decision, bugfix, pattern, discovery, warning
+  type: "learning",
   title: "[concise title]",
-  content: "[what was learned and why it matters]",
-  concepts: "[keywords]",
-  files: "[affected files]",
-  bead_id: "<bead-id>",
-});
-```
-
-**Create observations for:**
-
-- Patterns that should be reused
-- Gotchas that wasted time
-- Design decisions with rationale
-- Bug root causes
-
-## Phase 9: Update Memory (if applicable)
-
-If patterns or gotchas discovered:
-
-```typescript
-// For new patterns
-memory -
-  update({
-    file: "project/conventions",
-    content: "## [Pattern Name]\n\n[Description and example]",
-    mode: "append",
-  });
-
-// For gotchas
-memory -
-  update({
-    file: "project/gotchas",
-    content: "## [Gotcha Title]\n\n[What happened and how to avoid]",
-    mode: "append",
-  });
-```
-
-## Phase 10: Final Commit
-
-```bash
-git add -A
-git status
-```
-
-Commit with bead reference:
-
-```bash
-git commit -m "<bead-id>: [summary of changes]
-
-- [bullet 1]
-- [bullet 2]
-
-Closes: <bead-id>"
-```
-
-## Phase 11: Close Bead & Notify
-
-Complete the task:
-
-```typescript
-bd_done({ id: "$ARGUMENTS", msg: "Implemented: [1-liner summary]" });
-```
-
-Notify dependent tasks are now unblocked:
-
-```typescript
-bd_msg({
-  subj: "<bead-id> completed",
-  body: "Dependent tasks now unblocked. Summary: [1-liner]",
-  to: "all",
-  importance: "normal",
-  global: true,
+  content: "[what you learned]",
+  bead_id: "$ARGUMENTS",
 });
 ```
 
-## Phase 12: Database Health Check
-
-```typescript
-bd_ls({ status: "all", limit: 1 });
-```
-
-| Issue Count | Action                                       |
-| ----------- | -------------------------------------------- |
-| >200        | Warn about performance                       |
-| >500        | Strongly recommend `bd_cleanup({ days: 7 })` |
-
 ## Output
 
 ```
-Bead Closed: <bead-id>
-━━━━━━━━━━━━━━━━━━━━━
-
-Gates: All passed ✓
-Criteria: All met ✓
-Commit: [commit hash]
-
-Estimation:
-- Estimated: [S/M/L] (~[N] calls)
-- Actual: [N] calls
-- Accuracy: [good/over/under]
-
-Artifacts:
-- .beads/artifacts/<bead-id>/spec.md
-- .beads/artifacts/<bead-id>/review.md
-[- .beads/artifacts/<bead-id>/research.md]
-[- .beads/artifacts/<bead-id>/plan.md]
-[- .beads/artifacts/<bead-id>/adr.md]
-
-Branch: <bead-id>
-```
+Closed: $ARGUMENTS
 
-**Next steps:**
+Gates: All passed
+Commit: [hash]
+Branch: [branch]
 
+Next:
+- /pr $ARGUMENTS  # Create pull request
+- Or merge directly: git checkout main && git merge $ARGUMENTS
 ```
-━━━━━━━━━━━━━━━━━━━━━
 
-Ready to merge:
-  /pr <bead-id>           # Create pull request
-  git checkout main && git merge <bead-id>  # Direct merge
-
-Or start fresh:
-  → Start new session for next task
-  → Previous work: read_session("last")
-```
+## If Work Is Incomplete
 
-**If issue count >200:**
+Don't close incomplete work. Instead:
 
 ```
-⚠️  Database has [count] issues. Run:
-    bd_cleanup({ days: 7 })
-    bd_sync({ reason: "Cleanup after finish" })
+/handoff $ARGUMENTS "Stopped at [step]. Remaining: [what's left]"
 ```
 
-**If work was incomplete:**
-
-```
-⚠️  Work incomplete? Create handoff:
-    /handoff <bead-id> "Resume: [what's left]"
-
-Next session: /resume <bead-id>
-```
+Then start fresh session and `/resume $ARGUMENTS` later.