opencode-bonfire 1.5.0 → 2.0.0

package/README.md

@@ -24,22 +24,24 @@ bunx opencode-bonfire install --global
 
 | Component | Description |
 |-----------|-------------|
-| **8 Commands** | `/bonfire-start`, `/bonfire-end`, `/bonfire-spec`, `/bonfire-document`, `/bonfire-review`, `/bonfire-archive`, `/bonfire-configure`, `/bonfire-git-strategy` |
-| **4 Agents** | `codebase-explorer`, `spec-writer`, `doc-writer`, `work-reviewer` |
-| **1 Skill** | `bonfire-context` for loading session context |
+| **9 Commands** | `/bonfire-start`, `/bonfire-end`, `/bonfire-spec`, `/bonfire-strategic`, `/bonfire-document`, `/bonfire-review`, `/bonfire-review-pr`, `/bonfire-archive`, `/bonfire-configure` |
+| **3 Agents** | `codebase-explorer`, `writer`, `work-reviewer` |
+| **2 Skills** | `bonfire-context`, `archive-bonfire-awareness` |
 | **1 Plugin** | Archive suggestions + compaction context preservation |
 | **1 Tool** | `bonfire` for structured session data |
 
 ## Usage
 
 ```
-/bonfire-start              # Start session, scaffold if needed
-/bonfire-end                # Update context, commit changes
-/bonfire-spec <topic>       # Create implementation spec
-/bonfire-document <topic>   # Document a codebase topic
-/bonfire-review             # Find blindspots and gaps
-/bonfire-archive            # Archive completed work
-/bonfire-configure          # Change project settings
+/bonfire-start                      # Start session, scaffold if needed
+/bonfire-end                        # Update context, commit changes
+/bonfire-spec <topic>               # Create implementation spec
+/bonfire-strategic <type> <topic>   # Create RFC, PRD, or POC
+/bonfire-document <topic>           # Document a codebase topic
+/bonfire-review                     # Find blindspots and gaps
+/bonfire-review-pr <number>         # Review a GitHub PR
+/bonfire-archive                    # Archive completed work
+/bonfire-configure                  # Change project settings (git, linear)
 ```
 
 ## How It Works

package/files/agent/writer.md

@@ -0,0 +1,127 @@
+---
+name: writer
+description: Synthesize research and interview findings into documents
+model: anthropic/claude-sonnet-4-20250514
+hidden: true
+tools: [Read, Write]
+permission:
+  task:
+    "*": deny
+---
+
+You are a technical document writer. Given research findings and (optionally) interview answers, produce clear, actionable documentation.
+
+## Input Format
+
+You'll receive a structured prompt with:
+
+```
+## Document Type
+
+<spec | doc | rfc | prd | poc>
+
+## Research Findings
+
+<structured markdown from codebase-explorer>
+
+## Interview Q&A (if applicable)
+
+### [Round Name]
+**Q**: <question>
+**A**: <user's answer>
+
+## Document Metadata
+
+- **Topic**: <feature, system, or task name>
+- **Issue**: <issue ID or N/A>
+- **Output Path**: </absolute/path/to/file.md>
+- **Date**: <YYYY-MM-DD>
+- **Author**: <name, if applicable>
+
+## Template (optional)
+
+<specific template structure to follow>
+```
+
+Write the document to the exact path specified in Output Path.
+
+---
+
+## Document Types
+
+### Spec (Implementation Specification)
+
+**Purpose**: Actionable implementation plan for a feature or task.
+
+**Required sections**:
+- `## Overview` - What we're building and why
+- `## Decisions` - Key choices with rationale
+- `## Implementation Steps` - Ordered, actionable steps
+- `## Edge Cases` - Error handling, boundary conditions
+
+---
+
+### Doc (Reference Documentation)
+
+**Purpose**: Help developers understand a system, feature, or pattern.
+
+**Required sections**:
+- `## Overview` - What this is and why it exists
+- `## Key Files` - Important files with their roles
+- `## How It Works` - Conceptual explanation of flow/behavior
+- `## Gotchas` - Edge cases, pitfalls, things to watch out for
+
+---
+
+### RFC (Request for Comments)
+
+**Purpose**: Technical decision proposal for team review.
+
+**Required sections**:
+- `## Abstract` - 1-3 sentences summarizing proposal
+- `## Problems We Need To Solve` - Concrete problems with evidence
+- `## Proposed Solution` - Overview, pros, cons/tradeoffs
+- `## Alternatives Considered` - Other approaches evaluated
+
+---
+
+### PRD (Product Requirements Document)
+
+**Purpose**: Product specification for feature development.
+
+**Required sections**:
+- `## 2. Problem` - Customer and internal pain points
+- `## 5. Goals & Success Metrics` - Goals and measurable outcomes
+- `## 6. Product Requirements` - Functional and non-functional requirements
+- `## 9. Scope` - In scope and out of scope
+
+---
+
+### POC (Proof of Concept Plan)
+
+**Purpose**: Customer evaluation plan with clear success criteria.
+
+**Required sections**:
+- `## 2. Goals` - What we want to validate
+- `## 3. Success Criteria` - Concrete, measurable exit criteria
+- `## 4. Scope` - In scope and out of scope
+- `## 5. Plan & Timeline` - Phases and milestones
+
+---
+
+## Rules
+
+1. **Ground in research** - Reference actual files and patterns discovered
+2. **Honor interview answers** - Don't override user decisions
+3. **Be specific** - "Update UserService.ts" not "Update the service"
+4. **Don't invent** - If something wasn't discussed/found, don't add it
+5. **Keep it actionable** - Someone should be able to use this document
+
+## Quality Checklist
+
+Before finishing, verify:
+- [ ] All required sections for document type are present
+- [ ] Content references real files from research (not placeholders)
+- [ ] Interview decisions are captured (if applicable)
+- [ ] No vague or generic content
+- [ ] File written to exact Output Path specified

package/files/command/bonfire-configure.md

@@ -1,10 +1,17 @@
 ---
-description: Change project settings (locations, git strategy, Linear)
+description: Change project settings (locations, git strategy, Linear, hooks)
 ---
 
 # Configure Bonfire
 
-Always runs interactively - asks all configuration questions regardless of arguments.
+Change project settings. Supports targeted or full configuration.
+
+## Argument Handling
+
+Based on `$ARGUMENTS`:
+- Empty: Full interactive config (all settings)
+- `git`: Git strategy only (quick mode - replaces /bonfire-git-strategy)
+- `linear`: Linear integration only (quick mode)
 
 ## Step 1: Find Git Root
 

package/files/command/bonfire-review-pr.md

@@ -19,25 +19,7 @@ If no PR number provided:
 >
 > Example: `/bonfire-review-pr 333`"
 
-## Step 2: Verify Environment
-
-Check if running inside tmux:
-
-```bash
-[ -n "$TMUX" ] && echo "tmux: yes" || echo "tmux: no"
-```
-
-**If not in tmux**: Provide manual instructions and abort:
-
-> "PR review with inline comments requires tmux for worktree isolation.
->
-> **Manual alternative:**
-> 1. Create worktree: `git worktree add ../pr-<number>-review origin/<branch>`
-> 2. Open new terminal in that directory
-> 3. Run: `opencode 'Review this PR and help me post comments'`
-> 4. Clean up when done: `git worktree remove ../pr-<number>-review`"
-
-## Step 3: Fetch PR Metadata
+## Step 2: Fetch PR Metadata
 
 Get PR details:
 
@@ -55,7 +37,7 @@ Extract and store:
 - `url` - PR URL
 - `files` - Changed files list
 
-## Step 4: Find Git Root and Compute Paths
+## Step 3: Compute Worktree Path
 
 ```bash
 git rev-parse --show-toplevel
@@ -65,7 +47,7 @@ Compute worktree path: `<git-root>/../<repo-name>-pr-<number>-review`
 
 Example: `/Users/vieko/dev/gtm` → `/Users/vieko/dev/gtm-pr-333-review`
 
-## Step 5: Create Worktree
+## Step 4: Create Worktree
 
 Create isolated worktree for PR branch:
 
@@ -82,85 +64,78 @@ git worktree add <worktree-path> origin/<headRefName>
    - No: Abort
 3. If other error: Report error and abort with suggestion to check `git worktree list`
 
-## Step 6: Get PR Diff Summary
+## Step 5: Get PR Diff
 
 Get the diff for context:
 
 ```bash
-cd <worktree-path> && git diff origin/<baseRefName>...HEAD --stat
+git -C <worktree-path> diff origin/<baseRefName>...HEAD --stat
 ```
 
 Get changed files:
 
 ```bash
-cd <worktree-path> && git diff origin/<baseRefName>...HEAD --name-only
+git -C <worktree-path> diff origin/<baseRefName>...HEAD --name-only
 ```
 
-## Step 7: Generate Review Context
-
-Create context document for spawned session.
-
-Write to `<worktree-path>/.bonfire-pr-review-context.md`:
-
-```markdown
-# PR Review Context
-
-**PR**: #<number> - <title>
-**URL**: <url>
-**Branch**: <headRefName> → <baseRefName>
-**Commit**: <headRefOid>
-
-## Changed Files
-
-<list of changed files>
-
-## PR Description
-
-<body from PR>
-
----
-
-## Instructions
+## Step 6: Run Review (Subagent)
 
-You are reviewing PR #<number> in an isolated worktree.
+**Progress**: Tell the user "Reviewing PR for blindspots and gaps..."
 
-### Step 1: Run Review
+Use the Task tool to invoke the **work-reviewer** agent.
 
-Use the task tool to invoke the **work-reviewer** subagent:
+Provide the review context:
 
 ```
 Review this pull request for blindspots, gaps, and improvements.
 
 **Scope**: PR #<number> - <title>
 
+**PR Description**:
+<body from PR>
+
 **Files changed**:
 <list of changed files>
 
-**PR Description**:
-<body>
+**Worktree path**: <worktree-path>
 
+Read the changed files from the worktree to understand the actual changes.
 Return categorized findings with severity, effort, and specific file:line references.
 ```
 
-### Step 2: Present Findings
+**Wait for the subagent to return findings** before proceeding.
+
+### Review Validation
+
+After the subagent returns, validate the response:
 
-After review completes, present findings grouped by severity.
+**Valid response contains:**
+- Findings with file:line references where applicable
+- Severity categorization
 
-For each finding, note:
+**On subagent failure**: Fall back to in-context review using the diff.
+
+## Step 7: Present Findings
+
+Present the findings grouped by severity:
+
+For each finding, show:
 - File and line number (if applicable)
 - Severity (critical/moderate/minor)
 - Description
 
-### Step 3: Batch Comment Selection
+## Step 8: Batch Comment Selection
 
 Ask user: "Which findings should I post as PR comments?"
 
-Options:
-1. List findings by number, let user select (e.g., "1, 3, 5")
-2. "All" - post all findings
+Use the question tool with options:
+1. "All" - post all findings
+2. "Select" - user will specify which ones (e.g., "1, 3, 5")
 3. "None" - skip commenting
 
-### Step 4: Post Inline Comments
+If "Select" chosen, ask which finding numbers to post.
+
+## Step 9: Post Comments
 
 For each selected finding with a file:line reference, post an inline comment:
 
@@ -186,44 +161,23 @@ gh pr comment <number> --body "**Review Finding**
 *Severity: <severity> | Effort: <effort>*"
 ```
 
-**Note**: GitHub only allows inline comments on files that are part of the PR diff. If a finding references a file not in the diff (e.g., missing config in turbo.json when turbo.json wasn't changed), post it as a general PR comment instead.
+**Note**: GitHub only allows inline comments on files that are part of the PR diff. If a finding references a file not in the diff, post it as a general PR comment instead.
 
-### Step 5: Offer Cleanup
+## Step 10: Cleanup Worktree
 
 After commenting, ask: "Review complete. Remove worktree?"
 
 If yes:
 ```bash
-cd <original-git-root>
 git worktree remove <worktree-path>
 ```
 
 Report: "Worktree cleaned up. PR review complete."
-```
 
-## Step 8: Spawn Review Session
+## Step 11: Confirm
 
-Spawn a new OpenCode session in the worktree:
-
-```bash
-WORKTREE_PATH="<computed-worktree-path>"
-CONTEXT="$(cat "$WORKTREE_PATH/.bonfire-pr-review-context.md")"
-tmux split-window -h -c "$WORKTREE_PATH" \
-  "opencode --append-system-prompt '$CONTEXT' 'Ready to review PR #<number>. Starting work-reviewer subagent...'"
-```
-
-**Verify spawn succeeded**: If tmux fails (terminal too small), warn user and provide manual instructions.
-
-## Step 9: Confirm
-
-Tell the user:
-
-> **PR review session spawned.**
->
-> - Worktree created at `<worktree-path>`
-> - Review session opened in adjacent pane
-> - The new session will run work-reviewer and help you post comments
->
-> When done, the review session will offer to clean up the worktree.
->
-> You can continue working here - your current branch is unchanged.
+Summarize:
+- PR reviewed: #<number> - <title>
+- Findings: <count> total, <posted> posted as comments
+- PR URL for reference
+- Worktree status (cleaned up or retained)

package/files/command/bonfire-strategic.md

@@ -0,0 +1,166 @@
+---
+description: Create strategic documents (RFC, PRD, POC)
+---
+
+# Create Strategic Document
+
+Create a strategic document of type **$1** for **$2**.
+
+---
+
+## Document Type Detection
+
+Parse $ARGUMENTS:
+- First word: document type (rfc, prd, poc)
+- Remaining: topic/subject
+
+Examples:
+- `/bonfire-strategic rfc authentication` → RFC about authentication
+- `/bonfire-strategic prd dark-mode` → PRD about dark mode feature
+- `/bonfire-strategic poc acme-corp` → POC plan for Acme Corp
+
+If type not recognized or missing, ask user to specify.
+
+---
+
+## Supported Types
+
+| Type | Full Name | Use Case |
+|------|-----------|----------|
+| `rfc` | Request for Comments | Technical decisions, architecture proposals |
+| `prd` | Product Requirements Document | Product specs, feature definitions |
+| `poc` | Proof of Concept Plan | Customer evaluations, technical validations |
+
+---
+
+## Shared Flow
+
+All document types follow the same research → interview → write pattern:
+
+### Phase 1: Research (Subagent)
+
+**Progress**: Tell the user "Researching codebase for context..."
+
+Use the Task tool to invoke the **codebase-explorer** agent.
+
+Research questions vary by type:
+
+**RFC**: Prior art, architecture, constraints, stakeholders
+**PRD**: Related features, user flows, data model, technical constraints
+**POC**: Relevant features, integration points, configuration, limitations
+
+**Wait for findings** before proceeding.
+
+### Phase 2: Interview (Main Context)
+
+**Progress**: Tell the user "Starting interview..."
+
+Interview rounds vary by type:
+
+**RFC** (3 rounds):
+1. Problem definition
+2. Proposed solutions
+3. Logistics & scope
+
+**PRD** (4 rounds):
+1. Problem & opportunity
+2. Target users
+3. Requirements & metrics
+4. Scope
+
+**POC** (4 rounds):
+1. Customer context
+2. Goals & success criteria
+3. Scope & timeline
+4. Risks & responsibilities
+
+Use the question tool with informed questions based on research.
+
+### Phase 3: Write (Subagent)
+
+**Progress**: Tell the user "Writing document..."
+
+Use the Task tool to invoke the **writer** agent.
+
+Provide:
+- Document type
+- Research findings
+- Interview Q&A
+- Output path
+- Template structure (type-specific)
+
+### Phase 4: Verify & Confirm
+
+Verify required sections are present (4 key sections per type).
+
+If incomplete, offer: proceed / retry / abort.
+
+---
+
+## Type-Specific Details
+
+### RFC (Request for Comments)
+
+**Interview rounds**:
+- Round 1: Problem definition (what problems, who experiences, evidence)
+- Round 2: Proposed solutions (approach, alternatives, tradeoffs)
+- Round 3: Logistics (reviewers, scope, timeline)
+
+**Required sections**:
+- `## Abstract`
+- `## Problems We Need To Solve`
+- `## Proposed Solution`
+- `## Alternatives Considered`
+
+**Naming**: `rfc-<topic>.md` or `rfc-<issue-id>-<topic>.md`
+
+---
+
+### PRD (Product Requirements Document)
+
+**Interview rounds**:
+- Round 1: Problem & opportunity (pain points, why now, business case)
+- Round 2: Target users (primary/secondary audiences, plan gating)
+- Round 3: Requirements & metrics (must-haves, success metrics)
+- Round 4: Scope (in/out of scope, dependencies)
+
+**Required sections**:
+- `## 2. Problem`
+- `## 5. Goals & Success Metrics`
+- `## 6. Product Requirements`
+- `## 9. Scope`
+
+**Naming**: `prd-<feature>.md` or `prd-<issue-id>-<feature>.md`
+
+---
+
+### POC (Proof of Concept Plan)
+
+**Interview rounds**:
+- Round 1: Customer context (who, current state, why evaluating)
+- Round 2: Goals & success criteria (what to prove, measurable outcomes)
+- Round 3: Scope & timeline (in/out scope, dates, deadlines)
+- Round 4: Risks & responsibilities (ownership, assumptions, risks)
+
+**Required sections**:
+- `## 2. Goals`
+- `## 3. Success Criteria`
+- `## 4. Scope`
+- `## 5. Plan & Timeline`
+
+**Naming**: `poc-<customer>.md` or `poc-<issue-id>-<customer>.md`
+
+---
+
+## File Locations
+
+- **Config**: `<git-root>/.bonfire/config.json` contains `docsLocation`
+- **Default**: `.bonfire/docs/` if not configured
+
+---
+
+## Post-Write
+
+1. **Verify** document has required sections
+2. **Link** to session context in `<git-root>/.bonfire/index.md`
+3. **Confirm** with user and offer next steps

package/files/opencode.json

@@ -7,9 +7,6 @@
     },
     {
       "directory": "skill/archive-bonfire-awareness"
-    },
-    {
-      "directory": "skill/handoff-awareness"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-bonfire",
-  "version": "1.5.0",
+  "version": "2.0.0",
   "description": "OpenCode forgets everything between sessions. Bonfire remembers.",
   "type": "module",
   "bin": {