sdd-mcp-server 3.3.0 → 3.5.0

package/README.md

@@ -6,7 +6,26 @@
 
 A Model Context Protocol (MCP) server implementing Spec-Driven Development (SDD) workflows for AI-agent CLIs and IDEs like Claude Code, Cursor, and others.
 
-> **v3.3** - Multi-tool install support: `--codex` (AGENTS.md for OpenAI Codex CLI), `--antigravity` (.agent/ symlinks for Google Antigravity), `--all-tools`. See [CHANGELOG.md](CHANGELOG.md) for full version history.
+> **v3.5.0** - Target-aware native Codex and Claude Code installation, model routing, portable Codex hooks, and hardened failure reporting. See [CHANGELOG.md](CHANGELOG.md) for full version history.
+
+## Why sdd-mcp?
+
+Most AI coding workflows start as prompts and Markdown conventions. `sdd-mcp` adds a stateful MCP workflow layer so assistants can validate progress, enforce approvals, load the right amount of context, and keep long-running SDD work repeatable.
+
+```text
+sdd-init -> requirements -> approve -> design -> approve -> tasks -> review tests -> approve -> implement
+                         \-> compact handoff generated automatically ->/
+```
+
+### Compared With Superpowers and OpenSpec
+
+| Project | Best For | Main Strength | sdd-mcp Difference |
+|---------|----------|---------------|--------------------|
+| [Superpowers](https://github.com/obra/superpowers) | Agentic skill-driven development | Automatic skill activation, strong TDD culture, subagent workflows | `sdd-mcp` is MCP-native and keeps workflow state in tools, approvals, validation, and generated handoffs |
+| [OpenSpec](https://github.com/Fission-AI/OpenSpec) | Lightweight spec artifacts | Simple propose/apply/archive flow with broad tool support | `sdd-mcp` uses stricter phase gates, explicit review checkpoints, and compact context loading for governed workflows |
+| `sdd-mcp` | Repeatable SDD across MCP-compatible clients | Stateful tools, compact context handoffs, TDD checkpoints, quality gates | Optimized for teams that need enforceable workflow control rather than only guidance files |
+
+Use `sdd-mcp` when you want the AI assistant to follow a governed lifecycle, not just remember a convention from chat history.
 
 ## 🚀 Quick Start
 
@@ -16,7 +35,7 @@ A Model Context Protocol (MCP) server implementing Spec-Driven Development (SDD)
 npx -y sdd-mcp-server@latest
 
 # Pin exact version (optional)
-npx -y sdd-mcp-server@1.6.0
+npx -y sdd-mcp-server@3.5.0
 
 # For Claude Code MCP integration, add to your configuration:
 # "sdd-mcp-server": {
@@ -31,7 +50,7 @@ npx -y sdd-mcp-server@1.6.0
 npm install -g sdd-mcp-server@latest
 
 # Pin exact version (optional)
-npm install -g sdd-mcp-server@1.6.0
+npm install -g sdd-mcp-server@3.5.0
 
 # Start the server
 sdd-mcp-server
@@ -140,54 +159,68 @@ npm install -g sdd-mcp-server@latest
 sdd-mcp-server
 ```
 
-## 🎯 Agent Skills (NEW in v1.9.0)
+## 🎯 Agent Skills & Components (v3.5.0)
 
 SDD now uses a **hybrid architecture** for better token efficiency:
 
 - **MCP Tools**: Action-oriented operations (init, status, approve, quality-check, validate, spec-impl)
 - **Agent Skills**: Template/guidance-heavy operations (requirements, design, tasks, steering, implement, commit)
 
-### Installing Components (v3.0+)
+### Installing Components (v3.5.0)
 
 ```bash
-# Recommended: Install ALL components (skills, steering, rules, contexts, agents, hooks)
-npx sdd-mcp-server install --all
+# Lean compatibility install (defaults to Claude Code when non-interactive)
+npx sdd-mcp-server install
+
+# Full install prompts for Codex or Claude Code in an interactive terminal
+npx sdd-mcp-server install --profile full
 
-# Install specific component types
-npx sdd-mcp-server install --skills      # Skills to .claude/skills/
-npx sdd-mcp-server install --steering    # Steering to .spec/steering/
-npx sdd-mcp-server install --rules       # Rules to .claude/rules/
-npx sdd-mcp-server install --contexts    # Contexts to .claude/contexts/
-npx sdd-mcp-server install --agents      # Agents to .claude/agents/
-npx sdd-mcp-server install --hooks       # Hooks to .claude/hooks/
+# Automation and CI should select the target explicitly
+npx sdd-mcp-server install --profile full --target codex
+npx sdd-mcp-server install --profile full --target claude-code
+
+# Install selected components using that target's native paths
+npx sdd-mcp-server install --target codex --skills --rules --agents
+npx sdd-mcp-server install --target claude-code --skills --rules --agents
 
 # Install multiple component types
 npx sdd-mcp-server install --skills --rules --agents
 
-# Default: Install skills + steering (backward compatible)
-npx sdd-mcp-server install
-
 # List all available components
 npx sdd-mcp-server install --list
 
 # Legacy: Install skills only
 npx sdd-mcp-server install-skills
 
-# Multi-tool support (v3.3+)
-npx sdd-mcp-server install --codex             # + AGENTS.md for OpenAI Codex CLI
+# Compatibility and additional integrations
+npx sdd-mcp-server install --codex             # Deprecated alias for --target codex
 npx sdd-mcp-server install --antigravity       # + .agent/ symlinks for Google Antigravity
 npx sdd-mcp-server install --all-tools         # + all tool integrations
 ```
 
-**Component Types (v3.0):**
-| Component | Install Path | Purpose |
-|-----------|--------------|---------|
-| **Skills** | `.claude/skills/` | Workflow guidance (requirements, design, tasks, implement, etc.) |
-| **Steering** | `.spec/steering/` | Project-specific templates (product, tech, structure) |
-| **Rules** | `.claude/rules/` | Always-active guidelines (coding-style, testing, security, git-workflow) |
-| **Contexts** | `.claude/contexts/` | Mode-specific prompts (dev, review, planning, security-audit, research) |
-| **Agents** | `.claude/agents/` | Specialized AI personas (planner, architect, reviewer, implementer) |
-| **Hooks** | `.claude/hooks/` | Event-driven automation (pre-tool-use, post-tool-use, session events) |
+The installer creates only the selected primary target's native artifacts, preserves existing files, and updates the project's existing `.gitignore` with a managed block. `CLAUDE.md`, `AGENTS.md`, and `.spec/steering/` remain trackable.
+
+**Target paths:**
+
+| Component | Claude Code | Codex |
+|-----------|-------------|-------|
+| **Root guidance** | `CLAUDE.md` | `AGENTS.md` |
+| **Skills** | `.claude/skills/` | `.agents/skills/` |
+| **Steering** | `.spec/steering/` | `.spec/steering/` |
+| **Rules** | `.claude/rules/` | `.codex/guidance/rules/` |
+| **Contexts** | `.claude/contexts/` | `.codex/guidance/contexts/` |
+| **Agents** | `.claude/agents/*.md` | `.codex/agents/*.toml` |
+| **Hooks** | `.claude/hooks/` | `.codex/hooks.json`, `.codex/hooks/` |
+
+**Token-aware specialist routing:**
+
+| Work | Codex | Claude Code |
+|------|-------|-------------|
+| Planning, architecture, review, security | `gpt-5.6-sol` (`xhigh`) | `opus` |
+| Implementation and TDD (default) | `gpt-5.6-luna` (`max`) | `sonnet` |
+
+Codex uses `gpt-5.6-luna` as the default model for routed work. High-level advisor roles override that default with `gpt-5.6-sol` at xhigh effort. `gpt-5.6-terra` remains supported but is not selected by a default SDD role.
+For a detailed explanation of role selection, native agent metadata, delegation, and rerun behavior, see [Model Routing](docs/MODEL-ROUTING.md).
 
 ### Component Architecture & Relationships
 
@@ -208,11 +241,12 @@ The 6 component types work together in a **layered guidance model**:
                               │
                               ▼
 ┌──────────────────────────────────────────────────────────────┐
-│  RULES (always active)                                       │
+│  RULES (optional always-active profile)                      │
 │  • coding-style.md → TypeScript/JS conventions               │
 │  • testing.md → TDD requirements                             │
 │  • security.md → OWASP guidelines                            │
-│  • Loaded at session start, apply to ALL operations          │
+│  • Install only when your client benefits from always-on     │
+│    rule files                                                │
 └──────────────────────────────────────────────────────────────┘
                               │
                               ▼
@@ -244,7 +278,7 @@ The 6 component types work together in a **layered guidance model**:
                               │
                               ▼
 ┌──────────────────────────────────────────────────────────────┐
-│  STEERING (project-specific templates - v3.1+)               │
+│  STEERING (project-specific templates - v3.5.0)              │
 │  • product.md → Product description                          │
 │  • tech.md → Technology stack                                │
 │  • structure.md → Project structure                          │
@@ -262,7 +296,7 @@ The 6 component types work together in a **layered guidance model**:
 **When Each Component Activates:**
 | Component | Activation | Example |
 |-----------|------------|---------|
-| **Rules** | Session start (always) | `coding-style.md` enforces conventions on every response |
+| **Rules** | Full profile/session start | `coding-style.md` enforces conventions when rules are installed |
 | **Contexts** | Task type detection | `review.md` activates when reviewing code |
 | **Agents** | Explicit invocation | `reviewer.md` invoked by `/sdd-review` skill |
 | **Skills** | User command (`/skill-name`) | `/sdd-requirements` loads requirements template |
@@ -305,11 +339,11 @@ npx sdd-mcp-server migrate-steering --path ./my-project
 - Backs up existing `.spec/steering/` to `.spec/steering.backup/`
 - Removes static steering docs (principles.md, tdd-guideline.md, linus-review.md, etc.)
 - Preserves project-specific templates (product.md, tech.md, structure.md)
-- The static content now lives in enhanced `.claude/` components
+- The static content now lives in packaged `rules/`, `agents/`, and `skills/` sources and is rendered for the selected target
 
 ### Available Skills
 
-After installation, use these skills in Claude Code:
+After installation, use these skills in the selected target agent:
 
 | Skill | Description |
 |-------|-------------|
@@ -329,8 +363,35 @@ After installation, use these skills in Claude Code:
 
 **Old Design** (static steering): ~3,800 tokens loaded for every operation
 **New Design** (skills): ~1,700 tokens loaded only when skill invoked
+**Lean Install** (default): avoids installing rules, contexts, and agents unless requested
+**Automatic Handoffs**: phase approvals write compact `.spec/specs/{feature}/context/handoff.md` summaries and `sdd-context-load` uses them by default
+
+**Savings**: ~55% fewer tokens in typical operations, with further savings from lean install and compact handoffs. On typical specs, compact handoff loading targets a 60-85% reduction versus loading full `requirements.md`, `design.md`, and `tasks.md`.
+
+### Automatic Context Handoffs
+
+To reduce context growth during long SDD workflows, approval tools automatically compact phase context:
+
+```text
+sdd-approve requirements  -> .spec/specs/{feature}/context/requirements-handoff.md
+sdd-approve design        -> .spec/specs/{feature}/context/design-handoff.md
+sdd-approve tasks         -> .spec/specs/{feature}/context/tasks-handoff.md
+latest approved context   -> .spec/specs/{feature}/context/handoff.md
+```
+
+`sdd-context-load` defaults to compact mode and loads `handoff.md` instead of all phase documents.
 
-**Savings**: ~55% fewer tokens in typical operations!
+Use explicit modes when needed:
+
+```json
+{ "featureName": "auth-flow", "mode": "compact" }
+{ "featureName": "auth-flow", "mode": "standard" }
+{ "featureName": "auth-flow", "mode": "full" }
+```
+
+- `compact`: handoff only, best for routine continuation.
+- `standard`: handoff plus current `spec.json`.
+- `full`: all phase documents, for audits or ambiguous decisions.
 
 ## 📋 Available MCP Tools
 
@@ -341,21 +402,22 @@ Once connected to your AI client, you can use these MCP tools:
 | `sdd-init` | Initialize new SDD project with interactive clarification | Analyzes description quality (0-100 score), blocks if < 70%, asks targeted WHY/WHO/WHAT questions |
 | `sdd-status` | Check workflow progress | Shows current phase and approvals for features |
 | `sdd-approve` | Approve workflow phases | Mark phases (requirements, design, tasks) as approved |
+| `sdd-review-test-cases` | Approve optional TDD test-case checkpoint | Use before approving tasks when test-case review is enabled |
 | `sdd-quality-check` | Code quality analysis | Linus-style 5-layer code review |
-| `sdd-context-load` | Load project context | Restore project memory and state |
+| `sdd-context-load` | Load project context | Defaults to compact handoff context; use `mode: "full"` only when needed |
 | `sdd-validate-design` | Design quality validation | Interactive GO/NO-GO design review |
 | `sdd-validate-gap` | Implementation gap analysis | Analyze requirements vs codebase |
 | `sdd-spec-impl` | Execute tasks with TDD | Kent Beck's Red-Green-Refactor methodology |
-| `sdd-list-skills` | List available Agent Skills | Shows skills that can be installed for Claude Code |
+| `sdd-list-skills` | List available Agent Skills | Shows skills that can be installed for the selected target agent |
 
-> **Note**: Template/guidance tools (`sdd-requirements`, `sdd-design`, `sdd-tasks`, `sdd-steering`, `sdd-implement`) are now **Agent Skills**. Install them with `npx sdd-mcp-server install-skills` and use as `/sdd-requirements`, `/sdd-design`, etc.
+> **Note**: Template/guidance tools (`sdd-requirements`, `sdd-design`, `sdd-tasks`, `sdd-steering`, `sdd-implement`) are now **Agent Skills**. Install them with the target-aware `install` command and use them as `/sdd-requirements`, `/sdd-design`, etc.
 
 ## 💡 Basic Workflow
 
-1. **Setup: Install Skills & Steering, Initialize Project**
+1. **Setup: Install Target Components, Initialize Project**
    ```bash
-   # Install skills and steering documents (recommended)
-   npx sdd-mcp-server install
+   # Interactive full install, or pass --target explicitly in automation
+   npx sdd-mcp-server install --profile full
 
    # Initialize project with MCP tool
    Use sdd-init to create a new SDD project
@@ -385,6 +447,8 @@ Once connected to your AI client, you can use these MCP tools:
    Use /sdd-tasks <feature-name> to create TDD-focused task breakdown
    Includes test pyramid guidance (70/20/10 ratio)
    Tasks follow RED-GREEN-REFACTOR workflow automatically
+   Optional: enable test-case review checkpoint before implementation
+   If enabled, run sdd-review-test-cases before approving tasks
    Use sdd-approve (MCP tool) to approve the tasks phase
    ```
 
@@ -404,7 +468,7 @@ Once connected to your AI client, you can use these MCP tools:
 7. **Monitor & Manage (MCP Tools)**
    ```
    Use sdd-status to check workflow progress and phase approvals
-   Use sdd-context-load to restore project memory
+   Use sdd-context-load to restore compact project memory
    ```
 
 ## ⚙️ Configuration
@@ -480,7 +544,7 @@ claude mcp add sdd "sdd-mcp-server"
 - **EARS-Formatted Requirements**: Generate acceptance criteria based on actual npm scripts and dependencies
 - **Quality Enforcement**: Linus-style 5-layer code review system with security (OWASP Top 10) checks
 
-### Plugin Architecture (v3.0)
+### Plugin Architecture (v3.5.0)
 - **6 Component Types**: Skills, Steering, Rules, Contexts, Agents, Hooks for comprehensive AI guidance
 - **Specialized Agents**: Planner, Architect, Reviewer, Implementer, Security-Auditor, TDD-Guide personas
 - **Always-Active Rules**: Coding-style, Testing, Security, Git-workflow, Error-handling enforcement
@@ -496,7 +560,7 @@ claude mcp add sdd "sdd-mcp-server"
 
 ### Guidelines & Standards
 - **Coding Principles Enforcement**: Built-in SOLID, DRY, KISS, YAGNI, Separation of Concerns, and Modularity guidance
-- **Comprehensive Steering Documents**: 8 auto-generated guidance docs (product, tech, structure, linus-review, commit, tdd-guideline, security-check, principles)
+- **Project Steering Documents**: Project-specific `product.md`, `tech.md`, and `structure.md` docs, with static guidance consolidated into installable skills/rules/agents
 - **Multi-Language Support**: 10 languages with cultural adaptation (en, es, fr, de, it, pt, ru, ja, zh, ko)
 - **Template Engine**: Handlebars-based file generation with project-specific data
 - **Plugin System**: Extensible architecture for custom workflows
@@ -512,8 +576,8 @@ Here's how to use the MCP SDD Server in your AI client:
  for a React/TypeScript application with user authentication"
 
 # 2. Generate steering documents
-"Use sdd-steering to analyze my codebase and generate all steering documents"
-# Result: 8 steering documents created including principles.md and tdd-guideline.md
+"Use /sdd-steering to analyze my codebase and update project steering documents"
+# Result: product.md, tech.md, and structure.md describe your project
 
 # 3. Generate requirements with comprehensive analysis
 "Use sdd-requirements to analyze the project and create requirements.md"
@@ -533,7 +597,7 @@ Here's how to use the MCP SDD Server in your AI client:
 
 # 7. Implement with TDD
 "Use sdd-spec-impl to execute the authentication tasks with TDD methodology"
-# Result: Test-first development following principles.md and tdd-guideline.md
+# Result: Test-first development using installed skill and agent guidance
 
 # 8. Review code quality
 "Use sdd-quality-check to perform Linus-style code review with SOLID principles check"
@@ -630,19 +694,21 @@ For detailed documentation on:
 - **Plugin Development**: See [DEPLOYMENT.md](DEPLOYMENT.md)
 - **Docker Deployment**: See [Dockerfile](Dockerfile) and [docker-compose.yml](docker-compose.yml)
 
-**Component Documentation (v3.0)**:
+**Component Documentation (v3.5.0)**:
 - **Rules**: See `rules/*.md` for always-active coding guidelines
 - **Contexts**: See `contexts/*.md` for mode-specific system prompts
 - **Agents**: See `agents/*.md` for specialized AI personas
 - **Hooks**: See `hooks/**/*.md` for event-driven automation
 
-**Steering Documents (v3.1+)**:
+**Steering Documents (v3.5.0)**:
+
+Static steering content has been consolidated into enhanced components:
+- **Design Principles**: `rules/coding-style.md` (includes SOLID, DRY, KISS, YAGNI, SoC)
+- **TDD Methodology**: `agents/tdd-guide.md` (Red-Green-Refactor workflow)
+- **Code Review**: `agents/reviewer.md` (Linus-style 5-layer thinking)
+- **Security Checklist**: `agents/security-auditor.md` (OWASP Top 10)
 
-As of v3.1, static steering content has been consolidated into enhanced components:
-- **Design Principles**: `.claude/rules/coding-style.md` (includes SOLID, DRY, KISS, YAGNI, SoC)
-- **TDD Methodology**: `.claude/agents/tdd-guide.md` (Red-Green-Refactor workflow)
-- **Code Review**: `.claude/agents/reviewer.md` (Linus-style 5-layer thinking)
-- **Security Checklist**: `.claude/agents/security-auditor.md` (OWASP Top 10)
+The installer renders these sources into the Claude Code or Codex paths shown in the target table above.
 
 The `.spec/steering/` directory now contains only project-specific templates:
 - `product.md` - Product description template

package/dist/adapters/cli/SDDToolAdapter.d.ts

@@ -6,6 +6,7 @@ import { QualityService } from "../../application/services/QualityService.js";
 import { SteeringDocumentService } from "../../application/services/SteeringDocumentService.js";
 import { CodebaseAnalysisService } from "../../application/services/CodebaseAnalysisService.js";
 import { RequirementsClarificationService } from "../../application/services/RequirementsClarificationService.js";
+import { ContextCompactionService } from "../../application/services/ContextCompactionService.js";
 import { LoggerPort } from "../../domain/ports.js";
 export interface SDDToolHandler {
     name: string;
@@ -20,8 +21,9 @@ export declare class SDDToolAdapter {
     private readonly steeringService;
     private readonly codebaseAnalysisService;
     private readonly clarificationService;
+    private readonly contextCompactionService;
     private readonly logger;
-    constructor(projectService: ProjectService, workflowService: WorkflowService, templateService: TemplateService, qualityService: QualityService, steeringService: SteeringDocumentService, codebaseAnalysisService: CodebaseAnalysisService, clarificationService: RequirementsClarificationService, logger: LoggerPort);
+    constructor(projectService: ProjectService, workflowService: WorkflowService, templateService: TemplateService, qualityService: QualityService, steeringService: SteeringDocumentService, codebaseAnalysisService: CodebaseAnalysisService, clarificationService: RequirementsClarificationService, contextCompactionService: ContextCompactionService, logger: LoggerPort);
     getSDDTools(): SDDToolHandler[];
     private handleProjectInit;
     private formatClarificationQuestions;
@@ -29,7 +31,9 @@ export declare class SDDToolAdapter {
     private handleRequirements;
     private handleDesign;
     private handleTasks;
+    private handleReviewTestCases;
     private handleQualityCheck;
+    private handleContextLoad;
     private handleSteering;
     private handleSteeringCustom;
     private generateProductSteering;

package/dist/adapters/cli/SDDToolAdapter.js

@@ -20,6 +20,7 @@ import { QualityService } from "../../application/services/QualityService.js";
 import { SteeringDocumentService } from "../../application/services/SteeringDocumentService.js";
 import { CodebaseAnalysisService } from "../../application/services/CodebaseAnalysisService.js";
 import { RequirementsClarificationService } from "../../application/services/RequirementsClarificationService.js";
+import { ContextCompactionService } from "../../application/services/ContextCompactionService.js";
 import { WorkflowPhase } from "../../domain/types.js";
 import { ensureStaticSteeringDocuments } from "../../application/services/staticSteering.js";
 let SDDToolAdapter = class SDDToolAdapter {
@@ -30,8 +31,9 @@ let SDDToolAdapter = class SDDToolAdapter {
     steeringService;
     codebaseAnalysisService;
     clarificationService;
+    contextCompactionService;
     logger;
-    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, logger) {
+    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, contextCompactionService, logger) {
         this.projectService = projectService;
         this.workflowService = workflowService;
         this.templateService = templateService;
@@ -39,6 +41,7 @@ let SDDToolAdapter = class SDDToolAdapter {
         this.steeringService = steeringService;
         this.codebaseAnalysisService = codebaseAnalysisService;
         this.clarificationService = clarificationService;
+        this.contextCompactionService = contextCompactionService;
         this.logger = logger;
     }
     getSDDTools() {
@@ -64,6 +67,10 @@ let SDDToolAdapter = class SDDToolAdapter {
                                 description: "Answers to clarification questions (second pass)",
                                 additionalProperties: { type: "string" },
                             },
+                            reviewTestCases: {
+                                type: "boolean",
+                                description: "Enable an optional checkpoint requiring TDD test-case review before implementation",
+                            },
                         },
                         required: ["projectName"],
                     },
@@ -96,9 +103,9 @@ let SDDToolAdapter = class SDDToolAdapter {
                     inputSchema: {
                         type: "object",
                         properties: {
-                            featureName: { type: "string", description: "Feature name" },
+                            projectId: { type: "string", description: "Project ID" },
                         },
-                        required: ["featureName"],
+                        required: ["projectId"],
                     },
                 },
                 handler: this.handleRequirements.bind(this),
@@ -111,9 +118,9 @@ let SDDToolAdapter = class SDDToolAdapter {
                     inputSchema: {
                         type: "object",
                         properties: {
-                            featureName: { type: "string", description: "Feature name" },
+                            projectId: { type: "string", description: "Project ID" },
                         },
-                        required: ["featureName"],
+                        required: ["projectId"],
                     },
                 },
                 handler: this.handleDesign.bind(this),
@@ -126,13 +133,32 @@ let SDDToolAdapter = class SDDToolAdapter {
                     inputSchema: {
                         type: "object",
                         properties: {
-                            featureName: { type: "string", description: "Feature name" },
+                            projectId: { type: "string", description: "Project ID" },
+                            reviewTestCases: {
+                                type: "boolean",
+                                description: "When true, require an explicit TDD test-case review checkpoint before implementation",
+                            },
                         },
-                        required: ["featureName"],
+                        required: ["projectId"],
                     },
                 },
                 handler: this.handleTasks.bind(this),
             },
+            {
+                name: "sdd-review-test-cases",
+                tool: {
+                    name: "sdd-review-test-cases",
+                    description: "Mark the optional TDD test-case review checkpoint as reviewed",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            projectId: { type: "string", description: "Project ID" },
+                        },
+                        required: ["projectId"],
+                    },
+                },
+                handler: this.handleReviewTestCases.bind(this),
+            },
             {
                 name: "sdd-quality-check",
                 tool: {
@@ -149,6 +175,26 @@ let SDDToolAdapter = class SDDToolAdapter {
                 },
                 handler: this.handleQualityCheck.bind(this),
             },
+            {
+                name: "sdd-context-load",
+                tool: {
+                    name: "sdd-context-load",
+                    description: "Load compact workflow handoff context by default; use mode=full only when necessary",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            projectId: { type: "string", description: "Project ID" },
+                            mode: {
+                                type: "string",
+                                enum: ["compact", "standard", "full"],
+                                description: "Context size mode. compact is default and uses handoff.md.",
+                            },
+                        },
+                        required: ["projectId"],
+                    },
+                },
+                handler: this.handleContextLoad.bind(this),
+            },
             {
                 name: "sdd-steering",
                 tool: {
@@ -201,7 +247,7 @@ let SDDToolAdapter = class SDDToolAdapter {
         ];
     }
     async handleProjectInit(args) {
-        const { projectName, description = "", clarificationAnswers } = args;
+        const { projectName, description = "", clarificationAnswers, reviewTestCases = false, } = args;
         if (typeof projectName !== "string") {
             throw new Error("Invalid arguments: projectName must be a string");
         }
@@ -228,7 +274,7 @@ let SDDToolAdapter = class SDDToolAdapter {
             }
         }
         // Create project with enriched description
-        const project = await this.projectService.createProject(projectName, currentPath, "en");
+        const project = await this.projectService.createProject(projectName, currentPath, "en", { reviewTestCases: reviewTestCases === true });
         // Generate initial spec.json
         const specContent = await this.templateService.generateSpecJson(project);
         await this.templateService.writeProjectFile(project, "spec.json", specContent);
@@ -283,6 +329,10 @@ let SDDToolAdapter = class SDDToolAdapter {
         output += `Current Phase: ${status.currentPhase}\n`;
         output += `Next Phase: ${status.nextPhase ?? "Complete"}\n`;
         output += `Can Progress: ${status.canProgress ? "Yes" : "No"}\n`;
+        const testCaseCheckpoint = project.metadata.checkpoints?.testCases;
+        if (testCaseCheckpoint?.required) {
+            output += `TDD Test Cases Reviewed: ${testCaseCheckpoint.reviewed ? "Yes" : "No"}\n`;
+        }
         if (status.blockers && status.blockers.length > 0) {
             output += `Blockers:\n`;
             for (const blocker of status.blockers) {
@@ -310,10 +360,12 @@ let SDDToolAdapter = class SDDToolAdapter {
         await this.templateService.writeProjectFile(project, "requirements.md", content);
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.REQUIREMENTS);
-        await this.projectService.updateApprovalStatus(projectId, "requirements", {
+        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "requirements", {
             generated: true,
             approved: false,
         });
+        const specContent = await this.templateService.generateSpecJson(updatedProject);
+        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
         return `Requirements document generated for project "${project.name}"`;
     }
     async handleDesign(args) {
@@ -335,14 +387,16 @@ let SDDToolAdapter = class SDDToolAdapter {
         await this.templateService.writeProjectFile(project, "design.md", content);
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.DESIGN);
-        await this.projectService.updateApprovalStatus(projectId, "design", {
+        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "design", {
             generated: true,
             approved: false,
         });
+        const specContent = await this.templateService.generateSpecJson(updatedProject);
+        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
         return `Design document generated for project "${project.name}"`;
     }
     async handleTasks(args) {
-        const { projectId } = args;
+        const { projectId, reviewTestCases } = args;
         if (typeof projectId !== "string") {
             throw new Error("Invalid argument: projectId must be a string");
         }
@@ -358,14 +412,36 @@ let SDDToolAdapter = class SDDToolAdapter {
         // Generate tasks template
         const content = await this.templateService.generateTasksTemplate(project);
         await this.templateService.writeProjectFile(project, "tasks.md", content);
+        if (typeof reviewTestCases === "boolean") {
+            await this.projectService.updateTestCaseReviewCheckpoint(projectId, {
+                required: reviewTestCases,
+                reviewed: !reviewTestCases,
+            });
+        }
         // Update project phase and approval status
         await this.projectService.updateProjectPhase(projectId, WorkflowPhase.TASKS);
-        await this.projectService.updateApprovalStatus(projectId, "tasks", {
+        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "tasks", {
             generated: true,
             approved: false,
         });
+        const specContent = await this.templateService.generateSpecJson(updatedProject);
+        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
         return `Tasks document generated for project "${project.name}"`;
     }
+    async handleReviewTestCases(args) {
+        const { projectId } = args;
+        if (typeof projectId !== "string") {
+            throw new Error("Invalid argument: projectId must be a string");
+        }
+        const project = await this.projectService.getProject(projectId);
+        if (!project) {
+            throw new Error("Project not found");
+        }
+        const updatedProject = await this.projectService.updateTestCaseReviewCheckpoint(projectId, { required: true, reviewed: true });
+        const specContent = await this.templateService.generateSpecJson(updatedProject);
+        await this.templateService.writeProjectFile(updatedProject, "spec.json", specContent);
+        return `TDD test cases reviewed for project "${project.name}"`;
+    }
     async handleQualityCheck(args) {
         const { code, language = "typescript" } = args;
         if (typeof code !== "string") {
@@ -377,6 +453,21 @@ let SDDToolAdapter = class SDDToolAdapter {
         });
         return this.qualityService.formatQualityReport(report);
     }
+    async handleContextLoad(args) {
+        const { projectId, mode = "compact" } = args;
+        if (typeof projectId !== "string") {
+            throw new Error("Invalid argument: projectId must be a string");
+        }
+        if (!["compact", "standard", "full"].includes(mode)) {
+            throw new Error("Invalid argument: mode must be compact, standard, or full");
+        }
+        const project = await this.projectService.getProject(projectId);
+        if (!project) {
+            throw new Error("Project not found");
+        }
+        const context = await this.contextCompactionService.loadContext(project, mode);
+        return context;
+    }
     async handleSteering(args) {
         const { updateMode = "update" } = args;
         const projectPath = process.cwd();
@@ -444,10 +535,10 @@ let SDDToolAdapter = class SDDToolAdapter {
 - Project type: ${packageJson.type || "Unknown"}
 - Existing steering: Updated preserving customizations
 
-**Tip**: For a unified installation of skills and steering documents, run:
-\`npx sdd-mcp-server install\`
+**Tip**: For a complete target-native component installation, run:
+\`npx sdd-mcp-server install --profile full\`
 
-This installs both \`.claude/skills/\` (workflow guides) and \`.spec/steering/\` (project rules).`;
+Choose Codex or Claude Code interactively, or pass \`--target\` explicitly in automation.`;
         }
         catch (error) {
             this.logger.error("Failed to generate steering documents", error);
@@ -774,14 +865,16 @@ SDDToolAdapter = __decorate([
     __param(4, inject(TYPES.SteeringDocumentService)),
     __param(5, inject(TYPES.CodebaseAnalysisService)),
     __param(6, inject(TYPES.RequirementsClarificationService)),
-    __param(7, inject(TYPES.LoggerPort)),
+    __param(7, inject(TYPES.ContextCompactionService)),
+    __param(8, inject(TYPES.LoggerPort)),
     __metadata("design:paramtypes", [ProjectService,
         WorkflowService,
         TemplateService,
         QualityService,
         SteeringDocumentService,
         CodebaseAnalysisService,
-        RequirementsClarificationService, Object])
+        RequirementsClarificationService,
+        ContextCompactionService, Object])
 ], SDDToolAdapter);
 export { SDDToolAdapter };
 //# sourceMappingURL=SDDToolAdapter.js.map