opencode-bonfire 0.9.6

package/files/agent/work-reviewer.md

@@ -0,0 +1,130 @@
+---
+description: Strategic code review for blindspots, gaps, and improvements
+mode: subagent
+hidden: true
+model: anthropic/claude-sonnet-4-20250514
+maxSteps: 30
+tools:
+  write: false
+  edit: false
+  todowrite: false
+  todoread: false
+permission:
+  task:
+    "*": deny
+---
+
+You are a senior code reviewer focused on strategic quality, not nitpicks. Your job is to find what the developer might have missed.
+
+## Input
+
+You'll receive:
+1. **Review scope** - Branch diff, specific files, or session context
+2. **Intent** - What was the developer trying to accomplish
+3. **Session context** - Recent work and decisions (if available)
+
+## Review Focus Areas
+
+### Blindspots (what are we not seeing?)
+- Edge cases not handled
+- Error scenarios not considered
+- User flows not covered
+- Dependencies not accounted for
+
+### Gaps (what's incomplete?)
+- Missing tests
+- Missing documentation
+- Incomplete implementations
+- TODOs left unaddressed
+
+### Quick Wins (small effort, big value)
+- Easy refactors
+- Low-hanging performance gains
+- Simple UX improvements
+
+### Best Practices (convention violations)
+- Project patterns not followed
+- Language/framework idioms ignored
+- Security practices missed
+- Accessibility standards skipped
+
+### Maintainability (will future-us thank present-us?)
+- Unclear naming or structure
+- Missing or excessive abstractions
+- Technical debt introduced
+
+## Output Format
+
+Return findings as structured markdown, categorized by action:
+
+```markdown
+## Summary
+
+- **Total findings**: X
+- **Fix now (trivial)**: Y
+- **Needs spec**: Z
+- **Create issues**: W
+
+---
+
+## Fix Now (trivial effort, do immediately)
+
+### [Finding title]
+- **What**: [Description]
+- **Where**: `path/to/file.ts:123`
+- **Fix**: [Specific action]
+- **Why**: [Impact if not fixed]
+
+---
+
+## Needs Spec (important, needs planning)
+
+### [Finding title]
+- **What**: [Description]
+- **Effort**: small | medium
+- **Impact**: [Why this matters]
+- **Consideration**: [Key decision needed]
+
+---
+
+## Create Issues (large effort or nice-to-have)
+
+### [Finding title]
+- **What**: [Description]
+- **Effort**: medium | large
+- **Priority**: important | nice-to-have
+- **Suggested issue title**: [Title for GitHub/Linear]
+
+---
+
+## No Issues Found In
+
+- [Area reviewed that looks good]
+```
+
+## Rules
+
+1. **Strategic, not pedantic** - Skip style nitpicks, focus on substance
+2. **Consider intent** - Review against what they were trying to do
+3. **Categorize by action** - Fix now vs spec vs issue
+4. **Estimate effort** - trivial/small/medium/large
+5. **Be specific** - Include file paths and line numbers
+6. **Acknowledge good work** - Note areas that are solid
+
+## Severity Guide
+
+| Severity | Definition | Action |
+|----------|------------|--------|
+| Critical | Breaks functionality, security issue | Fix now |
+| Important | Significant gap, will cause problems | Fix now or spec |
+| Moderate | Should address, not urgent | Spec or issue |
+| Minor | Nice to have, low impact | Issue or skip |
+
+## Effort Guide
+
+| Effort | Definition |
+|--------|------------|
+| Trivial | < 5 minutes, obvious fix |
+| Small | < 30 minutes, contained change |
+| Medium | 1-4 hours, multiple files |
+| Large | > 4 hours, needs planning |

package/files/command/bonfire-archive.md

@@ -0,0 +1,128 @@
+---
+description: Archive completed session work
+---
+
+# Archive Session
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Review Completed Work
+
+Read `<git-root>/.bonfire/index.md` and identify completed work:
+- Sessions with merged PRs
+- Completed features/tasks
+- Work that's no longer active
+
+## Step 3: Create Archive Entry
+
+Move completed session content to `<git-root>/.bonfire/archive/`.
+
+**Naming convention**: `YYYY-MM-DD-<issue-id>-<topic>.md`
+
+Examples:
+- `2025-12-22-GTMENG-387-inbound-improvements.md` (with issue ID)
+- `2025-12-22-fix-login-redirect.md` (without issue ID)
+
+Use this template:
+```markdown
+# [TOPIC]
+
+**Date**: [DATE]
+**Issue**: [ISSUE-ID or N/A]
+**PR**: [PR link if available]
+**Status**: Completed
+
+---
+
+## Summary
+
+[Brief description of what was accomplished]
+
+## Accomplished
+
+- [List of completed items]
+
+## Decisions Made
+
+- [Key decisions and rationale]
+
+## Impact
+
+- [Before/after metrics if applicable]
+- Files changed: [count]
+
+## Related
+
+- [Links to related docs, specs, or code]
+```
+
+## Step 4: Clean Up Index
+
+Update `<git-root>/.bonfire/index.md`:
+- Remove archived session entries from Recent Sessions
+- Keep Current State focused on active work
+- Update Next Session Priorities
+- Add link to archive file in Archived Sessions section:
+  ```markdown
+  ## Archived Sessions
+
+  - [YYYY-MM-DD - Topic](archive/YYYY-MM-DD-issue-topic.md)
+  ```
+
+## Step 5: Clean Up Specs (if applicable)
+
+Read `specsLocation` from `<git-root>/.bonfire/config.json` (default `.bonfire/specs/`).
+
+Check if any specs in the configured location are now complete:
+- If the spec was fully implemented, delete the spec file (archive has the record)
+- If the spec has reusable reference material, move that content to `docs/` first
+
+## Step 6: Update Linear Issue (if applicable)
+
+Read `<git-root>/.bonfire/config.json` and check `linearEnabled`.
+
+**If `linearEnabled` is true**:
+
+1. Check if archived work references a Linear issue (look in session context for `[A-Z]+-[0-9]+` pattern)
+2. If Linear issue found, ask user: "Mark Linear issue [ISSUE-ID] as Done?"
+3. If user confirms:
+   - Use linear-cli to update the issue:
+     ```bash
+     linear issue update ENG-123 --state "Done"
+     ```
+   - Optionally add a comment with link to archive/PR:
+     ```bash
+     linear issue comment add ENG-123 -b "Archived: [link]"
+     ```
+4. On failure: Warn user - "Couldn't update Linear issue. You may need to update it manually."
+
+Note: Run `linear issue update --help` to see available options.
+
+**If `linearEnabled` is false or not set**: Skip this step.
+
+## Step 7: Commit Archive (if tracked)
+
+Read `gitStrategy` from `<git-root>/.bonfire/config.json`.
+
+**If gitStrategy is "ignore-all"**: Skip committing - archive is local only.
+
+**If gitStrategy is "hybrid" or "commit-all"**:
+1. **NEVER use `git add -f`** - respect gitignore
+2. Stage unignored files:
+   ```bash
+   git add .bonfire/
+   ```
+3. Check if anything was staged before committing:
+   ```bash
+   git diff --cached --quiet .bonfire/ || git commit -m "docs: archive completed session work"
+   ```
+
+## Step 8: Confirm
+
+Report:
+- What was archived
+- Any specs cleaned up
+- Current state of index.md
+- Ready for next session

package/files/command/bonfire-configure.md

@@ -0,0 +1,96 @@
+---
+description: Change project settings (locations, git strategy, Linear)
+---
+
+# Configure Bonfire
+
+Always runs interactively - asks all configuration questions regardless of arguments.
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Check for Bonfire Directory
+
+If `<git-root>/.bonfire/` does not exist, tell the user to run `/bonfire-start` first.
+
+## Step 3: Read Current Config
+
+Read `<git-root>/.bonfire/config.json` if it exists to see current settings.
+
+## Step 4: Ask All Configuration Questions
+
+Use the question tool to ask configuration questions (4 questions, one round):
+
+1. "Where should specs be saved?" (Header: "Specs")
+   - .bonfire/specs/ (Default) - Keep with session context
+   - specs/ - Project root level
+
+2. "Where should docs be saved?" (Header: "Docs")
+   - .bonfire/docs/ (Default) - Keep with session context
+   - docs/ - Project root level
+
+3. "How should `.bonfire/` be handled in git?" (Header: "Git")
+   - ignore-all (Default) - Keep sessions private/local
+   - hybrid - Commit docs/specs, keep notes private
+   - commit-all - Share everything with team
+
+4. "Enable Linear integration?" (Header: "Linear")
+   - No (Default) - Skip Linear integration
+   - Yes - Fetch/create Linear issues (requires linear-cli)
+
+## Step 5: Update Config
+
+**Completely overwrite** `<git-root>/.bonfire/config.json` with only these fields (do not preserve old fields like `models`):
+
+```json
+{
+  "specsLocation": "<user-answer>",
+  "docsLocation": "<user-answer>",
+  "gitStrategy": "<user-answer>",
+  "linearEnabled": <true-or-false>
+}
+```
+
+## Step 6: Update Git Strategy
+
+If git strategy or locations changed, update `<git-root>/.bonfire/.gitignore`:
+
+**Ignore all**:
+```
+*
+!.gitignore
+```
+
+**Hybrid** (only include dirs that are inside .bonfire/):
+```
+*
+!.gitignore
+```
+If docsLocation is `.bonfire/docs/`, add:
+```
+!docs/
+!docs/**
+```
+If specsLocation is `.bonfire/specs/`, add:
+```
+!specs/
+!specs/**
+```
+
+**Commit all**:
+```
+data/
+scratch/
+```
+
+If switching FROM commit/hybrid TO ignore:
+- Warn user that existing tracked files will remain tracked
+- Offer to run: `git rm -r --cached .bonfire/`
+
+## Step 7: Confirm
+
+Report:
+- Settings updated
+- Any manual steps needed (git cleanup)
+- New configuration summary

package/files/command/bonfire-document.md

@@ -0,0 +1,178 @@
+---
+description: Create documentation about a topic in the codebase
+---
+
+# Document Topic
+
+Create reference documentation using subagent for research, preserving main context.
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Check Config
+
+Read `<git-root>/.bonfire/config.json` if it exists.
+
+**Docs location**: Read `docsLocation` from config. Default to `.bonfire/docs/` if not set.
+
+## Step 3: Understand the Topic
+
+The topic to document is: $ARGUMENTS
+
+If no topic provided, ask the user what they want documented.
+
+## Step 4: Explore the Codebase (Subagent)
+
+**Progress**: Tell the user "Exploring codebase for [TOPIC]..."
+
+Use the task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive:
+
+```
+Research the codebase to document: [TOPIC]
+
+Find:
+1. **Architecture**: How this system/feature is structured, key components
+2. **Key Files**: Important files and their roles
+3. **Flow**: How data/control flows through the system
+4. **Patterns**: Design patterns and conventions used
+5. **Gotchas**: Important details, edge cases, things to watch out for
+
+Return structured findings with file paths and brief descriptions.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+The subagent runs in isolated context (haiku model, fast), preserving main context for writing.
+
+### Exploration Validation
+
+After the subagent returns, validate the response:
+
+**Valid response contains at least one of:**
+- `## Architecture` or `## Patterns Found` with content
+- `## Key Files` with entries
+- `## Flow` or `## Gotchas` with items
+
+**On valid response**: Proceed to Step 5.
+
+**On invalid/empty response**:
+1. Warn user: "Codebase exploration returned limited results. I'll research directly."
+2. Fall back to in-context research:
+   - `glob("**/*[topic-related]*")` to find relevant files
+   - `grep("topic-keywords")` to find implementations
+   - Read identified files
+3. Continue to Step 5 with in-context findings.
+
+**On subagent failure** (timeout, error):
+1. Warn user: "Subagent exploration failed. Continuing with direct research."
+2. Perform in-context research as above.
+3. Continue to Step 5.
+
+### Resumable Exploration (Large Codebases)
+
+For very large codebases, exploration may need multiple passes. The task tool returns a `session_id` you can use to resume.
+
+**When to offer resume:**
+- Subagent returns with "X additional items omitted" notes
+- Findings cover only part of the topic (e.g., found architecture but not flows)
+- User asks for deeper exploration of a specific aspect
+
+**To resume exploration:**
+1. Tell user: "Exploration found [X] but there's more to document. Continue exploring [specific aspect]?"
+2. If yes, re-invoke codebase-explorer with the `session_id` parameter:
+   - Pass the session_id from the previous invocation
+   - Provide a refined directive: "Continue exploring: [specific aspect]. Focus on [what to find]."
+3. Merge findings from resumed exploration with previous findings.
+4. Repeat if needed, up to 3 passes maximum.
+
+**Example multi-pass scenario:**
+- Pass 1: "Document payment system" → finds payment service, stripe integration
+- Pass 2 (resume): "Continue exploring: refund handling" → finds refund logic, webhooks
+- Merge: Combined findings produce more complete documentation
+
+## Step 5: Write Documentation (Subagent)
+
+**Progress**: Tell the user "Writing documentation..."
+
+**Naming convention**: `<topic>.md` (kebab-case)
+
+Examples:
+- `inbound-agent-architecture.md`
+- `sampling-strategies.md`
+- `authentication-flow.md`
+
+Use the task tool to invoke the **doc-writer** subagent.
+
+Provide the prompt in this exact format:
+
+```
+## Research Findings
+
+<paste structured findings from Step 4>
+
+## Doc Metadata
+
+- **Topic**: <topic name>
+- **Output Path**: <git-root>/<docsLocation>/<topic>.md
+- **Date**: <YYYY-MM-DD>
+```
+
+The subagent will write the doc file directly to the Output Path.
+
+### Doc Verification
+
+After the doc-writer subagent returns, verify the doc is complete.
+
+**Key sections to check** (lenient - only these 4):
+- `## Overview`
+- `## Key Files`
+- `## How It Works`
+- `## Gotchas`
+
+**Verification steps:**
+
+1. **Read the doc file** at `<git-root>/<docsLocation>/<topic>.md`
+
+2. **If file missing or empty**:
+   - Warn user: "Doc file wasn't written. Writing directly..."
+   - Write the doc yourself using the write tool
+   - Run verification again on the written file
+
+3. **If file exists, check for key sections**:
+   - Scan content for the 4 section headers above
+   - Track which sections are present/missing
+
+4. **If all 4 sections present**:
+   - Tell user: "Doc written and verified (4/4 key sections present)."
+   - Proceed to Step 6.
+
+5. **If 1-3 sections missing** (partial write):
+   - Warn user: "Doc appears incomplete. Missing sections: [list missing]"
+   - Show which sections ARE present
+   - Ask: "Proceed with partial doc, retry write, or abort?"
+   - **Proceed**: Continue to Step 6
+   - **Retry**: Re-invoke doc-writer subagent with same input, then verify again
+   - **Abort**: Stop and inform user the incomplete doc file remains at path
+
+6. **If all sections missing but has content**:
+   - Treat as invalid format, trigger fallback write
+   - Write the doc yourself, then verify the written file
+
+**On subagent failure** (timeout, error):
+- Warn user: "Doc writer failed. Writing doc directly..."
+- Write the doc yourself using the write tool
+- Run verification on the written file
+
+## Step 5: Link to Session Context
+
+Add a reference to the doc in `<git-root>/.bonfire/index.md` under Key Resources or Notes.
+
+## Step 6: Confirm
+
+Summarize what was documented and ask if the user wants:
+- More detail on any section
+- Related topics documented
+- To proceed with other work

package/files/command/bonfire-end.md

@@ -0,0 +1,62 @@
+---
+description: End session - update context and commit changes
+---
+
+# End Session
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Review Session Work
+
+Review what was accomplished this session by examining:
+- Recent git commits
+- Files changed
+- Conversation context
+
+## Step 3: Update Session Context
+
+Update `<git-root>/.bonfire/index.md`:
+
+1. Update the session entry with:
+   - **Accomplished**: List what was completed
+   - **Decisions**: Key decisions made and rationale
+   - **Files Modified**: Important files changed (if relevant)
+   - **Blockers**: Any issues encountered
+
+2. Update "Next Session Priorities" based on remaining work
+
+3. Update "Current State" to reflect new status
+
+## Step 4: Commit Changes (if tracked)
+
+Read `<git-root>/.bonfire/config.json` to check `gitStrategy`.
+
+**If gitStrategy is "ignore-all"**: Skip committing - nothing is tracked. Tell the user session context was updated locally.
+
+**If gitStrategy is "hybrid" or "commit-all"**:
+
+1. **Check what can be staged**: Run `git status .bonfire/` to see what files are not ignored
+2. **NEVER use `git add -f`** - if a file is gitignored, respect that
+3. **Stage only unignored files**:
+   ```bash
+   git add .bonfire/
+   ```
+4. **Check if anything was staged**: Run `git diff --cached --quiet .bonfire/`
+   - If nothing staged (exit code 0), tell user "Session context updated locally (files are gitignored)"
+   - If changes staged, commit:
+     ```bash
+     git commit -m "docs: update session context"
+     ```
+
+If the commit fails due to hooks, help resolve the issue (but never bypass hooks with `--no-verify`).
+
+## Step 5: Confirm
+
+Summarize:
+- What was documented
+- Next priorities
+- Any follow-up needed
+
+Let the user know they can run `/bonfire-archive` when this work is merged and complete.

package/files/command/bonfire-git-strategy.md

@@ -0,0 +1,91 @@
+---
+description: Change how .bonfire/ is handled in git
+---
+
+# Change Git Strategy
+
+## Step 1: Find Git Root
+
+Run `git rev-parse --show-toplevel` to locate the repository root.
+
+## Step 2: Read Current Config
+
+Read `<git-root>/.bonfire/config.json` to check current `specsLocation` and `docsLocation` settings.
+
+## Step 3: Explain Options
+
+Present the git strategy options:
+
+1. **Ignore all** - Keep sessions completely local
+   - Everything in .bonfire/ is gitignored
+   - Most private, nothing shared
+   - Good for: solo work, sensitive projects
+
+2. **Hybrid** - Commit docs/specs, keep notes private
+   - docs/ and specs/ are committed
+   - index.md and archive/ stay local
+   - Good for: teams that want shared docs but private notes
+
+3. **Commit all** - Share everything with team
+   - All session content is committed
+   - Only data/ and scratch/ ignored
+   - Good for: full transparency, team continuity
+
+## Step 4: Get User Choice
+
+Use the question tool to ask which strategy:
+
+"Which git strategy for `.bonfire/`?" (Header: "Git")
+- ignore-all (Recommended) - Keep sessions private/local
+- hybrid - Commit docs/specs, keep notes private
+- commit-all - Share everything with team
+
+## Step 5: Update .gitignore
+
+Write the appropriate `.gitignore` to `<git-root>/.bonfire/.gitignore`:
+
+**Ignore all**:
+```
+*
+!.gitignore
+```
+
+**Hybrid** (only include dirs that are inside .bonfire/):
+```
+*
+!.gitignore
+```
+If docsLocation is `.bonfire/docs/`, add:
+```
+!docs/
+!docs/**
+```
+If specsLocation is `.bonfire/specs/`, add:
+```
+!specs/
+!specs/**
+```
+
+**Commit all**:
+```
+data/
+scratch/
+```
+
+## Step 6: Handle Git Tracking
+
+If switching FROM commit/hybrid TO ignore:
+- Warn user that existing tracked files will remain tracked
+- Offer to run: `git rm -r --cached .bonfire/` (removes from git but keeps files)
+- They'll need to commit this change
+
+If switching TO commit/hybrid:
+- Files will be picked up on next commit
+- No special action needed
+
+## Step 7: Confirm
+
+Report:
+- New strategy applied
+- Any manual steps needed
+- How to verify the change