opencode-goopspec 0.1.0

package/skills/goop-core/skill.md

@@ -0,0 +1,383 @@
+---
+name: goop-core
+description: Core GoopSpec 0.1.0 operations - the 5-phase spec-driven workflow
+category: core
+triggers:
+  - goop
+  - spec
+  - workflow
+  - plan
+  - execute
+version: 0.1.0
+---
+
+# GoopSpec 0.1.0 Core Operations
+
+## The 5-Phase Workflow
+
+GoopSpec follows a disciplined spec-driven development cycle:
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│  Phase 1    │     │  Phase 2    │     │  Phase 3    │
+│  DISCUSS    │ ──▶ │    PLAN     │ ──▶ │  EXECUTE    │
+│ (Gather     │     │ (Create     │     │ (Wave-based │
+│  reqs)      │     │  PLAN.md)   │     │  impl)      │
+└─────────────┘     └─────────────┘     └─────────────┘
+                                              │
+                                              ▼
+                    ┌─────────────┐     ┌─────────────┐
+                    │  Phase 5    │     │  Phase 4    │
+                    │  CONFIRM    │ ◀── │   AUDIT     │
+                    │ (User       │     │ (Verify     │
+                    │  approval)  │     │  against    │
+                    └─────────────┘     │  spec)      │
+                                        └─────────────┘
+```
+
+**Phase 0**: Intent Gate (classify every incoming request)
+**Phase 1**: Discuss (gather requirements, clarify scope)
+**Phase 2**: Plan (create detailed execution plan)
+**Phase 3**: Execute (wave-based implementation)
+**Phase 4**: Audit (verify against requirements)
+**Phase 5**: Confirm (get user approval)
+
+### Phase 1: Discuss
+- Gather requirements through conversation
+- Ask clarifying questions
+- Identify edge cases and constraints
+- Challenge assumptions respectfully
+- Output: Clear understanding of what to build
+
+### Phase 2: Plan
+- Create detailed PLAN.md with waves and tasks
+- Break work into atomic, verifiable tasks
+- Identify dependencies between tasks
+- Define acceptance criteria for each task
+- Output: PLAN.md ready for execution
+
+### Phase 3: Execute
+- Wave-based implementation
+- Atomic commits per task
+- Track progress with checkpoints
+- Apply deviation rules (auto-fix vs ask)
+- Output: Working code
+
+### Phase 4: Audit
+- Verify implementation against requirements
+- Check all acceptance criteria are met
+- Review code quality and security
+- Identify any gaps or issues
+- Output: Audit report
+
+### Phase 5: Confirm (ACCEPTANCE GATE)
+- Present summary to user
+- Get explicit user approval
+- Handle change requests if needed
+- Archive completed work
+- Output: Accepted deliverable
+
+---
+
+## Planning Markdown Files
+
+GoopSpec uses markdown files for state and coordination:
+
+| File | Purpose |
+|------|---------|
+| `SPEC.md` | Locked specification with must-haves and nice-to-haves |
+| `BLUEPRINT.md` | Execution plan with waves and tasks |
+| `CHRONICLE.md` | Journey log tracking progress and decisions |
+| `RESEARCH.md` | Research findings from exploration phase |
+| `RETROSPECTIVE.md` | Post-completion analysis (for milestones) |
+| `LEARNINGS.md` | Extracted patterns and insights (archived) |
+
+### Directory Structure
+
+```
+.goopspec/
+├── SPEC.md              # Current specification
+├── BLUEPRINT.md         # Current execution plan
+├── CHRONICLE.md         # Current journey log
+├── RESEARCH.md          # Current research findings
+├── quick/               # Quick task history
+│   └── 001-task-name/
+│       └── SUMMARY.md
+├── milestones/          # Active milestones
+│   └── v1.0-feature/
+└── archive/             # Completed milestones
+    └── v0.9-setup/
+        ├── RETROSPECTIVE.md
+        └── LEARNINGS.md
+```
+
+---
+
+## Task Modes
+
+GoopSpec scales to the task size:
+
+| Mode | When | Workflow |
+|------|------|----------|
+| **Quick** | Bug fixes, small changes | Plan → Execute → Accept |
+| **Standard** | Features, moderate work | Full 5-phase workflow |
+| **Comprehensive** | Complex systems | Full workflow + deep research |
+| **Milestone** | Major releases | Multiple cycles + archive |
+
+### Quick Mode
+- Skip Research and Specify phases
+- For tasks under ~30 minutes
+- Still uses memory and atomic commits
+- Tracked in `.goopspec/quick/`
+
+### Standard Mode
+- Full 5-phase workflow
+- For features taking hours to a day
+- Contract gate at Specify
+- Acceptance gate at end
+
+### Comprehensive Mode
+- Extended research phase
+- Multiple parallel research agents
+- Detailed specification
+- Multiple execution waves
+
+### Milestone Mode
+- Groups related work into versioned milestone
+- Archives on completion
+- Extracts learnings to memory
+- Tags git with version
+
+---
+
+## Task Format
+
+GoopSpec uses markdown for task definitions (not XML):
+
+```markdown
+### Task 1.1: [Action-oriented name]
+
+**Files**: path/to/file.ext, other/file.ext
+**Action**: [What to do, how, and why]
+**Verify**: [Command or check to prove completion]
+**Done**: [Measurable acceptance criteria]
+```
+
+### Wave Structure
+
+```markdown
+## Wave 1: [Theme]
+
+### Task 1.1: [Name]
+...
+
+### Task 1.2: [Name]
+...
+
+## Wave 2: [Theme]
+...
+```
+
+---
+
+## Contract Gates
+
+Two mandatory confirmation points:
+
+### Specify Gate (Pre-Execution)
+```
+"I've captured the requirements in SPEC.md:
+- Must have: [list]
+- Nice to have: [list]
+- Out of scope: [list]
+
+Please confirm this specification before I proceed."
+```
+
+User must explicitly confirm before execution begins.
+
+### Accept Gate (Post-Execution)
+```
+"Implementation complete. Verification against spec:
+- [Requirement 1]: ✓ Implemented
+- [Requirement 2]: ✓ Implemented
+
+Please confirm acceptance or request changes."
+```
+
+User must explicitly accept before marking complete.
+
+---
+
+## Core Principles
+
+### The Continuation Mandate
+The agent continues until spec tasks are complete. If todos remain incomplete, enforced task continuation keeps work moving. Checkpoints allow pausing, but completion requires all must-haves delivered.
+
+### Goal-Backward Verification
+Don't just complete tasks - verify that the code delivers what was promised. Task completion ≠ Goal achievement. Always trace back to the original intent.
+
+### Vertical Slices Over Horizontal Layers
+```
+PREFER: Wave 1 = Complete User Feature (model + API + UI)
+AVOID:  Wave 1 = All Models, Wave 2 = All APIs, Wave 3 = All UIs
+```
+
+### Memory-First Protocol
+All agents follow the memory protocol:
+1. Search memory for relevant past decisions before starting
+2. Save important observations and decisions during work
+3. Persist learnings to memory after completion
+
+### Orchestrator as Conductor
+The orchestrator NEVER writes code. It coordinates, delegates, and maintains context. All implementation is delegated to specialized subagents.
+
+---
+
+## Deviation Rules
+
+### Rule 1: Auto-fix Bugs
+Fix immediately without asking:
+- Wrong logic, type errors, infinite loops
+- Security vulnerabilities (SQL injection, XSS)
+- Broken validation, race conditions
+- Memory/resource leaks
+
+### Rule 2: Auto-add Missing Critical Functionality
+Add immediately without asking:
+- Error handling (try-catch, promise rejection)
+- Input validation and sanitization
+- Null/undefined checks
+- Authentication/authorization checks
+- Rate limiting on public APIs
+
+### Rule 3: Auto-fix Blocking Issues
+Fix immediately without asking:
+- Missing dependencies
+- Broken import paths
+- Missing environment variables
+- Config errors
+- Circular dependencies
+
+### Rule 4: Ask About Architectural Changes
+STOP and ask user for:
+- New database tables (not just columns)
+- Schema changes (primary keys, table splits)
+- Framework/library switches
+- New infrastructure (queues, caches, CDNs)
+- Breaking API changes
+- New deployment environments
+
+---
+
+## Commands
+
+### Workflow Commands
+| Command | Description |
+|---------|-------------|
+| `/goop-discuss [description]` | Capture user vision, gather requirements |
+| `/goop-plan [description]` | Create detailed execution plan |
+| `/goop-execute` | Begin wave-based execution |
+| `/goop-accept` | Verify and accept completion |
+
+### Task Mode Commands
+| Command | Description |
+|---------|-------------|
+| `/goop-quick [task]` | Fast-track small task |
+| `/goop-milestone [name]` | Start versioned milestone |
+| `/goop-complete` | Complete and archive milestone |
+
+### Utility Commands
+| Command | Description |
+|---------|-------------|
+| `/goop-status` | Show workflow status |
+| `/goop-amend` | Propose spec changes |
+| `/goop-recall [query]` | Search persistent memory |
+| `/goop-remember [content]` | Save to persistent memory |
+| `/goop-pause [name]` | Save checkpoint |
+| `/goop-resume [id]` | Resume from checkpoint |
+
+---
+
+## Commit Format
+
+```
+type(wave-task): description
+
+- Detail 1
+- Detail 2
+```
+
+Types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
+
+Example:
+```
+feat(w1-t2): implement user authentication API
+
+- Add /auth/login and /auth/logout endpoints
+- Integrate JWT token generation
+- Add refresh token rotation
+```
+
+---
+
+## Status Indicators
+
+| Symbol | Meaning |
+|--------|---------|
+| `[OK]` | Complete/Passed |
+| `[FAIL]` | Failed/Error |
+| `[WARN]` | Warning/Attention Required |
+| `[INFO]` | Informational |
+| `[WORK]` | In Progress |
+| `[WAIT]` | Waiting/Blocked |
+| `[GATE]` | User Confirmation Required |
+
+---
+
+## Archive System
+
+When a milestone completes:
+
+1. **Move** milestone to `archive/`
+2. **Generate** RETROSPECTIVE.md (what worked, what didn't)
+3. **Extract** LEARNINGS.md (patterns, decisions, gotchas)
+4. **Persist** learnings to memory for future recall
+5. **Tag** git with milestone version
+
+### Learning Extraction
+
+Learnings are persisted with semantic concepts for search:
+
+```
+memory_save({
+  type: "observation",
+  title: "Milestone Learning: [name]",
+  concepts: ["auth", "jwt", "security"],
+  facts: ["jose library better than jsonwebtoken for ESM"],
+  importance: 0.8
+})
+```
+
+### Recall
+
+Use `/goop-recall` to search past work:
+
+```
+/goop-recall "how did we handle auth?"
+→ Returns relevant learnings from archived milestones
+```
+
+---
+
+## Quick Reference
+
+```
+WORKFLOW:    Discuss → Plan → Execute → Audit → Confirm
+FILES:       PLAN.md, SPEC.md, ADL.md (decisions), checkpoints
+MODES:       Quick, Standard, Comprehensive, Milestone
+GATES:       Confirm (user approval required)
+RULES:       Auto-fix bugs/blocking, Ask for architecture
+AGENTS:      Orchestrator coordinates, Subagents execute
+MEMORY:      Search before, save during, persist after
+```

package/skills/memory-usage/skill.md

@@ -0,0 +1,208 @@
+---
+name: memory-usage
+description: How to effectively use the memory system to remember and recall information
+category: core
+triggers:
+  - memory
+  - remember
+  - recall
+  - save for later
+  - persistent
+version: 0.1.0
+---
+
+# Memory System Usage Guide
+
+You have access to a persistent memory system that allows you to save and retrieve information across sessions. Use it wisely to provide better context-aware assistance.
+
+## Available Tools
+
+### `memory_save`
+Save important information to persistent memory.
+
+**When to use:**
+- User expresses a preference ("I prefer TypeScript")
+- You make an architectural decision
+- You discover important patterns in the codebase
+- You learn something that should persist
+
+**Example:**
+```
+memory_save(
+  title="User prefers functional React components",
+  content="User explicitly stated preference for functional components with hooks over class components.",
+  type="observation",
+  facts=["User prefers functional components", "Hooks preferred over class lifecycle"],
+  concepts=["react", "components", "preference"],
+  importance=8
+)
+```
+
+### `memory_search`
+Search your memory for relevant information.
+
+**When to use:**
+- Before making decisions that might have prior context
+- When user asks about previous work
+- When you need to recall preferences or patterns
+- At the start of new conversations about familiar topics
+
+**Example:**
+```
+memory_search(
+  query="user preferences for React components",
+  limit=5,
+  types=["observation", "decision"]
+)
+```
+
+### `memory_note`
+Quick way to save brief notes.
+
+**When to use:**
+- Quick observations that might be useful later
+- Temporary reminders
+- Brief insights
+
+**Example:**
+```
+memory_note(
+  note="The authentication service is in /src/services/auth.ts",
+  concepts=["auth", "services"]
+)
+```
+
+### `memory_decision`
+Record important decisions with reasoning.
+
+**When to use:**
+- Architecture decisions
+- Technology choices
+- Design trade-offs
+- Any decision that might need to be referenced later
+
+**Example:**
+```
+memory_decision(
+  decision="Use PostgreSQL for the database",
+  reasoning="Better JSON support needed for storing user preferences, and we anticipate complex analytical queries",
+  alternatives=["MySQL", "MongoDB"],
+  impact="high",
+  concepts=["database", "architecture"]
+)
+```
+
+### `memory_forget`
+Delete memories that are outdated or incorrect.
+
+**When to use:**
+- Information becomes outdated
+- You stored something incorrect
+- Cleaning up temporary notes
+
+**Example:**
+```
+memory_forget(id=123)  // Delete by ID
+memory_forget(query="outdated API endpoint", confirm=true)  // Delete by search
+```
+
+## Best Practices
+
+### What to Remember
+
+**HIGH PRIORITY (importance 8-10):**
+- User preferences and coding style
+- Project-specific decisions
+- Architecture patterns
+- Technology choices
+
+**MEDIUM PRIORITY (importance 5-7):**
+- Codebase patterns discovered
+- Bug fixes and their solutions
+- Feature implementation details
+- Configuration details
+
+**LOW PRIORITY (importance 3-4):**
+- Routine observations
+- Temporary context
+- Session-specific notes
+
+### What NOT to Remember
+
+**NEVER store:**
+- API keys, passwords, tokens
+- Private keys or secrets
+- Personal information
+- Content inside `<private>` tags
+- Large code blocks (store file paths instead)
+
+### Memory Hygiene
+
+1. **Be specific with titles** - They show up in search results
+2. **Extract atomic facts** - Each fact should stand alone
+3. **Use consistent concepts** - Helps with future searches
+4. **Set appropriate importance** - Higher importance = more likely to surface
+5. **Include source files** - Helps locate related code
+
+## Search Strategy
+
+1. **Before starting work:** Search for relevant context
+   ```
+   memory_search(query="<topic I'm about to work on>")
+   ```
+
+2. **After learning something:** Save it for later
+   ```
+   memory_save(title="...", content="...", ...)
+   ```
+
+3. **When asked about history:** Search first
+   ```
+   memory_search(query="previous work on <topic>")
+   ```
+
+## Integration with Goop Workflow
+
+Memory integrates with the Goop workflow phases:
+
+- **Discuss:** Search for relevant prior context
+- **Plan:** Save important decisions and constraints
+- **Execute:** Save observations about the codebase
+- **Audit:** Note any issues discovered
+- **Confirm:** Save summary of what was accomplished
+
+## Privacy
+
+Always respect privacy:
+- Content in `<private>...</private>` tags is never stored
+- Sensitive patterns (API keys, etc.) are automatically redacted
+- When in doubt, ask before storing
+
+## Examples of Good Memories
+
+**User Preference:**
+```
+Title: User prefers tabs over spaces
+Content: User explicitly stated preference for tabs (width 2) for indentation in all code.
+Facts: ["Use tabs for indentation", "Tab width should be 2"]
+Concepts: ["formatting", "preference", "style"]
+Importance: 9
+```
+
+**Architecture Decision:**
+```
+Title: Chose event sourcing for order system
+Content: Decided to use event sourcing pattern for the order management system to maintain complete audit history.
+Facts: ["Order system uses event sourcing", "Full audit history required"]
+Concepts: ["architecture", "event-sourcing", "orders"]
+Importance: 8
+```
+
+**Codebase Pattern:**
+```
+Title: API routes follow RESTful naming convention
+Content: All API routes in /src/api/ follow strict RESTful naming: GET /resources, GET /resources/:id, POST /resources, etc.
+Facts: ["RESTful API naming", "Routes in /src/api/"]
+Concepts: ["api", "rest", "conventions"]
+Importance: 6
+```