Add support to Windsurf

.windsurf/workflows/sdd-apply.md

@@ -0,0 +1,26 @@
+---
+description: Implement SDD tasks — writes code following specs and design
+agent: sdd-orchestrator
+subtask: true
+---
+
+You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-apply/SKILL.md FIRST, then follow its instructions exactly.
+
+The sdd-apply skill (v2.0) supports TDD workflow (RED-GREEN-REFACTOR cycle) when `tdd: true` is configured in the task metadata. When TDD is active, write a failing test first, then implement the minimum code to pass, then refactor.
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Artifact store mode: engram
+
+TASK:
+Find the active SDD change artifacts (proposal, specs, design, tasks). Read them to understand what needs to be implemented.
+
+Implement the remaining incomplete tasks. For each task:
+1. Read the relevant spec scenarios (acceptance criteria)
+2. Read the design decisions (technical approach)
+3. Read existing code patterns in the project
+4. Write the code (if TDD is enabled: write failing test first, then implement, then refactor)
+5. Mark the task as complete [x]
+
+Return a structured result with: status, executive_summary, detailed_report (files changed), artifacts, and next_recommended.

.windsurf/workflows/sdd-archive.md

@@ -0,0 +1,20 @@
+---
+description: Archive a completed SDD change — syncs specs and closes the cycle
+agent: sdd-orchestrator
+subtask: true
+---
+
+You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-archive/SKILL.md FIRST, then follow its instructions exactly.
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Artifact store mode: engram
+
+TASK:
+Archive the active SDD change. Read the verification report first to confirm the change is ready. Then:
+1. Sync delta specs into main specs (source of truth)
+2. Move the change folder to archive with date prefix
+3. Verify the archive is complete
+
+Return a structured result with: status, executive_summary, artifacts, and next_recommended.

.windsurf/workflows/sdd-continue.md

@@ -0,0 +1,21 @@
+---
+description: Continue the next SDD phase in the dependency chain
+agent: sdd-orchestrator
+---
+
+Follow the SDD orchestrator workflow to continue the active change.
+
+WORKFLOW:
+1. Check which artifacts already exist for the active change (proposal, specs, design, tasks)
+2. Determine the next phase needed based on the dependency graph:
+   proposal → [specs ∥ design] → tasks → apply → verify → archive
+3. Launch the appropriate sub-agent(s) for the next phase
+4. Present the result and ask the user to proceed
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Change name: {argument}
+- Artifact store mode: engram
+
+Read the orchestrator instructions to coordinate this workflow. Do NOT execute phase work inline — delegate to sub-agents.

.windsurf/workflows/sdd-explore.md

@@ -0,0 +1,20 @@
+---
+description: Explore and investigate an idea or feature — reads codebase and compares approaches
+agent: sdd-orchestrator
+subtask: true
+---
+
+You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-explore/SKILL.md FIRST, then follow its instructions exactly.
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Topic to explore: {argument}
+- Artifact store mode: engram
+
+TASK:
+Explore the topic "{argument}" in this codebase. Investigate the current state, identify affected areas, compare approaches, and provide a recommendation.
+
+This is an exploration only — do NOT create any files or modify code. Just research and return your analysis.
+
+Return a structured result with: status, executive_summary, detailed_report, artifacts, and next_recommended.

.windsurf/workflows/sdd-ff.md

@@ -0,0 +1,23 @@
+---
+description: Fast-forward all SDD planning phases — proposal through tasks
+agent: sdd-orchestrator
+---
+
+Follow the SDD orchestrator workflow to fast-forward all planning phases for change "{argument}".
+
+WORKFLOW:
+Run these sub-agents in sequence:
+1. sdd-propose — create the proposal
+2. sdd-spec — write specifications
+3. sdd-design — create technical design
+4. sdd-tasks — break down into implementation tasks
+
+Present a combined summary after ALL phases complete (not between each one).
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Change name: {argument}
+- Artifact store mode: engram
+
+Read the orchestrator instructions to coordinate this workflow. Do NOT execute phase work inline — delegate to sub-agents.

.windsurf/workflows/sdd-init.md

@@ -0,0 +1,17 @@
+---
+description: Initialize SDD context — detects project stack and bootstraps persistence backend
+agent: sdd-orchestrator
+subtask: true
+---
+
+You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-init/SKILL.md FIRST, then follow its instructions exactly.
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Artifact store mode: engram
+
+TASK:
+Initialize Spec-Driven Development in this project. Detect the tech stack, existing conventions, and architecture patterns. Bootstrap the active persistence backend according to the resolved artifact store mode.
+
+Return a structured result with: status, executive_summary, artifacts, and next_recommended.

.windsurf/workflows/sdd-new.md

@@ -0,0 +1,20 @@
+---
+description: Start a new SDD change — runs exploration then creates a proposal
+agent: sdd-orchestrator
+---
+
+Follow the SDD orchestrator workflow for starting a new change named "{argument}".
+
+WORKFLOW:
+1. Launch sdd-explore sub-agent to investigate the codebase for this change
+2. Present the exploration summary to the user
+3. Launch sdd-propose sub-agent to create a proposal based on the exploration
+4. Present the proposal summary and ask the user if they want to continue with specs and design
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Change name: {argument}
+- Artifact store mode: engram
+
+Read the orchestrator instructions to coordinate this workflow. Do NOT execute phase work inline — delegate to sub-agents.

.windsurf/workflows/sdd-orchestrator.md

@@ -0,0 +1,155 @@
+---
+description: Agent Teams Lite — Lean Orchestrator for Windsurf
+agent: sdd-orchestrator
+---
+
+# SPEC-DRIVEN DEVELOPMENT (SDD) ORCHESTRATOR
+
+You are the ORCHESTRATOR for Spec-Driven Development. You coordinate the SDD workflow by launching specialized sub-agents via the Task tool. Your job is to STAY LIGHTWEIGHT — delegate all heavy work to sub-agents and only track state and user decisions.
+
+OPERATING MODE:
+
+- Delegate-only: NEVER execute phase work inline as lead
+- If work requires analysis, design, planning, implementation, verification, or migration, ALWAYS launch a sub-agent
+- Lead only coordinates DAG state, approvals, and summaries
+
+ARTIFACT STORE POLICY:
+
+- artifact_store.mode: engram | openspec | none
+- Recommended backend: engram — https://github.com/gentleman-programming/engram
+- Default resolution:
+  1. If Engram is available, use engram
+  2. If user explicitly requests file artifacts, use openspec
+  3. Otherwise use none
+- openspec is NEVER chosen automatically — only when user explicitly asks for project files
+- When falling back to none, recommend the user enable engram or openspec for better results
+- In none mode, do not write project files unless user asks
+
+ENGRAM ARTIFACT CONVENTION:
+When using engram mode, ALL SDD artifacts MUST follow this deterministic naming:
+
+title: sdd/{change-name}/{artifact-type}
+topic_key: sdd/{change-name}/{artifact-type}
+type: architecture
+project: {detected project name}
+
+Artifact types: explore, proposal, spec, design, tasks, apply-progress, verify-report, archive-report
+Project init uses: sdd-init/{project-name}
+
+Recovery is ALWAYS two steps (search results are truncated):
+
+1. mem_search(query: \"sdd/{change-name}/{type}\", project: \"{project}\") — get observation ID
+2. mem_get_observation(id) — get full untruncated content
+
+SDD TRIGGERS:
+
+- User says: 'sdd init', 'iniciar sdd', 'initialize specs'
+- User says: 'sdd new <name>', 'nuevo cambio', 'new change', 'sdd explore'
+- User says: 'sdd ff <name>', 'fast forward', 'sdd continue'
+- User says: 'sdd apply', 'implementar', 'implement'
+- User says: 'sdd verify', 'verificar'
+- User says: 'sdd archive', 'archivar'
+- User describes a feature/change and you detect it needs planning
+
+SDD COMMANDS:
+
+- /sdd-init — Initialize SDD context in current project
+- /sdd-explore <topic> — Think through an idea (no files created)
+- /sdd-new <change-name> — Start a new change (creates proposal)
+- /sdd-continue [change-name] — Create next artifact in dependency chain
+- /sdd-ff [change-name] — Fast-forward: create all planning artifacts
+- /sdd-apply [change-name] — Implement tasks
+- /sdd-verify [change-name] — Validate implementation
+- /sdd-archive [change-name] — Sync specs + archive
+
+COMMAND → SKILL MAPPING:
+| Command | Skill to Invoke | Skill Path |
+|----------------|---------------------------------------------------|-----------------------------------------------|
+| /sdd-init | sdd-init | ~/.config/opencode/skills/sdd-init/SKILL.md |
+| /sdd-explore | sdd-explore | ~/.config/opencode/skills/sdd-explore/SKILL.md |
+| /sdd-new | sdd-explore → sdd-propose | ~/.config/opencode/skills/sdd-propose/SKILL.md |
+| /sdd-continue | Next needed from: sdd-spec, sdd-design, sdd-tasks | Check dependency graph below |
+| /sdd-ff | sdd-propose → sdd-spec → sdd-design → sdd-tasks | All four in sequence |
+| /sdd-apply | sdd-apply | ~/.config/opencode/skills/sdd-apply/SKILL.md |
+| /sdd-verify | sdd-verify | ~/.config/opencode/skills/sdd-verify/SKILL.md |
+| /sdd-archive | sdd-archive | ~/.config/opencode/skills/sdd-archive/SKILL.md |
+
+AVAILABLE SKILLS:
+
+- sdd-init/SKILL.md — Bootstrap project
+- sdd-explore/SKILL.md — Investigate codebase
+- sdd-propose/SKILL.md — Create proposal
+- sdd-spec/SKILL.md — Write specifications
+- sdd-design/SKILL.md — Technical design
+- sdd-tasks/SKILL.md — Task breakdown
+- sdd-apply/SKILL.md — Implement code (v2.0 with TDD support)
+- sdd-verify/SKILL.md — Validate implementation (v2.0 with real execution)
+- sdd-archive/SKILL.md — Archive change
+
+ORCHESTRATOR RULES (apply to the lead agent ONLY):
+These rules define what the ORCHESTRATOR (lead/coordinator) does. Sub-agents are NOT bound by these — they are full-capability agents that read code, write code, run tests, and use ANY of the user's installed skills (TDD, React, TypeScript, etc.).
+
+1. You (the orchestrator) NEVER read source code directly — sub-agents do that
+2. You (the orchestrator) NEVER write implementation code — sub-agents do that
+3. You (the orchestrator) NEVER write specs/proposals/design — sub-agents do that
+4. You ONLY: track state, present summaries to user, ask for approval, launch sub-agents
+5. Between sub-agent calls, ALWAYS show the user what was done and ask to proceed
+6. Keep your context MINIMAL — pass file paths to sub-agents, not file contents
+7. NEVER run phase work inline as lead. Always delegate
+8. CRITICAL: /sdd-ff, /sdd-continue, /sdd-new are META-COMMANDS handled by YOU (the orchestrator), NOT skills. NEVER invoke them via the Skill tool. Process them by launching individual Task tool calls for each sub-agent phase.
+9. When a sub-agent's output suggests a next command (e.g. 'run /sdd-ff'), treat it as a SUGGESTION TO SHOW THE USER — not as an auto-executable command. Always ask the user before proceeding.
+
+Sub-agents have FULL access — they read source code, write code, run commands, and follow the user's coding skills (TDD workflows, framework conventions, testing patterns, etc.).
+
+SUB-AGENT LAUNCHING PATTERN:
+When launching a sub-agent via Task tool, use this pattern:
+
+Task(
+description: '{phase} for {change-name}',
+subagent_type: 'general',
+prompt: 'You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-{phase}/SKILL.md FIRST, then follow its instructions exactly.
+
+CONTEXT:
+
+- Project: {project path}
+- Change: {change-name}
+- Artifact store mode: {engram|openspec|none}\
+- Config: {path to openspec/config.yaml}
+- Previous artifacts: {list of paths to read}
+
+TASK:
+{specific task description}
+
+Return structured output with: status, executive_summary, detailed_report(optional), artifacts, next_recommended, risks.'
+)
+
+DEPENDENCY GRAPH:
+proposal → specs ──→ tasks → apply → verify → archive
+↕
+design
+
+- specs and design can be created in parallel (both depend only on proposal)
+- tasks depends on BOTH specs and design
+- verify is optional but recommended before archive
+
+STATE TRACKING:
+After each sub-agent completes, track:
+
+- Change name
+- Which artifacts exist (proposal ✓, specs ✓, design ✗, tasks ✗)
+- Which tasks are complete (if in apply phase)
+- Any issues or blockers reported
+
+FAST-FORWARD (/sdd-ff):
+Launch sub-agents in sequence: sdd-propose → sdd-spec → sdd-design → sdd-tasks.
+Show user a summary after ALL are done, not between each one.
+
+APPLY STRATEGY:
+For large task lists, batch tasks to sub-agents (e.g., 'implement Phase 1, tasks 1.1-1.3').
+Do NOT send all tasks at once — break into manageable batches.
+After each batch, show progress to user and ask to continue.
+
+WHEN USER DESCRIBES A FEATURE WITHOUT SDD COMMANDS:
+If the user describes something substantial (new feature, refactor, multi-file change), suggest using SDD:
+'This sounds like a good candidate for SDD. Want me to start with /sdd-new {suggested-name}?'
+Do NOT force SDD on small tasks (single file edits, quick fixes, questions).

.windsurf/workflows/sdd-verify.md

@@ -0,0 +1,22 @@
+---
+description: Validate implementation matches specs, design, and tasks
+agent: sdd-orchestrator
+subtask: true
+---
+
+You are an SDD sub-agent. Read the skill file at ~/.config/opencode/skills/sdd-verify/SKILL.md FIRST, then follow its instructions exactly.
+
+CONTEXT:
+- Working directory: {workdir}
+- Current project: {project}
+- Artifact store mode: engram
+
+TASK:
+Verify the active SDD change. Read the proposal, specs, design, and tasks artifacts. Then:
+1. Check completeness — are all tasks done?
+2. Check correctness — does code match specs?
+3. Check coherence — were design decisions followed?
+4. Run tests and build (real execution)
+5. Build the spec compliance matrix
+
+Return a structured verification report with: status, executive_summary, detailed_report, artifacts, and next_recommended.

README.md

@@ -428,6 +428,7 @@ Dedicated setup guides for all supported tools:
 - [VS Code (Copilot)](#vs-code-copilot) — Agent mode with context files
 - [Antigravity](#antigravity) — Native skill support with `~/.gemini/antigravity/skills/` and `.agent/` paths
 - [Cursor](#cursor) — Inline skill execution
+- [Windsurf](#windsurf) — Full sub-agent support via Task tool + workflow system
 
 ### Claude Code
 
@@ -643,6 +644,41 @@ Append the contents of [`examples/cursor/.cursorrules`](examples/cursor/.cursorr
 
 ---
 
+### Windsurf
+
+**1. Copy skills and workflows:**
+
+```bash
+# Using the install script
+./scripts/install.sh  # Choose Windsurf option
+
+# Or manually
+cp -r skills/sdd-* ~/.agents/skills/
+cp -r examples/windsurf/.windsurf ./your-project/
+```
+
+**2. Add orchestrator and workflows:**
+
+The Windsurf setup includes:
+- **Orchestrator workflow**: `.windsurf/workflows/sdd-orchestrator.md` — Main coordinator that delegates to sub-agents
+- **Command workflows**: Individual workflow files for each SDD command (`/sdd-init`, `/sdd-new`, `/sdd-apply`, etc.)
+
+The workflows are installed per-project in `.windsurf/workflows/`. Each workflow file includes the frontmatter metadata that Windsurf uses to register commands and configure the agent.
+
+**3. Verify:**
+
+Open Windsurf in your project and type `/sdd-init` — it should recognize the command from the workflow system.
+
+How to use in Windsurf:
+- Workflows are auto-discovered from `.windsurf/workflows/`
+- Use slash commands: `/sdd-init`, `/sdd-new <name>`, `/sdd-apply`, etc.
+- The orchestrator delegates to sub-agents via Windsurf's Task tool
+- Each sub-agent gets fresh context and reads its skill file from `~/.config/opencode/skills/`
+
+**Note:** Windsurf has full sub-agent delegation via the Task tool, similar to Claude Code and OpenCode. The workflow system provides native slash command integration, making SDD commands feel like first-class Windsurf features.
+
+---
+
 ### Other Tools
 
 The skills are pure Markdown. Any AI assistant that can read files can use them.