opencode-bonfire 1.1.1 → 1.2.0

package/files/command/bonfire-poc.md

@@ -0,0 +1,332 @@
+---
+description: Create a Proof of Concept (POC) plan
+---
+
+# Create POC Plan
+
+A hybrid approach using subagents: research in isolated context, interview in main context, write in isolated 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: Gather Initial Context
+
+Get the customer/project name from $ARGUMENTS or ask if unclear.
+
+Check for existing context:
+- Read `<git-root>/.bonfire/index.md` for project state
+- Check for existing POC plans in docs location
+- If issue ID provided, note for filename
+
+## Step 4: Research Phase (Subagent)
+
+**Progress**: Tell the user "Researching codebase for POC context..."
+
+Use the task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive with these questions:
+
+```
+Research the codebase for POC context: [CUSTOMER/PROJECT]
+
+Find:
+1. **Relevant Features**: Features/products being evaluated in this POC
+2. **Integration Points**: APIs, webhooks, SDKs that customer would use
+3. **Configuration**: Environment setup, feature flags, plan requirements
+4. **Limitations**: Known constraints, quotas, edge cases to test
+
+Return structured findings only - no raw file contents.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+### Research Validation
+
+After the subagent returns, validate the response:
+
+**Valid response contains at least one of:**
+- `## Relevant Features` or `## Key Files` with content
+- `## Integration Points` with entries
+- `## Configuration` or `## Limitations` 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 using glob, grep, and read.
+3. Continue to Step 5 with in-context findings.
+
+**Note**: POCs may be less code-focused. If research returns minimal findings, that's okay - the interview will gather most context.
+
+## Step 5: Interview Phase (Main Context)
+
+**Progress**: Tell the user "Starting interview (4 rounds: context, goals, plan, logistics)..."
+
+Using the research findings, interview the user with **informed questions** via the question tool.
+
+### Round 1: Customer Context
+
+**Progress**: "Round 1/4: Customer context..."
+
+Ask about the customer and current state:
+
+Example questions:
+- "Who is the customer? Brief context on their business/use case."
+- "What's their current state? (existing stack, competitor product, greenfield)"
+- "Who are the DRIs on the customer side? (technical lead, decision maker)"
+- "Why are they evaluating us? What triggered this POC?"
+
+### Round 2: Goals & Success Criteria
+
+**Progress**: "Round 2/4: Goals and success criteria..."
+
+Based on Round 1 answers and research, ask about success:
+
+Example questions:
+- "What are the top 3 goals for this POC? What must we prove?"
+- "What does success look like? (specific, measurable criteria)"
+- "What would make this POC fail? (dealbreakers, must-haves)"
+- "I found [feature/limitation]. Is this relevant to their evaluation?"
+
+### Round 3: Scope & Timeline
+
+**Progress**: "Round 3/4: Scope and timeline..."
+
+Ask about what's included:
+
+**Scope** (must ask):
+- "What's in scope for this POC? (features, workloads, environments)"
+- "What's explicitly out of scope?"
+
+**Timeline** (must ask):
+- "POC start date and target decision date?"
+- "Any hard deadlines? (contract renewal, board meeting, etc.)"
+
+### Round 4: Risks & Responsibilities (Required)
+
+**Progress**: "Round 4/4: Risks and responsibilities (final round)..."
+
+Always ask about logistics:
+
+**Responsibilities** (must ask):
+- "What will our team own vs what will the customer own?"
+- "Who is the internal DRI for this POC?"
+
+**Risks** (must ask):
+- "What are the main risks? (technical, timeline, relationship)"
+- "Any assumptions we're making that could be wrong?"
+
+## Step 6: Write the POC Plan (Subagent)
+
+**Progress**: Tell the user "Writing POC plan..."
+
+Use the task tool to invoke the **doc-writer** subagent.
+
+Provide the prompt in this exact format:
+
+```
+## Document Type
+
+POC (Proof of Concept) Plan
+
+## Research Findings
+
+<paste structured findings from Step 4>
+
+## Interview Q&A
+
+### Customer Context
+**Q**: <question from Round 1>
+**A**: <user's answer>
+
+### Goals & Success Criteria
+**Q**: <question from Round 2>
+**A**: <user's answer>
+
+### Scope & Timeline
+**Q**: <question from Round 3>
+**A**: <user's answer>
+
+### Risks & Responsibilities
+**Q**: <question from Round 4>
+**A**: <user's answer>
+
+## Document Metadata
+
+- **Customer**: <customer name>
+- **Internal DRI**: <from interview>
+- **Issue**: <issue ID or N/A>
+- **Output Path**: <git-root>/<docsLocation>/poc-<customer>.md
+- **Date**: <YYYY-MM-DD>
+
+## Template
+
+Use this structure:
+
+# <Customer> - Proof of Concept (POC) Plan
+
+**Customer / Partner:** <name>
+**Internal DRIs:** <names & roles>
+**Customer DRIs:** <names & roles>
+**POC Start:** <date>
+**Target Decision Date:** <date>
+
+---
+
+## 1. Context
+
+<!-- Short summary: customer, current state, why this POC -->
+
+## 2. Goals
+
+<!-- 3-5 bullets: what we want to validate -->
+
+- Goal 1...
+- Goal 2...
+
+## 3. Success Criteria
+
+<!-- Concrete, measurable exit criteria -->
+
+- Technical: ...
+- Performance / reliability: ...
+- DX / workflow: ...
+- Commercial (optional): ...
+
+## 4. Scope
+
+### 4.1 In Scope
+
+- Workloads / apps / surfaces included
+- Products / features being evaluated
+- Environments (staging, prod shadow, etc.)
+
+### 4.2 Out of Scope
+
+- What we will NOT do in this POC
+
+## 5. Plan & Timeline
+
+### Phase 1 - Prep
+
+- Environment setup
+- Access and security requirements
+- Baseline metrics (before POC)
+
+### Phase 2 - Implementation
+
+- Tasks / owners (Internal vs Customer)
+- Milestones
+
+### Phase 3 - Validation
+
+- Tests to run
+- How we'll collect metrics and feedback
+
+### Phase 4 - Review & Decision
+
+- Joint review meeting
+- Decision options: Go / No-go / Extend
+- Next steps if "Go"
+
+## 6. Responsibilities
+
+### Internal Team
+
+- ...
+
+### Customer
+
+- ...
+
+## 7. Assumptions
+
+<!-- Things we're assuming will be true -->
+
+- ...
+
+## 8. Risks & Mitigations
+
+- Risk: ...
+  Mitigation: ...
+
+## 9. Reporting
+
+<!-- How progress and results will be shared -->
+
+- Weekly update: ...
+- Final summary: ...
+
+## 10. Appendix
+
+<!-- Links to architecture, repos, dashboards, contracts -->
+```
+
+The subagent will write the POC plan directly to the Output Path.
+
+**Naming convention**: `poc-<customer>.md` or `poc-<issue-id>-<customer>.md`
+
+### Document Verification
+
+After the doc-writer subagent returns, verify the POC plan is complete.
+
+**Key sections to check** (lenient - only these 4):
+- `## 2. Goals`
+- `## 3. Success Criteria`
+- `## 4. Scope`
+- `## 5. Plan & Timeline`
+
+**Verification steps:**
+
+1. **Read the POC file** at the output path
+
+2. **If file missing or empty**:
+   - Warn user: "POC plan wasn't written. Writing directly..."
+   - Write the POC plan yourself using the write tool
+
+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: "POC plan written and verified (4/4 key sections present)."
+   - Proceed to Step 7.
+
+5. **If sections missing**:
+   - Warn user: "POC plan appears incomplete. Missing sections: [list]"
+   - Ask: "Proceed with partial plan, retry write, or abort?"
+
+## Step 7: Link to Session Context
+
+Add a reference to the POC plan in `<git-root>/.bonfire/index.md` under Current State.
+
+## Step 8: Confirm
+
+Read the generated POC plan and present a summary. Ask if user wants to:
+- Share with customer
+- Refine specific sections
+- Add more detail to timeline
+- Create related issues/tasks
+
+## POC Lifecycle
+
+POC plans progress through states:
+
+1. **Draft** - Initial creation
+2. **Prep** - Environment setup, access provisioned
+3. **Active** - POC in progress
+4. **Review** - Evaluating results
+5. **Decided** - Go / No-go / Extend
+
+**When a POC concludes**:
+- Document outcome and learnings
+- If "Go": Create onboarding plan, handoff docs
+- If "No-go": Document reasons for future reference
+- Archive the POC plan with outcome notes

package/files/command/bonfire-prd.md

@@ -0,0 +1,332 @@
+---
+description: Create a Product Requirements Document (PRD)
+---
+
+# Create PRD
+
+A hybrid approach using subagents: research in isolated context, interview in main context, write in isolated 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: Gather Initial Context
+
+Get the feature/product name from $ARGUMENTS or ask if unclear.
+
+Check for existing context:
+- Read `<git-root>/.bonfire/index.md` for project state
+- Check for existing PRDs in docs location
+- If issue ID provided, note for filename
+
+## Step 4: Research Phase (Subagent)
+
+**Progress**: Tell the user "Researching codebase for product context..."
+
+Use the task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive with these questions:
+
+```
+Research the codebase for PRD context: [FEATURE/PRODUCT]
+
+Find:
+1. **Related Features**: Existing similar features, integration points, shared components
+2. **User Flows**: Current user journeys, entry points, related screens/endpoints
+3. **Data Model**: Relevant entities, schemas, APIs that would be affected
+4. **Technical Constraints**: Performance limits, plan gating, existing quotas/limits
+
+Return structured findings only - no raw file contents.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+### Research Validation
+
+After the subagent returns, validate the response:
+
+**Valid response contains at least one of:**
+- `## Related Features` or `## Patterns Found` with content
+- `## Key Files` with entries
+- `## User Flows` or `## Data Model` 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 using glob, grep, and read.
+3. Continue to Step 5 with in-context findings.
+
+## Step 5: Interview Phase (Main Context)
+
+**Progress**: Tell the user "Starting interview (4 rounds: problem, users, requirements, scope)..."
+
+Using the research findings, interview the user with **informed questions** via the question tool.
+
+### Round 1: Problem & Opportunity
+
+**Progress**: "Round 1/4: Problem and opportunity..."
+
+Ask about the problem and why now:
+
+Example questions (adapt based on findings):
+- "What problem does this feature solve? Who feels this pain most?"
+- "Why build this now vs later? (market, competition, customer requests)"
+- "I found [existing feature]. How does this relate or differ?"
+- "What's the business opportunity? Revenue, retention, expansion?"
+
+### Round 2: Target Users
+
+**Progress**: "Round 2/4: Target users..."
+
+Based on Round 1 answers and research, ask about users:
+
+Example questions:
+- "Who is the primary audience? (persona, plan tier, role)"
+- "Secondary audiences?"
+- "I see [existing user flow]. Will these same users use this feature?"
+- "Any users who should NOT have access? (plan gating, permissions)"
+
+### Round 3: Requirements & Metrics
+
+**Progress**: "Round 3/4: Requirements and success metrics..."
+
+Ask about what success looks like:
+
+**Functional requirements** (must ask):
+- "What must this feature do? (the 'must haves')"
+- "What should it do? (the 'should haves')"
+
+**Success metrics** (must ask):
+- "How will we measure success? (adoption, retention, revenue, NPS)"
+- "What are the guardrail metrics? (performance, reliability, support load)"
+
+### Round 4: Scope (Required)
+
+**Progress**: "Round 4/4: Scope (final round)..."
+
+Always ask about scope:
+
+**In scope** (must ask):
+- "What's explicitly in scope for v1?"
+
+**Out of scope** (must ask):
+- "What's explicitly out of scope or deferred to later?"
+
+**Dependencies**:
+- "Any dependencies on other teams, projects, or launches?"
+
+## Step 6: Write the PRD (Subagent)
+
+**Progress**: Tell the user "Writing PRD document..."
+
+Use the task tool to invoke the **doc-writer** subagent.
+
+Provide the prompt in this exact format:
+
+```
+## Document Type
+
+PRD (Product Requirements Document)
+
+## Research Findings
+
+<paste structured findings from Step 4>
+
+## Interview Q&A
+
+### Problem & Opportunity
+**Q**: <question from Round 1>
+**A**: <user's answer>
+
+### Target Users
+**Q**: <question from Round 2>
+**A**: <user's answer>
+
+### Requirements & Metrics
+**Q**: <question from Round 3>
+**A**: <user's answer>
+
+### Scope
+**Q**: <question from Round 4>
+**A**: <user's answer>
+
+## Document Metadata
+
+- **Feature**: <feature name>
+- **DRI (PM)**: <from interview or ask>
+- **Issue**: <issue ID or N/A>
+- **Output Path**: <git-root>/<docsLocation>/prd-<feature>.md
+- **Date**: <YYYY-MM-DD>
+
+## Template
+
+Use this structure:
+
+# PRD: <Feature Name>
+
+**DRI (PM):** <name>
+**Engineering DRI:** <name or TBD>
+**Product Area:** <area/team>
+**Last Updated:** <YYYY-MM-DD>
+
+---
+
+## 1. Overview
+
+<!-- 3-5 sentence narrative: what, who, outcome -->
+
+## 2. Problem
+
+### Customer Pain Points
+
+- ...
+
+### Internal Pain Points
+
+- ...
+
+## 3. Opportunity / Why Now
+
+<!-- Why this matters now -->
+
+## 4. Target Audience
+
+- **Primary:** ...
+- **Secondary:** ...
+
+## 5. Goals & Success Metrics
+
+### Goals
+
+- G1: ...
+- G2: ...
+
+### Metrics for Success
+
+- Core metric(s): ...
+- Guardrails: ...
+
+## 6. Product Requirements
+
+### 6.1 Functional Requirements
+
+- FR1: ...
+- FR2: ...
+
+### 6.2 Non-functional Requirements
+
+- NFR1: ...
+
+## 7. User Stories
+
+- As a <persona>, I want <goal> so that <outcome>.
+
+## 8. Solution Outline
+
+### 8.1 UX / Flows
+
+<!-- High-level flows, link to designs -->
+
+### 8.2 Product Details
+
+- Plans: which plans get what
+- Limits / quotas
+- Interactions with existing features
+
+## 9. Scope
+
+### 9.1 In Scope
+
+- ...
+
+### 9.2 Out of Scope
+
+- ...
+
+## 10. Dependencies & Risks
+
+### Dependencies
+
+- ...
+
+### Risks & Mitigations
+
+- Risk: ...
+  Mitigation: ...
+
+## 11. Open Questions
+
+- Q1...
+
+## 12. Appendix
+
+<!-- Links to designs, RFCs, customer notes -->
+```
+
+The subagent will write the PRD file directly to the Output Path.
+
+**Naming convention**: `prd-<feature>.md` or `prd-<issue-id>-<feature>.md`
+
+### Document Verification
+
+After the doc-writer subagent returns, verify the PRD is complete.
+
+**Key sections to check** (lenient - only these 4):
+- `## 2. Problem`
+- `## 5. Goals & Success Metrics`
+- `## 6. Product Requirements`
+- `## 9. Scope`
+
+**Verification steps:**
+
+1. **Read the PRD file** at the output path
+
+2. **If file missing or empty**:
+   - Warn user: "PRD file wasn't written. Writing directly..."
+   - Write the PRD yourself using the write tool
+
+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: "PRD written and verified (4/4 key sections present)."
+   - Proceed to Step 7.
+
+5. **If sections missing**:
+   - Warn user: "PRD appears incomplete. Missing sections: [list]"
+   - Ask: "Proceed with partial PRD, retry write, or abort?"
+
+## Step 7: Link to Session Context
+
+Add a reference to the PRD in `<git-root>/.bonfire/index.md` under Current State.
+
+## Step 8: Confirm
+
+Read the generated PRD and present a summary. Ask if user wants to:
+- Share with stakeholders
+- Refine specific sections
+- Add more requirements
+- Create implementation specs from this
+
+## PRD Lifecycle
+
+PRDs progress through states:
+
+1. **Draft** - Initial creation, gathering input
+2. **In Review** - Shared with stakeholders
+3. **Approved** - Signed off, ready for engineering
+4. **In Development** - Being built
+5. **Shipped** - Feature launched
+
+**When a PRD is approved**:
+- Create RFCs for technical decisions
+- Create implementation specs for engineering
+- Link PRD in related issues/PRs

package/files/command/bonfire-rfc.md

@@ -0,0 +1,267 @@
+---
+description: Create a Request for Comments (RFC) document
+---
+
+# Create RFC
+
+A hybrid approach using subagents: research in isolated context, interview in main context, write in isolated 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: Gather Initial Context
+
+Get the topic from $ARGUMENTS or ask if unclear.
+
+Check for existing context:
+- Read `<git-root>/.bonfire/index.md` for project state
+- Check for existing RFCs in docs location
+- If issue ID provided, note for filename
+
+## Step 4: Research Phase (Subagent)
+
+**Progress**: Tell the user "Researching codebase for context and prior art..."
+
+Use the task tool to invoke the **codebase-explorer** subagent for research.
+
+Provide a research directive with these questions:
+
+```
+Research the codebase for RFC context: [TOPIC]
+
+Find:
+1. **Prior Art**: Existing implementations, related features, previous approaches
+2. **Architecture**: Current system design, relevant components, integration points
+3. **Constraints**: Technical limitations, dependencies, performance considerations
+4. **Stakeholders**: Teams/systems that would be affected by changes
+
+Return structured findings only - no raw file contents.
+```
+
+**Wait for the subagent to return findings** before proceeding.
+
+### Research Validation
+
+After the subagent returns, validate the response:
+
+**Valid response contains at least one of:**
+- `## Prior Art` or `## Patterns Found` with content
+- `## Key Files` with entries
+- `## Architecture` or `## Constraints` 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 using glob, grep, and read.
+3. Continue to Step 5 with in-context findings.
+
+## Step 5: Interview Phase (Main Context)
+
+**Progress**: Tell the user "Starting interview (3 rounds: problem, solutions, logistics)..."
+
+Using the research findings, interview the user with **informed questions** via the question tool.
+
+### Round 1: Problem Definition
+
+**Progress**: "Round 1/3: Problem definition..."
+
+Ask about the problems being solved:
+
+Example questions (adapt based on findings):
+- "What specific problems does this RFC address? I found [existing approach] - what's not working?"
+- "Who experiences these problems? End users, developers, ops?"
+- "How do we know these are real problems? (metrics, incidents, feedback)"
+- "I see [related system]. Is this problem isolated or connected to that?"
+
+### Round 2: Proposed Solutions
+
+**Progress**: "Round 2/3: Proposed solutions..."
+
+Based on Round 1 answers and research, ask about solutions:
+
+Example questions:
+- "What's your primary proposed solution?"
+- "I found [existing pattern]. Should the solution extend this or take a different approach?"
+- "What alternatives did you consider? Why not [alternative approach]?"
+- "What are the main tradeoffs of your proposed solution?"
+
+### Round 3: Logistics & Scope (Required)
+
+**Progress**: "Round 3/3: Logistics and scope (final round)..."
+
+Always ask about logistics:
+
+**Reviewers** (must ask):
+- "Who should review this RFC? Which teams need to sign off?"
+
+**Scope** (must ask):
+- "What's explicitly out of scope for this RFC?"
+
+**Timeline** (optional):
+- "Any timeline constraints or dependencies?"
+
+## Step 6: Write the RFC (Subagent)
+
+**Progress**: Tell the user "Writing RFC document..."
+
+Use the task tool to invoke the **doc-writer** subagent.
+
+Provide the prompt in this exact format:
+
+```
+## Document Type
+
+RFC (Request for Comments)
+
+## Research Findings
+
+<paste structured findings from Step 4>
+
+## Interview Q&A
+
+### Problem Definition
+**Q**: <question from Round 1>
+**A**: <user's answer>
+
+### Proposed Solutions
+**Q**: <question from Round 2>
+**A**: <user's answer>
+
+### Logistics & Scope
+**Q**: <question from Round 3>
+**A**: <user's answer>
+
+## Document Metadata
+
+- **Topic**: <topic name>
+- **Author**: <from git config or ask>
+- **Issue**: <issue ID or N/A>
+- **Output Path**: <git-root>/<docsLocation>/rfc-<topic>.md
+- **Date**: <YYYY-MM-DD>
+
+## Template
+
+Use this structure:
+
+# RFC: <Title>
+
+**Author(s):** <name>
+**Reviewers:** <names/teams from interview>
+**Status:** Draft
+**Date:** <YYYY-MM-DD>
+
+## Abstract
+
+<!-- 1-3 sentences summarizing proposal and why -->
+
+## Background
+
+<!-- Context, history, prior work, relevant links -->
+
+## Problems We Need To Solve
+
+<!-- Bullet out concrete problems with evidence -->
+
+- Problem 1...
+- Problem 2...
+
+## Proposed Solution
+
+### Overview
+
+### Architecture / Implementation
+
+### Pros
+
+- ...
+
+### Cons / Tradeoffs
+
+- ...
+
+## Alternatives Considered
+
+### Alternative A
+
+- Summary
+- Pros
+- Cons
+
+## Open Questions
+
+<!-- Unresolved items needing feedback -->
+
+- Question 1...
+
+## Appendix
+
+<!-- Links to issues, docs, prior RFCs -->
+```
+
+The subagent will write the RFC file directly to the Output Path.
+
+**Naming convention**: `rfc-<topic>.md` or `rfc-<issue-id>-<topic>.md`
+
+### Document Verification
+
+After the doc-writer subagent returns, verify the RFC is complete.
+
+**Key sections to check** (lenient - only these 4):
+- `## Abstract`
+- `## Problems We Need To Solve`
+- `## Proposed Solution`
+- `## Alternatives Considered`
+
+**Verification steps:**
+
+1. **Read the RFC file** at the output path
+
+2. **If file missing or empty**:
+   - Warn user: "RFC file wasn't written. Writing directly..."
+   - Write the RFC yourself using the write tool
+
+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: "RFC written and verified (4/4 key sections present)."
+   - Proceed to Step 7.
+
+5. **If sections missing**:
+   - Warn user: "RFC appears incomplete. Missing sections: [list]"
+   - Ask: "Proceed with partial RFC, retry write, or abort?"
+
+## Step 7: Link to Session Context
+
+Add a reference to the RFC in `<git-root>/.bonfire/index.md` under Current State.
+
+## Step 8: Confirm
+
+Read the generated RFC and present a summary. Ask if user wants to:
+- Share with reviewers
+- Refine specific sections
+- Add more alternatives
+- Save for later
+
+## RFC Lifecycle
+
+RFCs progress through states:
+
+1. **Draft** - Initial creation, gathering feedback
+2. **In Review** - Shared with reviewers, collecting comments
+3. **Approved** - Accepted, ready for implementation
+4. **Rejected** - Not moving forward (document why)
+
+**When an RFC is approved**:
+- Create implementation specs from it
+- Link RFC in related issues/PRs
+- Keep RFC as historical record

package/package.json

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