opencode-goopspec 0.1.2 → 0.1.4

package/commands/goop-quick.md

@@ -1,165 +1,61 @@
 ---
 name: goop-quick
-description: Execute small tasks with abbreviated workflow (Plan → Execute → Accept)
+description: Fast-track a small task
 ---
 
-# GoopSpec Quick
+# /goop-quick
 
-Execute small, ad-hoc tasks with GoopSpec guarantees using an abbreviated workflow.
+**Execute small tasks fast.** Abbreviated workflow for simple changes.
 
 ## Usage
 
+```bash
+/goop-quick [task description]
 ```
-/goop-quick [brief description]
-```
-
-## Workflow Position
 
-Quick mode uses a shortened path:
+## Tools Used
 
-```
-┌─────────────┐     ┌─────────────┐     ┌─────────────┐
-│    PLAN     │ ──▶ │   EXECUTE   │ ──▶ │   ACCEPT    │
-│  (Intent)   │     │   (Build)   │     │  (Verify)   │
-└─────────────┘     └─────────────┘     └─────────────┘
-
-Research and Specify phases SKIPPED
-```
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `goop_status` | Check current state, skip heavy workflow |
+| `memory_search` | Find relevant prior context |
+| `memory_save` | Persist any discoveries |
 
-Quick mode skips:
-- Research phase (assumes existing patterns sufficient)
-- Specify phase (intent serves as implicit spec)
-- Formal SPEC.md and BLUEPRINT.md
-- Comprehensive verification
-
-## When to Use Quick Mode
-
-**Good for:**
-- Fix a specific bug
-- Add a small feature
-- Refactor a specific function
-- Update documentation
-- Add a test
-- Configure a tool
-- 15-60 minutes of work
-
-**Too big for quick mode:**
-- New major feature
-- Architecture changes
-- Multiple interdependent changes
-- Unknown problem domain
-- Anything requiring research
-
-## What Happens
-
-1. **Quick Planning** - Abbreviated Plan phase:
-   - Capture intent in 1-2 sentences
-   - Define one clear success criterion
-   - Skip detailed requirements
-
-2. **Direct Execution** - Simplified Execute phase:
-   - 1-2 waves maximum
-   - Faster delegation
-   - Less formal tracking
-   - Atomic commits still required
-
-3. **Quick Acceptance** - Abbreviated Accept phase:
-   - Quick verification
-   - No formal report
-   - Simple confirmation prompt
-
-## Artifacts Created
-
-- `.goopspec/quick/NNN-slug/PLAN.md` - Brief task plan
-- `.goopspec/quick/NNN-slug/SUMMARY.md` - Completion summary
-- Git commits (atomic, per task)
-- STATE.md updated with quick task entry
-
-## Task Size Guide
-
-| Duration | Appropriate? |
-|----------|--------------|
-| < 15 min | Yes (might be too simple) |
-| 15-30 min | Ideal |
-| 30-60 min | Good |
-| 1-2 hours | Borderline |
-| > 2 hours | Use standard workflow |
+**Hook Support:** Minimal - quick mode bypasses most phase enforcement.
 
-## Example
-
-```
-/goop-quick Fix login button styling to match design system
-```
-
-Agent:
-1. Captures intent: "Update login button to use design system styles"
-2. Success criterion: "Button matches design system colors and spacing"
-3. Executes: Modify button component, update styles
-4. Commits: `fix(quick): update login button to match design system`
-5. Verifies: Visual check, no errors
-6. Presents for acceptance
-
-## Good Quick Task Examples
-
-**GOOD:**
-- "Fix the login button styling"
-- "Add validation to the email field"
-- "Update the README with new setup steps"
-- "Refactor the auth utility to use async/await"
-- "Add unit test for user validation"
+---
 
-**TOO BIG:**
-- "Implement user authentication" (use standard workflow)
-- "Add payment processing" (use standard workflow)
-- "Refactor the entire codebase" (use milestone)
+## How It Works
 
-## Quick Mode Guarantees
+Quick mode bypasses the formal Plan/Research/Specify phases while maintaining safety guarantees. Ideal for bug fixes, small refactors, or docs.
 
-Even in quick mode, you still get:
-- Atomic commits
-- Deviation rule enforcement
-- Memory integration
-- Verification before acceptance
-- User confirmation gate
+### 1. Implicit Planning
+- Captures intent in 1 sentence.
+- Defines 1 clear success criterion.
+- Skips formal `SPEC.md`.
 
-What you skip:
-- Formal research
-- Locked specification
-- Wave-based planning
-- Comprehensive verification report
+### 2. Rapid Execution
+- Creates a simplified 1-Wave Blueprint.
+- Executes immediately.
+- Still performs atomic commits.
 
-## Next Steps
+### 3. Quick Acceptance
+- Verifies the fix.
+- Asks for confirmation.
 
-After quick task:
-- `/goop-quick [next]` - Another quick task
-- `/goop-plan [feature]` - Start standard workflow
-- `/goop-status` - Check overall progress
+## When to Use
+- **Good:** "Fix the typo in the navbar", "Update dependency X", "Add a unit test".
+- **Bad:** "Add user auth", "Refactor entire API". (Use `/goop-plan` for these).
 
-## Completion Prompt
+## Output
 
-```
-╭─ ⬢ GoopSpec ───────────────────────────────────────╮
-│                                                    │
-│  ⚡ QUICK TASK COMPLETE                            │
-│                                                    │
-│  Task: Fix login button styling                   │
-│                                                    │
-│  Duration: 12 minutes                              │
-│  Files: 1 modified                                 │
-│  Commits: 1                                        │
-│                                                    │
-│  VERIFICATION:                                     │
-│  ☑ Button matches design system                    │
-│  ☑ No console errors                               │
-│  ☑ Tests passing                                   │
-│                                                    │
-│  ─────────────────────────────────────────────     │
-│  Type "accept" to confirm.                         │
-│  Type "issues: [description]" for fixes.           │
-│                                                    │
-╰────────────────────────────────────────────────────╯
-```
+- Atomic commits.
+- `.goopspec/quick/` logs (for history).
 
----
+## Example
 
-**GoopSpec**: Quick tasks, same guarantees.
+> **User:** `/goop-quick Fix the z-index on the modal`
+> **Agent:** "Plan: Adjust z-index in `Modal.css`. Success: Modal appears above overlay.
+> Executing...
+> Done (commit: x9y8z7). Modal z-index set to 1000.
+> Verified. Type 'accept' to close."

package/commands/goop-recall.md

@@ -16,6 +16,17 @@ Search the persistent memory system for relevant context. Use this to:
 `/goop-recall recent` - Show recent memories
 `/goop-recall decisions` - Show recent architectural decisions
 
+## Tools Used
+
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `memory_search` | Search persistent memories |
+| `session_search` | Search session history |
+
+**Hook Support:** None specific - read-only query.
+
+---
+
 ## Instructions
 
 When this command is invoked:

package/commands/goop-remember.md

@@ -17,6 +17,18 @@ Save important information to the persistent memory system for future sessions.
 `/goop-remember note: [content]` - Quick note
 `/goop-remember todo: [content]` - Create a durable task
 
+## Tools Used
+
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `memory_save` | Store structured memories |
+| `memory_decision` | Record decisions with reasoning |
+| `memory_note` | Quick note capture |
+
+**Hook Support:** `system.transform` uses saved memories in future sessions.
+
+---
+
 ## Instructions
 
 When this command is invoked:

package/commands/goop-research.md

@@ -1,98 +1,77 @@
 ---
 name: goop-research
-description: Start the Research phase - explore implementation approaches
+description: Launch research for unknowns or risks
+agent: goop-researcher
+spawn: true
+phase: research
+next-step: "Apply research findings to create or refine the plan"
+next-command: /goop-plan
+alternatives:
+  - command: /goop-research
+    when: "For additional research on related topics"
+  - command: /goop-specify
+    when: "If research confirms the plan is ready to lock"
 ---
 
-# GoopSpec Research
+# /goop-research
 
-Gather context and explore implementation approaches before committing to a specification.
+**Start the Research Phase.** Explore unknowns, compare options, and gather technical context.
 
 ## Usage
 
+```bash
+/goop-research [topic or question]
 ```
-/goop-research
-```
-
-## Workflow Position
-
-```
-┌─────────────┐     ┌─────────────┐     ┌─────────────┐
-│    PLAN     │ ──▶ │  RESEARCH   │ ──▶ │   SPECIFY   │
-│  (Intent)   │     │  (Explore)  │     │ (Contract)  │
-└─────────────┘     └─────────────┘     └─────────────┘
-                          ↑
-                    (You are here)
-```
-
-The Research phase answers: **How should we build this?**
-
-## What Happens
 
-1. **Parallel Agent Spawning** - Multiple agents work simultaneously:
-   - **Researcher** - Deep domain research (technologies, patterns, best practices)
-   - **Explorer** - Codebase analysis (existing patterns, conventions, integration points)
-   - **Librarian** - Documentation gathering (API docs, library guides, examples)
-   - **Designer** - (UI tasks only) Visual research (patterns, components, UX)
+## Tools Used
 
-2. **Research Areas Covered:**
-   - Technology options and trade-offs
-   - Existing codebase patterns
-   - Domain knowledge and edge cases
-   - Security and performance considerations
-   - Industry standards and best practices
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `goop_status` | Check current phase allows research |
+| `memory_search` | Find prior research on same topic |
+| `memory_save` | Persist research findings |
+| `goop_skill` | Load specialized research skills |
 
-3. **Consolidation** - Findings merged into RESEARCH.md with:
-   - Technology recommendations
-   - Codebase integration points
-   - Key decisions needed
-   - Risk assessment
-   - Estimated complexity
+**Hook Support:** `system.transform` injects prior research context.
 
-4. **Memory Integration** - Past research and patterns retrieved
-
-## Artifacts Created
-
-- `RESEARCH.md` - Consolidated research findings
-- Technology comparison table
-- Recommended approach with rationale
-- Risk catalog
-- Integration points identified
+---
 
-## Example
+## How It Works
 
-After planning "Add user authentication":
+Research is an **opt-in** phase used when the path forward isn't clear. It prevents "coding in the dark."
 
-```
-/goop-research
-```
+### 1. Scope Definition
+The agent confirms what needs to be learned:
+- Technical feasibility
+- Library/Tool selection
+- Architectural patterns
+- Bug root cause analysis
 
-Research agents explore:
-- JWT vs session-based auth
-- Existing auth patterns in codebase
-- Security best practices
-- Library options (jose, jsonwebtoken, etc.)
-- Integration with current user model
+### 2. Investigation
+The `goop-researcher` subagent performs:
+- **Web Search:** For latest docs and libraries.
+- **Code Search:** For examples and usage patterns.
+- **Memory Search:** For past learnings.
 
-## Next Steps
+### 3. Synthesis
+Findings are compiled into a structured report with a clear recommendation.
 
-After research:
-- `/goop-specify` - Lock the specification (CONTRACT GATE)
+## Output
 
-## Quick Mode Shortcut
+- `.goopspec/RESEARCH.md`: Detailed findings and trade-offs.
+- **Memory:** Key learnings are persisted for future recall.
 
-For Quick tasks, Research phase is **SKIPPED entirely**:
-- Assumes existing patterns are sufficient
-- No parallel agent spawning
-- Jumps directly from Plan to Execute
+## Transitions
 
-## Comprehensive Mode
+- **Next Step:** `/goop-plan` to apply findings to a plan.
+- **Loop:** `/goop-research` can be run multiple times for deep dives.
 
-For Comprehensive tasks:
-- Deeper research per agent
-- More alternatives explored
-- Extended timeframe
-- User reviews RESEARCH.md before Specify
+## Examples
 
----
+**Library Selection:**
+> **User:** `/goop-research best react animation library for minimal bundle size`
+> **Agent:** "I'll compare Framer Motion, React Spring, and a CSS-only approach."
 
-**GoopSpec**: Research thoroughly, decide confidently.
+**Technical Feasibility:**
+> **User:** `/goop-research can we use WebSockets on Vercel serverless?`
+> **Agent:** "Investigating Vercel platform limits and workaround options like Pusher."

package/commands/goop-resume.md

@@ -1,57 +1,48 @@
 ---
 name: goop-resume
-description: Resume from a checkpoint
+description: Resume from a saved checkpoint
 ---
 
-# GoopSpec Resume
+# /goop-resume
 
-Resume your work from a saved checkpoint.
+**Resume from a checkpoint.** Restore context and continue work.
 
 ## Usage
 
-```
+```bash
 /goop-resume [checkpoint-id]
 ```
 
-## What Gets Restored
-
-When resuming:
-- Session context is restored
-- Current phase is set
-- Active spec is loaded
-- Todos are displayed
-- Modified files list is shown
+## Tools Used
 
-## Without Checkpoint ID
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `goop_checkpoint` | Load saved execution state |
+| `goop_status` | Verify current state matches checkpoint |
+| `memory_search` | Find context from when checkpoint was saved |
 
-If no checkpoint ID is provided, loads the **most recent** checkpoint.
-
-## Example
-
-```
-/goop-resume
-```
+**Hook Support:** `system.transform` injects checkpoint context automatically.
 
-Or specify a specific checkpoint:
-```
-/goop-resume checkpoint-abc123
-```
+---
 
-## Workflow
+## How It Works
 
-1. **Load checkpoint data**
-2. **Restore session context**
-3. **Display current todos**
-4. **Show relevant files**
-5. **Ready to continue work**
+Loads a saved state, restores the workflow context, and prepares the agent to continue exactly where it left off.
 
-## See Available Checkpoints
+### Behavior
+- **No ID:** Resumes the most recent checkpoint.
+- **With ID:** Resumes specific checkpoint (e.g., `/goop-resume cp-123`).
 
-To list all checkpoints:
-```
-Use the goop_checkpoint tool with action: "list"
-```
+### What Happens
+1. **Load State:** Reads the checkpoint JSON.
+2. **Restore Context:** Re-initializes the Orchestrator at the correct phase/wave.
+3. **Status Check:** Runs a quick status check to confirm environment matches.
+4. **Prompt:** Reminds user of the next pending task.
 
----
+## Example
 
-**GoopSpec**: Pick up exactly where you left off.
+> **User:** `/goop-resume`
+> **Agent:** "Resuming session from 2 hours ago.
+> Phase: Execute (Wave 2).
+> Next Task: [2.2] Implement handler.
+> Ready to continue?"