opencode-goopspec 0.1.0

package/commands/goop-memory.md

@@ -0,0 +1,66 @@
+---
+name: goop-memory
+description: View memory system status and statistics
+---
+
+View the status and statistics of the persistent memory system.
+
+## Usage
+
+`/goop-memory` - Show memory system status
+`/goop-memory stats` - Show detailed statistics
+`/goop-memory clean` - Clean up old/low-importance memories
+
+## Instructions
+
+When this command is invoked:
+
+1. Check if memory system is running:
+   - Use `goop_status` to verify memory worker is active
+   - Report if memory is disabled
+
+2. Show memory statistics:
+   - Total memories stored
+   - Breakdown by type (decisions, observations, notes, etc.)
+   - Recent activity summary
+   - Storage usage
+
+3. If "stats" argument:
+   - Show detailed breakdown by type
+   - Show top concepts/tags
+   - Show importance distribution
+   - Show oldest and newest memories
+
+4. If "clean" argument:
+   - List memories that could be cleaned (old + low importance)
+   - Ask for confirmation before deleting
+   - Report what was cleaned
+
+## Example Output
+
+```
+## Memory System Status
+
+Status: Running (worker on port 37777)
+
+### Statistics
+- Total Memories: 127
+- Decisions: 23
+- Observations: 65
+- Notes: 31
+- Session Summaries: 8
+
+### Recent Activity
+- Last save: 5 minutes ago
+- Last search: 2 minutes ago
+- Memories today: 7
+
+### Top Concepts
+1. architecture (15 memories)
+2. typescript (12 memories)
+3. testing (9 memories)
+4. security (7 memories)
+5. performance (5 memories)
+```
+
+Provide visibility into the memory system's state.

package/commands/goop-milestone.md

@@ -0,0 +1,213 @@
+---
+name: goop-milestone
+description: Start a new milestone
+---
+
+# GoopSpec Milestone
+
+Start a new milestone - a major development cycle with multiple related features.
+
+## Usage
+
+```
+/goop-milestone [milestone name]
+```
+
+## What is a Milestone?
+
+A milestone is a collection of related features that together deliver significant value:
+
+**Examples:**
+- "Authentication System" (login, logout, password reset, OAuth)
+- "Payment Integration" (checkout, subscriptions, invoices)
+- "Admin Dashboard" (user management, analytics, settings)
+- "Mobile App" (iOS/Android apps with core features)
+
+**Not milestones:**
+- Single features (use `/goop-plan` instead)
+- Bug fixes (use `/goop-quick` instead)
+- Small enhancements (use `/goop-plan` instead)
+
+## What Happens
+
+1. **Milestone Planning** - Define scope and features:
+   - Milestone objectives
+   - Feature list
+   - Success criteria
+   - Timeline estimate
+
+2. **Create Milestone Structure**:
+   ```
+   .goopspec/
+   └── milestones/
+       └── milestone-1-auth-system/
+           ├── MILESTONE.md
+           ├── features/
+           │   ├── feature-1-login/
+           │   ├── feature-2-password-reset/
+           │   └── feature-3-oauth/
+           └── shared/
+   ```
+
+3. **Feature Breakdown** - Identify individual features within milestone
+
+4. **Dependency Mapping** - Determine feature order and dependencies
+
+5. **User Confirmation** - Confirm milestone scope before starting
+
+## MILESTONE.md Structure
+
+```markdown
+# Milestone: [Name]
+
+**Status:** Active | Complete
+**Started:** [Date]
+**Target:** [Date]
+**Progress:** [N/M features complete]
+
+## Objectives
+
+[What this milestone achieves]
+
+## Features
+
+### Feature 1: [Name]
+**Status:** Planned | In Progress | Complete
+**Dependencies:** None
+**Estimated Effort:** [Size]
+
+### Feature 2: [Name]
+**Status:** Planned
+**Dependencies:** Feature 1
+**Estimated Effort:** [Size]
+
+## Success Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+## Timeline
+
+- Week 1: Features 1-2
+- Week 2: Features 3-4
+- Week 3: Integration and polish
+
+## Notes
+
+[Important context, constraints, decisions]
+```
+
+## Milestone Workflow
+
+```
+/goop-milestone [name]
+    ↓
+Plan milestone scope
+    ↓
+Break into features
+    ↓
+For each feature:
+    /goop-plan → /goop-research → /goop-specify → /goop-execute → /goop-accept
+    ↓
+/goop-complete (archive milestone)
+```
+
+## Task Modes
+
+Milestones use **Comprehensive Mode**:
+- Deeper research per feature
+- More thorough planning
+- Extended verification
+- Formal retrospectives
+
+## Example
+
+Starting authentication system milestone:
+
+```
+/goop-milestone Authentication System
+```
+
+Agent creates:
+- MILESTONE.md with objectives
+- Feature breakdown:
+  - Feature 1: Email/password login
+  - Feature 2: Session management
+  - Feature 3: Password reset
+  - Feature 4: OAuth integration
+- Dependency map
+- Timeline estimate
+
+User confirms scope, then proceeds feature by feature.
+
+## Milestone Tracking
+
+Track progress with:
+
+```
+/goop-status
+```
+
+Shows:
+- Current milestone
+- Features complete/in-progress/planned
+- Overall progress percentage
+- Estimated completion
+
+## Milestone Completion
+
+When all features complete:
+
+```
+/goop-complete
+```
+
+This:
+- Archives milestone files
+- Generates retrospective
+- Extracts learnings
+- Tags git version
+- Prepares for next milestone
+
+## Best Practices
+
+### Good Milestone Scope
+
+**Right size:**
+- 3-8 related features
+- 1-4 weeks of work
+- Clear theme/objective
+- Delivers user value
+
+**Too small:**
+- Single feature (use `/goop-plan`)
+- < 1 week work
+- No clear theme
+
+**Too large:**
+- > 10 features
+- > 1 month work
+- Multiple unrelated areas
+- Split into multiple milestones
+
+### Milestone Planning
+
+1. **Start with objectives** - What value does this deliver?
+2. **List features** - What's needed to achieve objectives?
+3. **Map dependencies** - What order makes sense?
+4. **Estimate effort** - How long will this take?
+5. **Get confirmation** - Does user agree with scope?
+
+## Next Steps
+
+After milestone started:
+- `/goop-plan [feature]` - Plan first feature
+- `/goop-status` - Check milestone progress
+
+After milestone complete:
+- `/goop-milestone [next]` - Start next milestone
+- Review RETROSPECTIVE.md for insights
+
+---
+
+**GoopSpec**: Think in milestones, deliver in features.

package/commands/goop-pause.md

@@ -0,0 +1,61 @@
+---
+name: goop-pause
+description: Save a checkpoint to pause work
+---
+
+# GoopSpec Pause (Checkpoint)
+
+Save your current progress as a checkpoint that you can resume later.
+
+## Usage
+
+```
+/goop-pause [checkpoint-name]
+```
+
+## What Gets Saved
+
+A checkpoint captures:
+- Current session ID
+- Current phase and spec
+- Incomplete todos
+- Modified files
+- Git commit hash
+- Timestamp
+
+## Storage
+
+Checkpoints are saved to:
+`.goopspec/checkpoints/checkpoint-{id}.json`
+
+## Auto-Cleanup
+
+Old checkpoints are automatically cleaned up (configurable limit, default 10).
+
+## Example
+
+```
+/goop-pause "Before major refactor"
+```
+
+## Resume Later
+
+To resume from this checkpoint:
+```
+/goop-resume [checkpoint-id]
+```
+
+Or resume the latest:
+```
+/goop-resume
+```
+
+## Use Cases
+
+- End of work day - save and resume tomorrow
+- Before experimental changes - save as backup
+- Context switching - pause one task, work on another
+
+---
+
+**GoopSpec**: Never lose your place.

package/commands/goop-plan.md

@@ -0,0 +1,78 @@
+---
+name: goop-plan
+description: Start the Plan phase - capture intent and requirements
+---
+
+# GoopSpec Plan
+
+Capture user intent and establish the foundation for all subsequent work.
+
+## Usage
+
+```
+/goop-plan [brief description]
+```
+
+## Workflow Position
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│    PLAN     │ ──▶ │  RESEARCH   │ ──▶ │   SPECIFY   │
+│  (Intent)   │     │  (Explore)  │     │ (Contract)  │
+└─────────────┘     └─────────────┘     └─────────────┘
+     ↑
+(You are here)
+```
+
+The Plan phase answers: **What does the user want and why?**
+
+## What Happens
+
+1. **Intent Capture** - Extract core intent from your request
+2. **Clarifying Questions** - Resolve critical ambiguities
+3. **Requirements Gathering** - Categorize must/should/could/won't haves
+4. **Constraint Identification** - Document technical, time, resource limits
+5. **Success Criteria** - Define observable completion conditions
+6. **Memory Search** - Check for similar past work and preferences
+
+The agent will ask questions to understand:
+- Scope boundaries
+- Priority trade-offs
+- Performance/security requirements
+- Integration with existing features
+
+## Artifacts Created
+
+- Intent statement (what and why)
+- Requirements list (must/should/could/won't)
+- Constraints documentation
+- Success criteria
+
+## Example
+
+```
+/goop-plan Add user authentication with email/password
+```
+
+Agent captures:
+- **Intent:** Enable users to create accounts and log in
+- **Must haves:** Email/password login, session persistence
+- **Success:** User can log in and stay logged in across refresh
+
+## Next Steps
+
+After planning:
+- `/goop-research` - Research implementation approaches
+- `/goop-quick` - Skip research for simple tasks (Plan → Execute → Accept)
+
+## Quick Mode Shortcut
+
+For small tasks, Plan phase is abbreviated:
+- Capture intent in 1-2 sentences
+- Skip detailed requirements
+- Define one clear success criterion
+- Proceed directly to Execute
+
+---
+
+**GoopSpec**: Plan with precision, execute with confidence.

package/commands/goop-quick.md

@@ -0,0 +1,165 @@
+---
+name: goop-quick
+description: Execute small tasks with abbreviated workflow (Plan → Execute → Accept)
+---
+
+# GoopSpec Quick
+
+Execute small, ad-hoc tasks with GoopSpec guarantees using an abbreviated workflow.
+
+## Usage
+
+```
+/goop-quick [brief description]
+```
+
+## Workflow Position
+
+Quick mode uses a shortened path:
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│    PLAN     │ ──▶ │   EXECUTE   │ ──▶ │   ACCEPT    │
+│  (Intent)   │     │   (Build)   │     │  (Verify)   │
+└─────────────┘     └─────────────┘     └─────────────┘
+
+Research and Specify phases SKIPPED
+```
+
+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 |
+
+## 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)
+
+## Quick Mode Guarantees
+
+Even in quick mode, you still get:
+- Atomic commits
+- Deviation rule enforcement
+- Memory integration
+- Verification before acceptance
+- User confirmation gate
+
+What you skip:
+- Formal research
+- Locked specification
+- Wave-based planning
+- Comprehensive verification report
+
+## Next Steps
+
+After quick task:
+- `/goop-quick [next]` - Another quick task
+- `/goop-plan [feature]` - Start standard workflow
+- `/goop-status` - Check overall progress
+
+## Completion Prompt
+
+```
+╭─ ⬢ 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.           │
+│                                                    │
+╰────────────────────────────────────────────────────╯
+```
+
+---
+
+**GoopSpec**: Quick tasks, same guarantees.

package/commands/goop-recall.md

@@ -0,0 +1,48 @@
+---
+name: goop-recall
+description: Search and retrieve relevant memories from the persistent memory system
+---
+
+Search the persistent memory system for relevant context. Use this to:
+
+- Find past decisions related to the current task
+- Recall previous debugging insights
+- Retrieve architectural patterns from earlier sessions
+- Remember user preferences and project conventions
+
+## Usage
+
+`/goop-recall [query]` - Search memories for the given query
+`/goop-recall recent` - Show recent memories
+`/goop-recall decisions` - Show recent architectural decisions
+
+## Instructions
+
+When this command is invoked:
+
+1. Use `memory_search` to find relevant memories matching the query
+2. If query is "recent", use `memory_search` with a broad recent-focused query
+3. If query is "decisions", search specifically for type "decision"
+4. Present found memories in a clear, organized format:
+   - Show memory title, type, and date
+   - Include key facts and concepts
+   - Show importance score
+5. Suggest related searches if results are limited
+
+## Example Output
+
+```
+## Found 3 Relevant Memories
+
+### [decision] Use Zod for schema validation (Jan 15, 2026)
+Importance: 8/10
+Decided to use Zod over io-ts because of better TypeScript inference...
+Tags: validation, zod, architecture
+
+### [observation] ESLint flat config migration (Jan 14, 2026)
+Importance: 6/10  
+Migrated from .eslintrc to eslint.config.js...
+Tags: eslint, config, migration
+```
+
+Provide actionable context that helps with the current task.

package/commands/goop-remember.md

@@ -0,0 +1,71 @@
+---
+name: goop-remember
+description: Save important context, decisions, or notes to persistent memory
+---
+
+Save important information to the persistent memory system for future sessions. Use this to:
+
+- Log architectural decisions with reasoning
+- Store project conventions and patterns
+- Note important discoveries and insights
+- Save user preferences for future reference
+
+## Usage
+
+`/goop-remember [content]` - Save a memory with auto-detected type
+`/goop-remember decision: [content]` - Log an architectural decision
+`/goop-remember note: [content]` - Quick note
+`/goop-remember todo: [content]` - Create a durable task
+
+## Instructions
+
+When this command is invoked:
+
+1. Parse the content to determine the memory type:
+   - If starts with "decision:", use `memory_decision`
+   - If starts with "note:", use `memory_note`
+   - If starts with "todo:", use `memory_save` with type "todo"
+   - Otherwise, infer the best type based on content
+
+2. Extract key information:
+   - Create a clear, concise title
+   - Identify facts (atomic pieces of knowledge)
+   - Extract concepts/tags for semantic grouping
+   - Assess importance (1-10)
+
+3. Save to memory using appropriate tool:
+   - For decisions: Use `memory_decision` with reasoning
+   - For notes: Use `memory_note` 
+   - For others: Use `memory_save`
+
+4. Confirm what was saved:
+   - Show the memory ID
+   - Display the title and type
+   - List extracted concepts/tags
+
+## Example Usage
+
+```
+/goop-remember decision: Use TypeScript strict mode for all new files. Reasoning: Catches more bugs at compile time and improves refactoring safety.
+
+> Saved memory #42:
+> Title: Use TypeScript strict mode for all new files
+> Type: decision
+> Importance: 8/10
+> Reasoning: Catches more bugs at compile time and improves refactoring safety
+> Tags: typescript, config, code-quality
+```
+
+```
+/goop-remember note: The auth system uses JWT with refresh tokens. Access tokens expire in 15 minutes.
+
+> Saved memory #43:
+> Title: Auth system uses JWT with refresh tokens
+> Type: note
+> Facts:
+>   - Access tokens expire in 15 minutes
+>   - Uses refresh token pattern
+> Tags: auth, jwt, security
+```
+
+Make information persist across sessions for continuity.