sdd-mcp-server 3.5.1 → 5.0.0

package/dist/adapters/cli/SDDToolAdapter.js

@@ -13,434 +13,163 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { injectable, inject } from "inversify";
 import { TYPES } from "../../infrastructure/di/types.js";
-import { ProjectService } from "../../application/services/ProjectService.js";
-import { WorkflowService } from "../../application/services/WorkflowService.js";
 import { TemplateService } from "../../application/services/TemplateService.js";
 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 { WorkflowEngineService } from "../../application/services/WorkflowEngineService.js";
+import { GovernanceError } from "../../application/services/WorkflowErrors.js";
 import { ensureStaticSteeringDocuments } from "../../application/services/staticSteering.js";
+import { SDD_TOOL_DEFINITIONS, SDD_TOOL_NAMES, } from "../../infrastructure/mcp/sddToolDefinitions.js";
+export { SDD_TOOL_NAMES };
 let SDDToolAdapter = class SDDToolAdapter {
-    projectService;
-    workflowService;
     templateService;
     qualityService;
     steeringService;
     codebaseAnalysisService;
     clarificationService;
-    contextCompactionService;
+    workflowEngineService;
     logger;
-    constructor(projectService, workflowService, templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, contextCompactionService, logger) {
-        this.projectService = projectService;
-        this.workflowService = workflowService;
+    constructor(templateService, qualityService, steeringService, codebaseAnalysisService, clarificationService, workflowEngineService, logger) {
         this.templateService = templateService;
         this.qualityService = qualityService;
         this.steeringService = steeringService;
         this.codebaseAnalysisService = codebaseAnalysisService;
         this.clarificationService = clarificationService;
-        this.contextCompactionService = contextCompactionService;
+        this.workflowEngineService = workflowEngineService;
         this.logger = logger;
     }
     getSDDTools() {
-        return [
-            {
-                name: "sdd-init",
-                tool: {
-                    name: "sdd-init",
-                    description: "Initialize a new SDD project with interactive requirements clarification",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectName: {
-                                type: "string",
-                                description: "The name of the project to initialize",
-                            },
-                            description: {
-                                type: "string",
-                                description: "Project description",
-                            },
-                            clarificationAnswers: {
-                                type: "object",
-                                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"],
-                    },
-                },
-                handler: this.handleProjectInit.bind(this),
-            },
-            {
-                name: "sdd-status",
-                tool: {
-                    name: "sdd-status",
-                    description: "Get current project status and workflow phase information",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                            projectPath: {
-                                type: "string",
-                                description: "Project path (alternative to ID)",
-                            },
-                        },
-                    },
-                },
-                handler: this.handleProjectStatus.bind(this),
-            },
-            {
-                name: "sdd-requirements",
-                tool: {
-                    name: "sdd-requirements",
-                    description: "Generate requirements doc",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleRequirements.bind(this),
-            },
-            {
-                name: "sdd-design",
-                tool: {
-                    name: "sdd-design",
-                    description: "Create design specifications",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                        },
-                        required: ["projectId"],
-                    },
-                },
-                handler: this.handleDesign.bind(this),
-            },
-            {
-                name: "sdd-tasks",
-                tool: {
-                    name: "sdd-tasks",
-                    description: "Generate task breakdown",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            projectId: { type: "string", description: "Project ID" },
-                            reviewTestCases: {
-                                type: "boolean",
-                                description: "When true, require an explicit TDD test-case review checkpoint before implementation",
-                            },
-                        },
-                        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: {
-                    name: "sdd-quality-check",
-                    description: "Perform Linus-style code quality analysis",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            code: { type: "string", description: "Code to analyze" },
-                            language: { type: "string", description: "Programming language" },
-                        },
-                        required: ["code"],
-                    },
-                },
-                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: {
-                    name: "sdd-steering",
-                    description: "Create/update steering documents with project-specific analysis",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            updateMode: {
-                                type: "string",
-                                enum: ["create", "update"],
-                                description: "Whether to create new or update existing documents",
-                            },
-                        },
-                    },
-                },
-                handler: this.handleSteering.bind(this),
-            },
-            {
-                name: "sdd-steering-custom",
-                tool: {
-                    name: "sdd-steering-custom",
-                    description: "Create custom steering documents for specialized contexts",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            fileName: {
-                                type: "string",
-                                description: "Filename for the custom steering document",
-                            },
-                            topic: {
-                                type: "string",
-                                description: "Topic/purpose of the custom steering document",
-                            },
-                            inclusionMode: {
-                                type: "string",
-                                enum: ["always", "conditional", "manual"],
-                                description: "How this steering document should be included",
-                            },
-                            filePattern: {
-                                type: "string",
-                                description: "File pattern for conditional inclusion",
-                            },
-                        },
-                        required: ["fileName", "topic", "inclusionMode"],
-                    },
-                },
-                handler: this.handleSteeringCustom.bind(this),
-            },
-        ];
+        const handlers = {
+            "sdd-init": this.handleProjectInit.bind(this),
+            "sdd-requirements": this.handleRequirements.bind(this),
+            "sdd-design": this.handleDesign.bind(this),
+            "sdd-tasks": this.handleTasks.bind(this),
+            "sdd-implement": this.handleImplement.bind(this),
+            "sdd-status": this.handleProjectStatus.bind(this),
+            "sdd-approve": this.handleApprove.bind(this),
+            "sdd-review-test-cases": this.handleReviewTestCases.bind(this),
+            "sdd-quality-check": this.handleQualityCheck.bind(this),
+            "sdd-context-load": this.handleContextLoad.bind(this),
+            "sdd-template-render": this.handleTemplateRender.bind(this),
+            "sdd-steering": this.handleSteering.bind(this),
+            "sdd-steering-custom": this.handleSteeringCustom.bind(this),
+            "sdd-validate-design": this.handleValidateDesign.bind(this),
+            "sdd-validate-gap": this.handleValidateGap.bind(this),
+            "sdd-spec-impl": this.handleSpecImplementation.bind(this),
+        };
+        return SDD_TOOL_DEFINITIONS.map((tool) => ({
+            name: tool.name,
+            tool,
+            handler: handlers[tool.name],
+        }));
     }
     async handleProjectInit(args) {
-        const { projectName, description = "", clarificationAnswers, reviewTestCases = false, } = args;
-        if (typeof projectName !== "string") {
-            throw new Error("Invalid arguments: projectName must be a string");
+        const featureName = this.requireFeatureName(args.featureName);
+        const description = args.description;
+        if (typeof description !== "string") {
+            throw new Error("Invalid argument: description must be a string");
         }
-        const currentPath = process.cwd();
-        // FIRST PASS: Analyze description quality
+        const clarificationAnswers = args.clarificationAnswers;
         if (!clarificationAnswers) {
-            const result = await this.clarificationService.analyzeDescription(description, currentPath);
-            // If clarification needed, BLOCK and return questions
+            const result = await this.clarificationService.analyzeDescription(description, process.cwd());
             if (result.needsClarification && result.questions) {
-                return this.formatClarificationQuestions(result.questions, result.analysis);
+                return { status: "clarification-required", featureName, questions: result.questions };
             }
         }
-        // SECOND PASS: Validate and synthesize enriched description
         let enrichedDescription = description;
         if (clarificationAnswers && typeof clarificationAnswers === "object") {
-            const result = await this.clarificationService.analyzeDescription(description, currentPath);
+            const result = await this.clarificationService.analyzeDescription(description, process.cwd());
             if (result.questions) {
                 const validation = this.clarificationService.validateAnswers(result.questions, clarificationAnswers);
                 if (!validation.valid) {
-                    throw new Error(`Missing required answers: ${validation.missingRequired.join(", ")}`);
+                    throw new GovernanceError('InvalidParams', `Missing required answers: ${validation.missingRequired.join(", ")}`);
                 }
-                const enriched = this.clarificationService.synthesizeDescription(description, result.questions, clarificationAnswers);
-                enrichedDescription = enriched.enriched;
+                enrichedDescription = this.clarificationService.synthesizeDescription(description, result.questions, clarificationAnswers).enriched;
             }
         }
-        // Create project with enriched description
-        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);
-        const clarificationNote = clarificationAnswers
-            ? "\n\n✅ Requirements Clarification: Your answers have been incorporated into an enriched project description."
-            : "";
-        return `Project "${projectName}" initialized successfully\nProject ID: ${project.id}\n\nDescription:\n${enrichedDescription}${clarificationNote}`;
-    }
-    formatClarificationQuestions(questions, analysis) {
-        let output = "## Requirements Clarification Needed\n\n";
-        output +=
-            "Your project description needs more detail to ensure we build the right solution.\n\n";
-        output += `**Quality Score**: ${Math.round(analysis.qualityScore)}/100 (need 70+ to proceed)\n\n`;
-        output += "### Please answer these questions:\n\n";
-        let questionNum = 1;
-        for (const q of questions) {
-            output += `**${questionNum}. ${q.question}**${q.required ? " *(required)*" : ""}\n`;
-            if (q.examples && q.examples.length > 0) {
-                output += `   Examples:\n`;
-                for (const ex of q.examples) {
-                    output += `   - ${ex}\n`;
-                }
-            }
-            output += `   Answer ID: \`${q.id}\`\n\n`;
-            questionNum++;
+        await this.workflowEngineService.initializeFeature({
+            projectRoot: process.cwd(),
+            featureName,
+            description: enrichedDescription,
+            language: args.language ?? "en",
+        });
+        return { status: "initialized", featureName, revision: 0 };
+    }
+    async requireFeatureProject(featureName) {
+        return this.workflowEngineService.loadProject({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(featureName),
+        });
+    }
+    requireFeatureName(featureName) {
+        if (typeof featureName !== "string" || featureName.length === 0) {
+            throw new Error("Invalid argument: featureName must be a non-empty string");
         }
-        output += "\n### How to Provide Answers\n\n";
-        output +=
-            "Call sdd-init again with clarificationAnswers parameter containing your answers.\n";
-        return output;
+        return featureName;
     }
     async handleProjectStatus(args) {
-        const { projectId, projectPath } = args;
-        let project;
-        if (projectId && typeof projectId === "string") {
-            project = await this.projectService.getProject(projectId);
-        }
-        else if (projectPath && typeof projectPath === "string") {
-            project = await this.projectService.getProjectByPath(projectPath);
-        }
-        else {
-            throw new Error("Either projectId or projectPath must be provided");
-        }
-        if (!project) {
-            return "Project not found";
-        }
-        const status = await this.workflowService.getWorkflowStatus(project.id);
-        if (!status) {
-            return "Unable to get workflow status";
-        }
-        let output = `Project: ${project.name}\n`;
-        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) {
-                output += `- ${blocker}\n`;
-            }
+        const { featureName } = args;
+        if (featureName === undefined) {
+            const features = await this.workflowEngineService.listFeatureStatuses({
+                projectRoot: process.cwd(),
+            });
+            return { features };
         }
-        return output;
+        return this.workflowEngineService.getFeatureStatus({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(featureName),
+        });
     }
     async handleRequirements(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");
-        }
-        // Check if can transition to requirements phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.REQUIREMENTS);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate requirements: ${validation.reason}`);
-        }
-        // Generate requirements template
-        const content = await this.templateService.generateRequirementsTemplate(project);
-        await this.templateService.writeProjectFile(project, "requirements.md", content);
-        // Update project phase and approval status
-        await this.projectService.updateProjectPhase(projectId, WorkflowPhase.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}"`;
+        return this.handlePhaseSubmission(args, "requirements");
     }
     async handleDesign(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");
-        }
-        // Check if can transition to design phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.DESIGN);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate design: ${validation.reason}`);
-        }
-        // Generate design template
-        const content = await this.templateService.generateDesignTemplate(project);
-        await this.templateService.writeProjectFile(project, "design.md", content);
-        // Update project phase and approval status
-        await this.projectService.updateProjectPhase(projectId, WorkflowPhase.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}"`;
+        return this.handlePhaseSubmission(args, "design");
     }
     async handleTasks(args) {
-        const { projectId, reviewTestCases } = 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");
-        }
-        // Check if can transition to tasks phase
-        const validation = await this.workflowService.validatePhaseTransition(projectId, WorkflowPhase.TASKS);
-        if (!validation.canProgress) {
-            throw new Error(`Cannot generate tasks: ${validation.reason}`);
-        }
-        // 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);
-        const updatedProject = await this.projectService.updateApprovalStatus(projectId, "tasks", {
-            generated: true,
-            approved: false,
+        return this.handlePhaseSubmission(args, "tasks");
+    }
+    async handlePhaseSubmission(args, phase) {
+        return this.workflowEngineService.submitPhaseArtifact({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+            phase,
+            content: args.content,
+            expectedRevision: args.expectedRevision,
+            expectedArtifactSha256: args.expectedArtifactSha256,
+            reviewTestCases: phase === "tasks" ? args.reviewTestCases : undefined,
+        });
+    }
+    async handleImplement(args) {
+        return this.workflowEngineService.beginImplementation({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+        });
+    }
+    async handleApprove(args) {
+        const featureName = this.requireFeatureName(args.featureName);
+        const phase = args.phase;
+        if (!["requirements", "design", "tasks"].includes(phase)) {
+            throw new Error("Invalid argument: phase must be requirements, design, or tasks");
+        }
+        return this.workflowEngineService.approve({
+            projectRoot: process.cwd(),
+            featureName,
+            phase: phase,
+            expectedRevision: args.expectedRevision,
+            expectedArtifactSha256: args.expectedArtifactSha256,
         });
-        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}"`;
+        const featureName = this.requireFeatureName(args.featureName);
+        return this.workflowEngineService.reviewTestCases({
+            projectRoot: process.cwd(),
+            featureName,
+            expectedTasksRevision: args.expectedTasksRevision,
+            expectedArtifactSha256: args.expectedArtifactSha256,
+        });
     }
     async handleQualityCheck(args) {
         const { code, language = "typescript" } = args;
@@ -454,19 +183,71 @@ 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;
+        const featureName = this.requireFeatureName(args.featureName);
+        const { mode, phase, maxEstimatedTokens, ifNoneMatch, includeUnapproved, } = args;
+        return this.workflowEngineService.loadFeatureContext({
+            projectRoot: process.cwd(),
+            featureName,
+            mode: mode,
+            phase: phase,
+            maxEstimatedTokens: maxEstimatedTokens,
+            ifNoneMatch: ifNoneMatch,
+            includeUnapproved: includeUnapproved,
+        });
+    }
+    async handleTemplateRender(args) {
+        const project = await this.requireFeatureProject(args.featureName);
+        const templateType = args.templateType;
+        if (args.customTemplate !== undefined) {
+            if (typeof args.customTemplate !== "string") {
+                throw new Error("Invalid argument: customTemplate must be a string");
+            }
+            return {
+                featureName: project.name,
+                templateType,
+                content: args.customTemplate,
+            };
+        }
+        let content;
+        switch (templateType) {
+            case "requirements":
+                content = await this.templateService.generateRequirementsTemplate(project);
+                break;
+            case "design":
+                content = await this.templateService.generateDesignTemplate(project);
+                break;
+            case "tasks":
+                content = await this.templateService.generateTasksTemplate(project);
+                break;
+            default:
+                throw new Error("Invalid argument: templateType must be requirements, design, or tasks");
+        }
+        return { featureName: project.name, templateType, content };
+    }
+    async handleValidateDesign(args) {
+        return this.workflowEngineService.validateDesignArtifact({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+        });
+    }
+    async handleValidateGap(args) {
+        const project = await this.requireFeatureProject(args.featureName);
+        return {
+            featureName: project.name,
+            analysis: await this.codebaseAnalysisService.analyzeCodebase(project.path),
+        };
+    }
+    async handleSpecImplementation(args) {
+        return this.workflowEngineService.recordTaskProgress({
+            projectRoot: process.cwd(),
+            featureName: this.requireFeatureName(args.featureName),
+            taskNumber: args.taskNumber,
+            action: args.action,
+            expectedRevision: args.expectedRevision,
+            evidence: args.evidence,
+            affectedArtifacts: args.affectedArtifacts,
+            blocker: args.blocker,
+        });
     }
     async handleSteering(args) {
         const { updateMode = "update" } = args;
@@ -553,6 +334,12 @@ Choose Codex or Claude Code interactively, or pass \`--target\` explicitly in au
             typeof inclusionMode !== "string") {
             throw new Error("Invalid arguments: fileName, topic, and inclusionMode must be strings");
         }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]*\.md$/.test(fileName)) {
+            throw new Error("Invalid argument: fileName must be a Markdown basename");
+        }
+        if (!["always", "conditional", "manual"].includes(inclusionMode)) {
+            throw new Error("Invalid argument: inclusionMode must be always, conditional, or manual");
+        }
         const content = `# ${topic}
 
 ## Purpose
@@ -858,23 +645,19 @@ ${this.generateWorkflow(analysis)}`;
 };
 SDDToolAdapter = __decorate([
     injectable(),
-    __param(0, inject(TYPES.ProjectService)),
-    __param(1, inject(TYPES.WorkflowService)),
-    __param(2, inject(TYPES.TemplateService)),
-    __param(3, inject(TYPES.QualityService)),
-    __param(4, inject(TYPES.SteeringDocumentService)),
-    __param(5, inject(TYPES.CodebaseAnalysisService)),
-    __param(6, inject(TYPES.RequirementsClarificationService)),
-    __param(7, inject(TYPES.ContextCompactionService)),
-    __param(8, inject(TYPES.LoggerPort)),
-    __metadata("design:paramtypes", [ProjectService,
-        WorkflowService,
-        TemplateService,
+    __param(0, inject(TYPES.TemplateService)),
+    __param(1, inject(TYPES.QualityService)),
+    __param(2, inject(TYPES.SteeringDocumentService)),
+    __param(3, inject(TYPES.CodebaseAnalysisService)),
+    __param(4, inject(TYPES.RequirementsClarificationService)),
+    __param(5, inject(TYPES.WorkflowEngineService)),
+    __param(6, inject(TYPES.LoggerPort)),
+    __metadata("design:paramtypes", [TemplateService,
         QualityService,
         SteeringDocumentService,
         CodebaseAnalysisService,
         RequirementsClarificationService,
-        ContextCompactionService, Object])
+        WorkflowEngineService, Object])
 ], SDDToolAdapter);
 export { SDDToolAdapter };
 //# sourceMappingURL=SDDToolAdapter.js.map