@tudeorangbiasa/sdd-multiagent-opencode 0.1.4 → 0.2.0

package/.opencode/skills/sdd-implementation/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: sdd-implementation
-description: Systematic code implementation patterns for SDD workflows. Activates when executing planned implementations, following todo-lists, or building features according to specifications. Use with /implement command.
+description: Systematic implementation patterns for /sdd-apply. Use when executing approved SDD tasks from specs/active/<change-id>/tasks.md.
 ---
 
 ## What I do
 
 - Guide systematic execution of planned implementations
-- Enforce todo-list discipline with progress tracking
+- Enforce `tasks.md` checklist discipline with progress tracking
 - Ensure code follows existing patterns and conventions
 - Handle blockers with structured escalation
 - Coordinate with sdd-verifier for post-implementation validation
@@ -14,15 +14,15 @@ description: Systematic code implementation patterns for SDD workflows. Activate
 ## When to use me
 
 Use this skill when:
-- Running `/implement` command
-- Executing tasks from a plan or roadmap
+- Running `/sdd-apply` command
+- Executing tasks from `specs/active/<change-id>/tasks.md`
 - Need systematic progress tracking during implementation
 - Building features according to specifications
 
 ## Implementation Protocol
 
 ### Before Starting
-1. Read `plan.md`, `tasks.md`, `todo-list.md`, and `spec.md`
+1. Read `proposal.md`, `spec.md`, `design.md`, and `tasks.md`
 2. Understand the full scope before writing code
 3. Identify potential blockers early
 
@@ -42,8 +42,8 @@ Use this skill when:
 
 ### After Completion
 1. Spawn `sdd-verifier` to validate implementation
-2. Update todo-list with final status
-3. Document discoveries for `/evolve`
+2. Update `tasks.md` with final status
+3. Document discoveries in the relevant artifact and explain the deviation
 
 ## Code Quality Standards
 
@@ -53,11 +53,9 @@ Use this skill when:
 - Write tests for new functionality
 - No secrets or credentials in code
 
-## TDD Mode (Optional)
+## Test-First Mode (When Requested)
 
-When `--tdd` flag is specified, follow this protocol instead of the standard approach:
-
-### TDD Loop per Task
+When the user explicitly asks for test-first implementation, follow this loop per task:
 
 1. **Write failing test first**
    - Create test file: `tests/[feature].test.ts`
@@ -77,7 +75,7 @@ When `--tdd` flag is specified, follow this protocol instead of the standard app
    - Only after test passes
    - Keep test passing during refactor
 
-### TDD Rules
+### Test-First Rules
 - Never write implementation before failing test
 - Test must fail BEFORE implementation starts
 - Only implement enough to pass the test

package/.opencode/skills/sdd-planning/SKILL.md

@@ -1,45 +1,36 @@
 ---
 name: sdd-planning
-description: Architecture design and planning patterns for SDD workflows. Activates when generating technical plans, breaking down tasks, or creating feature briefs. Use with /brief, /plan, /tasks, /specify commands.
+description: Compact SDD planning for /sdd-propose. Use when generating proposal, spec, design, and tasks for one focused change.
 ---
 
 ## What I do
 
-- Transform specifications into actionable technical plans
-- Guide architecture design with Mermaid diagrams
-- Break down features into 2-8 hour tasks with DAG dependencies
-- Create feature briefs for quick planning workflows
+- Transform one focused change request into reviewable artifacts
+- Guide compact architecture and implementation design
+- Break down features into small ordered tasks
 - Estimate effort and identify technical risks
 
 ## When to use me
 
 Use this skill when:
-- Running `/brief`, `/plan`, `/tasks`, or `/specify` commands
-- A spec exists and needs technical architecture
-- Breaking down a feature into implementation tasks
+- Running `/sdd-propose` command
+- A change needs technical architecture
+- Breaking down a change into implementation tasks
 - Need to estimate effort and identify risks
 
 ## Planning Protocol
 
-### Brief Planning (30 min)
-1. Parse feature description, extract requirements
-2. Quick codebase scan for existing patterns
-3. Ask clarifying questions if needed
-4. Generate feature-brief.md with problem, users, requirements, approach
-
-### Full Planning (60 min)
-1. Read spec.md thoroughly
-2. Analyze codebase constraints via `codebase-memory-mcp`
-3. Design architecture with Mermaid diagrams
-4. Define components, APIs, data models
-5. Assess risks and open questions
+### Proposal Planning
+1. Parse the request and derive a safe change id
+2. Scan the codebase for existing patterns
+3. Ask at most 3 clarifying questions if needed
+4. Generate `proposal.md`, `spec.md`, `design.md`, and `tasks.md`
 
 ### Task Breakdown
-1. Read plan.md
-2. Organize into phases: Setup → Core → Integration → Polish
-3. Break into 2-8 hour tasks
-4. Define dependencies for DAG execution
-5. Populate `sdd.touchedFiles` for parallel execution safety
+1. Organize tasks in implementation order
+2. Keep each task small and independently verifiable
+3. Include verification steps for each phase
+4. Call out dependencies and risky file overlaps
 
 ## Estimation Heuristics
 
@@ -53,7 +44,7 @@ Use this skill when:
 ## Output Templates
 
 Use templates from `.sdd/templates/`:
-- `feature-brief-v2.md` for briefs
-- `spec-compact.md` for specifications
-- `plan-compact.md` for technical plans
-- `tasks-compact.md` for task breakdowns
+- `proposal-template.md`
+- `spec-template.md`
+- `design-template.md`
+- `tasks-template.md`

package/.opencode/skills/sdd-research/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sdd-research
-description: Structured investigation patterns for SDD workflows. Activates when researching technical approaches, evaluating external solutions, or investigating codebase patterns. Use with /research command.
+description: Structured investigation patterns for /sdd-explore. Use when researching existing code, external options, or technical tradeoffs before proposing a change.
 ---
 
 ## What I do
@@ -13,7 +13,7 @@ description: Structured investigation patterns for SDD workflows. Activates when
 ## When to use me
 
 Use this skill when:
-- Running `/research` command
+- Running `/sdd-explore` command
 - Technical approach is unclear and needs investigation
 - Evaluating multiple technologies or approaches
 - Need to understand existing codebase patterns before planning
@@ -26,7 +26,7 @@ Use this skill when:
 3. **Comparison** — Create pros/cons matrix for top 3 options
 4. **Recommendation** — Primary + alternative with rationale
 
-### Deep Research (`--deep` flag)
+### Deeper Research
 1. **Pass 1 — Landscape:** `exa_web_search_exa` to identify top 3-5 candidates
 2. **Pass 2 — Documentation:** `webfetch` official docs, API references, pricing
 3. **Pass 3 — Validation:** Search for production reviews, benchmarks, comparisons
@@ -39,6 +39,6 @@ Use this skill when:
 | Medium | Established blogs, Stack Overflow (high votes), GitHub issues (resolved) |
 | Low | Personal blogs, forum posts, outdated articles |
 
-## Output Templates
+## Output
 
-Use the research.md template from `.sdd/templates/research-compact.md`
+Return findings, options, a recommendation, and the next `/sdd-propose` command. Do not implement code.

package/.sdd/config.json

@@ -10,16 +10,16 @@
     "autoNumberFeatures": true,
     "requireReviews": true,
     "collaborationMode": true,
-    "defaultWorkflow": "brief",
+    "defaultWorkflow": "sdd-propose",
     "planningTimeLimit": 30,
     "maxParallelImplementers": 4,
     "templates": {
-      "brief": ".sdd/templates/feature-brief-v2.md",
-      "spec": ".sdd/templates/spec-compact.md",
-      "plan": ".sdd/templates/plan-compact.md",
-      "tasks": ".sdd/templates/tasks-compact.md",
-      "research": ".sdd/templates/research-compact.md",
-      "todo": ".sdd/templates/todo-compact.md"
+      "proposal": ".sdd/templates/proposal-template.md",
+      "spec": ".sdd/templates/spec-template.md",
+      "design": ".sdd/templates/design-template.md",
+      "tasks": ".sdd/templates/tasks-template.md",
+      "progress": ".sdd/templates/progress-template.md",
+      "verification": ".sdd/templates/verification-template.md"
     }
   },
   "directories": {
@@ -29,8 +29,8 @@
     "backlog": "specs/backlog"
   },
   "workflow": {
-    "phases": ["specify", "plan", "tasks", "implement", "review", "complete"],
-    "requiredFiles": ["spec.md", "plan.md", "tasks.md"],
-    "optionalFiles": ["progress.md", "reviews.md", "notes.md"]
+    "phases": ["explore", "propose", "apply", "ship"],
+    "requiredFiles": ["proposal.md", "spec.md", "design.md", "tasks.md"],
+    "optionalFiles": ["progress.md", "verification.md", "status.md", "notes.md"]
   }
 }

package/.sdd/templates/design-template.md

@@ -0,0 +1,21 @@
+# Design: <Change Title>
+
+## Existing Patterns
+
+- `[path]`: [pattern to follow]
+
+## Approach
+
+[Technical approach in concise bullets or paragraphs.]
+
+## Files Likely To Change
+
+- `[path]`: [expected change]
+
+## Risks
+
+- [Risk]: [mitigation]
+
+## Verification
+
+- `[command]`: [what it proves]

package/.sdd/templates/model-profile-template.json

@@ -1,9 +1,41 @@
 {
-  "defaultPrimary": "opencode/minimax-m2.5-free",
+  "_info": {
+    "description": "Model routing configuration. Edit this file to change which model each agent uses. Restart OpenCode after editing.",
+    "requirement": "SDD requires at least ONE paid/subscription model for orchestrator and planner. These roles need strong reasoning that free models cannot provide.",
+    "subscription_options": {
+      "opencode_go": "$10/month — includes GLM 5.1, Kimi K2.5, MiniMax M2.5/M2.7",
+      "kimi_moderato": "Kimi K2.6 with vision support",
+      "openai_plus": "GPT 5.5 with reasoning and multimodal",
+      "glm_lite": "GLM 5.1 with strong reasoning",
+      "openrouter": "Access to frontier reasoning models"
+    },
+    "paid_models": {
+      "opencode/gpt-5.5": "Best for orchestrator/planner — strongest reasoning + multimodal",
+      "opencode/claude-sonnet-4-5": "Excellent for planner — code understanding and reasoning",
+      "opencode/claude-opus-4-5": "Maximum capability for complex architecture planning",
+      "opencode/kimi-k2.6": "Strong reasoning + vision, good alternative for planner",
+      "opencode/glm-5.1": "Strong reasoning, good for orchestrator/planner"
+    },
+    "free_models": {
+      "opencode/qwen3.6-plus-free": "Multimodal — best for verifier (Chrome DevTools screenshots)",
+      "opencode/deepseek-v4-flash-free": "Fast code gen — best for explorer and implementer",
+      "opencode/minimax-m2.5-free": "Structured output — best for reviewer (code review)",
+      "opencode/nemotron-3-super-free": "1M context — good for exploration tasks"
+    },
+    "recommendations": {
+      "orchestrator": "PAID: GPT 5.5 or Claude Sonnet 4.5 — needs strong reasoning for DAG coordination",
+      "planner": "PAID: GPT 5.5 or Claude Opus 4.5 — needs maximum reasoning for architecture",
+      "explorer": "FREE: DeepSeek v4 Flash — fast readonly exploration, token-efficient",
+      "implementer": "FREE: DeepSeek v4 Flash — code generation, high token usage",
+      "verifier": "FREE: Qwen3.6 Plus — multimodal for Chrome DevTools screenshots",
+      "reviewer": "FREE: MiniMax M2.5 — structured code review output"
+    }
+  },
+  "defaultPrimary": "opencode/gpt-5.5",
   "small": "opencode/deepseek-v4-flash-free",
   "agents": {
-    "sdd-orchestrator": "opencode/minimax-m2.5-free",
-    "sdd-planner": "opencode/qwen3.6-plus-free",
+    "sdd-orchestrator": "opencode/gpt-5.5",
+    "sdd-planner": "opencode/gpt-5.5",
     "sdd-explorer": "opencode/deepseek-v4-flash-free",
     "sdd-implementer": "opencode/deepseek-v4-flash-free",
     "sdd-verifier": "opencode/qwen3.6-plus-free",

package/.sdd/templates/progress-template.md

@@ -0,0 +1,23 @@
+# Progress: <Change Title>
+
+## Status
+
+- phase: propose|apply|ship
+- ready_for_next_task: yes|no
+- last_updated: <date>
+
+## Completed
+
+- [Task id or title]
+
+## Blocked
+
+- [Task id or title]: [reason]
+
+## Decisions During Apply
+
+- [Decision]: [reason]
+
+## Next Safe Task
+
+[The next task that can be resumed with minimal context.]

package/.sdd/templates/project-profile-template.json

@@ -26,8 +26,8 @@
     "codeReview": "sdd-reviewer"
   },
   "sddSettings": {
-    "defaultBriefTemplate": "feature-brief-v2",
+    "defaultWorkflow": "sdd-propose",
     "autoCheckpoint": true,
     "compactAtPercent": 80
   }
-}
+}

package/.sdd/templates/proposal-template.md

@@ -0,0 +1,22 @@
+# Proposal: <Change Title>
+
+## Problem
+
+[What problem this change solves.]
+
+## Goals
+
+- [Goal 1]
+- [Goal 2]
+
+## Non-Goals
+
+- [What is intentionally out of scope]
+
+## User Impact
+
+[Who is affected and how behavior changes.]
+
+## Success Criteria
+
+- [ ] [Observable success condition]

package/.sdd/templates/reasoning-profile-template.json

@@ -13,13 +13,9 @@
     "sdd-reviewer": "medium"
   },
   "commands": {
-    "brief": "medium",
-    "research": "medium",
-    "specify": "high",
-    "plan": "high",
-    "tasks": "high",
-    "implement": "medium",
-    "execute-parallel": "high",
-    "audit": "medium"
+    "sdd-explore": "medium",
+    "sdd-propose": "high",
+    "sdd-apply": "medium",
+    "sdd-ship": "medium"
   }
 }

package/.sdd/templates/spec-template.md

@@ -0,0 +1,19 @@
+# Spec: <Change Title>
+
+## Requirements
+
+- [Requirement 1]
+- [Requirement 2]
+
+## Acceptance Criteria
+
+- [ ] [Verifiable outcome]
+- [ ] [Verifiable outcome]
+
+## Edge Cases
+
+- [Edge case and expected behavior]
+
+## Out Of Scope
+
+- [Excluded behavior]

package/.sdd/templates/tasks-template.md

@@ -0,0 +1,8 @@
+# Tasks: <Change Title>
+
+- [ ] 1. [Task]
+  - Verification: `[command or check]`
+- [ ] 2. [Task]
+  - Verification: `[command or check]`
+- [ ] 3. [Task]
+  - Verification: `[command or check]`

package/.sdd/templates/verification-template.md

@@ -0,0 +1,17 @@
+# Verification: <Change Title>
+
+## Findings
+
+- critical: none
+- major: none
+- minor: none
+
+## Commands
+
+- passed: `[command]`
+- failed: none
+- not run: none
+
+## Decision
+
+ready: no

package/GUIDE.md

@@ -0,0 +1,128 @@
+# SDD Multi-Agent OpenCode Guide
+
+This kit exposes one small workflow for OpenCode:
+
+```text
+/sdd-explore -> /sdd-propose -> /sdd-apply -> /sdd-ship
+```
+
+It is inspired by spec-driven development, but it is not a port of another tool. The goal is to make OpenCode safer on real projects by separating investigation, planning, implementation, and final verification.
+
+## Commands
+
+| Command | Purpose | Writes Code? |
+|---------|---------|--------------|
+| `/sdd-explore` | Investigate unclear ideas, bugs, or code areas | No |
+| `/sdd-propose` | Create one focused change plan | No |
+| `/sdd-apply` | Implement an approved change | Yes |
+| `/sdd-ship` | Verify readiness before merge/release | No, unless explicitly asked |
+
+## Default Flow
+
+```text
+/sdd-propose change-id "what should change"
+    -> review specs/active/change-id/
+/sdd-apply change-id
+/sdd-ship change-id
+```
+
+Use `/sdd-explore` first only when the problem is unclear.
+
+## When To Use Each Command
+
+### `/sdd-explore`
+
+Use this when you need understanding before deciding what to build.
+
+```text
+/sdd-explore "admin UI feels messy, find reusable component opportunities"
+/sdd-explore invoice-delete "why invoice delete sometimes fails"
+```
+
+This command should return findings, options, and a recommended next `/sdd-propose` command. It must not implement code.
+
+### `/sdd-propose`
+
+Use this when you know the change you want.
+
+```text
+/sdd-propose ui-admin-components "modularize admin UI into reusable components"
+/sdd-propose "add password reset flow"
+```
+
+It creates:
+
+```text
+specs/active/<change-id>/
+├── proposal.md
+├── spec.md
+├── design.md
+├── tasks.md
+└── progress.md        optional for large changes
+```
+
+Review these files before applying. This is the agreement point.
+
+### `/sdd-apply`
+
+Use this after the proposal is accepted.
+
+```text
+/sdd-apply ui-admin-components
+```
+
+It reads the artifacts, implements `tasks.md`, updates checkboxes, and runs targeted verification when possible.
+
+For large changes, it uses `progress.md` as a checkpoint so work can resume without relying on chat history. If tasks touch disjoint files, it can run safe batches in parallel through subagents; otherwise it runs sequentially.
+
+### `/sdd-ship`
+
+Use this before calling the change done.
+
+```text
+/sdd-ship ui-admin-components
+```
+
+It audits the implementation against the artifacts and writes:
+
+```text
+specs/active/<change-id>/verification.md
+```
+
+## Example: New Feature
+
+```text
+/sdd-propose auth-reset "add secure password reset by email"
+/sdd-apply auth-reset
+/sdd-ship auth-reset
+```
+
+## Example: Bug Fix
+
+```text
+/sdd-explore invoice-delete "deleting invoices sometimes fails in production"
+/sdd-propose invoice-delete "fix invoice delete failure with regression coverage"
+/sdd-apply invoice-delete
+/sdd-ship invoice-delete
+```
+
+## Example: Refactor
+
+```text
+/sdd-explore admin-ui "check whether admin UI is modular and reusable"
+/sdd-propose admin-ui-components "extract reusable admin layout and form components"
+/sdd-apply admin-ui-components
+/sdd-ship admin-ui-components
+```
+
+## Design Principles
+
+- Four commands only by default.
+- No fake flags like `--deep` or `--until-finish`.
+- No source code changes during explore/propose.
+- One change folder per unit of work.
+- Planning artifacts are compact and reviewable.
+- Proposals must cite real project files or clearly say what was not found.
+- Long-running apply work must checkpoint to `progress.md`.
+- Parallel execution is a capability inside `/sdd-apply`, not a separate command.
+- Verification is a first-class step, not a vague final message.