@actwith-ai/mcp-server 0.1.0

package/dist/tools/patterns.js

@@ -0,0 +1,874 @@
+/**
+ * Pattern Tools
+ *
+ * MCP tools for work patterns:
+ * - list_patterns: List available patterns in space
+ * - start_pattern: Start a pattern instance
+ * - pattern_status: Check instance progress
+ * - join_pattern: Join as participant
+ * - advance_pattern: Move to next stage + submit handoff
+ * - handoff: Submit handoff for task
+ */
+// Pattern tools
+export const patternTools = [
+    {
+        name: "list_patterns",
+        description: "List available work patterns in the current space. Patterns are reusable templates for multi-agent coordination (Pipeline, Parallel, etc.).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    description: "Filter by pattern type: pipeline, parallel, swarm, supervisor, or consensus",
+                    enum: ["pipeline", "parallel", "swarm", "supervisor", "consensus"],
+                },
+            },
+        },
+    },
+    {
+        name: "start_pattern",
+        description: "Start a new instance of a work pattern. Creates tasks and sets up the coordination flow based on the pattern type.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern_id: {
+                    type: "string",
+                    description: "The ID of the pattern to start",
+                },
+                root_task_id: {
+                    type: "string",
+                    description: "Optional: Link this instance to an existing task",
+                },
+                initial_state: {
+                    type: "object",
+                    description: "Optional: Initial state/context for the instance",
+                },
+                deadline_at: {
+                    type: "number",
+                    description: "Optional: Unix timestamp deadline for time awareness (pattern will track elapsed time)",
+                },
+            },
+            required: ["pattern_id"],
+        },
+    },
+    {
+        name: "pattern_context",
+        description: "Get the accumulated stage context for a pattern instance. Shows completed stages, key decisions made, artifacts created, and any warnings. Use this to understand prior work before starting your stage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "pattern_status",
+        description: "Get the current status of a pattern instance, including progress, participants, and handoffs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "join_pattern",
+        description: "Join a pattern instance as a participant. Use auto_assign=true to automatically claim the current stage if eligible.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance to join",
+                },
+                role: {
+                    type: "string",
+                    description: "Your role: worker (default), lead, or reviewer",
+                    enum: ["worker", "lead", "reviewer"],
+                },
+                assigned_stage: {
+                    type: "string",
+                    description: "Optional: Request assignment to a specific stage (pipeline patterns)",
+                },
+                auto_assign: {
+                    type: "boolean",
+                    description: "Optional: Automatically claim the current stage if eligible (default: true)",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "declare_capabilities",
+        description: "Declare your capabilities for capability-based stage assignment. Some stages require specific capabilities.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                capabilities: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of capabilities (e.g., 'code_review', 'testing', 'documentation', 'security_audit')",
+                },
+            },
+            required: ["capabilities"],
+        },
+    },
+    {
+        name: "claim_stage",
+        description: "Claim a specific stage in a pattern instance. Claims have a TTL and expire if not completed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+                stage_name: {
+                    type: "string",
+                    description: "The name of the stage to claim",
+                },
+            },
+            required: ["instance_id", "stage_name"],
+        },
+    },
+    {
+        name: "available_stages",
+        description: "Get stages available for you to work on, showing which you can claim based on capabilities and current claims.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "verify_stage",
+        description: "Verify stage completion criteria. Some stages require verification before advancement.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+                stage_name: {
+                    type: "string",
+                    description: "The name of the stage to verify",
+                },
+                test_output: {
+                    type: "string",
+                    description: "Optional: Output from automated tests",
+                },
+                comparison_output: {
+                    type: "string",
+                    description: "Optional: Output to compare against reference",
+                },
+            },
+            required: ["instance_id", "stage_name"],
+        },
+    },
+    {
+        name: "advance_pattern",
+        description: "Advance a pipeline pattern to its next stage. Include a handoff to provide context for the next participant.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+                task_id: {
+                    type: "string",
+                    description: "The task ID you completed for this stage",
+                },
+                handoff: {
+                    type: "object",
+                    description: "Handoff content for the next participant",
+                    properties: {
+                        summary: {
+                            type: "string",
+                            description: "Brief summary of what was accomplished",
+                        },
+                        status: {
+                            type: "string",
+                            description: "Status: completed, partial, or blocked",
+                            enum: ["completed", "partial", "blocked"],
+                        },
+                        completed: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of completed items/tasks",
+                        },
+                        next_steps: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Recommended next steps for the next participant",
+                        },
+                        blockers: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional: Any blockers or issues to address",
+                        },
+                        artifacts: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional: IDs of artifacts created",
+                        },
+                        context_links: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional: URLs/paths to relevant documentation",
+                        },
+                        relevant_files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional: Files touched or created",
+                        },
+                        prior_decisions: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    decision: { type: "string" },
+                                    rationale: { type: "string" },
+                                },
+                            },
+                            description: "Optional: Key decisions made and their rationale",
+                        },
+                        change_impact_scope: {
+                            type: "string",
+                            description: "Optional: Scope of changes - which prior work might be affected",
+                        },
+                    },
+                    required: ["summary", "status", "completed", "next_steps"],
+                },
+            },
+            required: ["instance_id", "handoff"],
+        },
+    },
+    {
+        name: "handoff",
+        description: "Submit a handoff for a task. Handoffs provide context and status when transferring work to another agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_id: {
+                    type: "string",
+                    description: "The task ID this handoff is for",
+                },
+                instance_id: {
+                    type: "string",
+                    description: "Optional: Pattern instance ID if part of a pattern",
+                },
+                from_stage: {
+                    type: "string",
+                    description: "Optional: Stage this handoff is from",
+                },
+                to_stage: {
+                    type: "string",
+                    description: "Optional: Stage this handoff is to",
+                },
+                summary: {
+                    type: "string",
+                    description: "Brief summary of what was accomplished",
+                },
+                status: {
+                    type: "string",
+                    description: "Status: completed, partial, or blocked",
+                    enum: ["completed", "partial", "blocked"],
+                },
+                completed: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of completed items/tasks",
+                },
+                next_steps: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Recommended next steps",
+                },
+                blockers: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: Any blockers or issues",
+                },
+            },
+            required: ["task_id", "summary", "status", "completed", "next_steps"],
+        },
+    },
+    // Tier 3: Parallel Work Quality
+    {
+        name: "compare_output",
+        description: "Compare your subtask output against the reference (oracle comparison). Use this to verify your work matches expectations before completing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                subtask_id: {
+                    type: "string",
+                    description: "The ID of the subtask to compare",
+                },
+                output: {
+                    type: "string",
+                    description: "Your output to compare against the reference",
+                },
+            },
+            required: ["subtask_id", "output"],
+        },
+    },
+    {
+        name: "get_comparisons",
+        description: "Get all subtask comparison results for an instance. Useful during aggregation to see which outputs matched and which had discrepancies.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "get_golden_example",
+        description: "Get the golden example for a pattern. Shows sample input, expected output, and success criteria to guide your work.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern_id: {
+                    type: "string",
+                    description: "The ID of the pattern",
+                },
+            },
+            required: ["pattern_id"],
+        },
+    },
+    // Tier 4: Context & Regression Management
+    {
+        name: "check_time",
+        description: "Check time awareness for a pattern instance. Shows elapsed time, deadline proximity, stage timeout status, and any time-related warnings.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+            },
+            required: ["instance_id"],
+        },
+    },
+    {
+        name: "run_regression_tests",
+        description: "Run regression tests for a stage before advancing. Some stages require tests to pass before advancement.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+                stage_name: {
+                    type: "string",
+                    description: "The name of the stage to test",
+                },
+                test_outputs: {
+                    type: "object",
+                    description: "Map of test name to result: { 'test_name': { passed: true, output: '...' } }",
+                },
+            },
+            required: ["instance_id", "stage_name"],
+        },
+    },
+    {
+        name: "check_constraints",
+        description: "Check all advancement constraints (time limits, regression tests) before advancing a stage. Use this before advance_pattern to see if you're blocked.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                instance_id: {
+                    type: "string",
+                    description: "The ID of the pattern instance",
+                },
+                stage_name: {
+                    type: "string",
+                    description: "The name of the stage to check",
+                },
+                test_outputs: {
+                    type: "object",
+                    description: "Optional: Test outputs if regression tests are defined",
+                },
+            },
+            required: ["instance_id", "stage_name"],
+        },
+    },
+];
+// Tool name set for routing
+export const PATTERN_TOOLS = new Set([
+    "list_patterns",
+    "start_pattern",
+    "pattern_context",
+    "pattern_status",
+    "join_pattern",
+    "declare_capabilities",
+    "claim_stage",
+    "available_stages",
+    "verify_stage",
+    "advance_pattern",
+    "handoff",
+    // Tier 3
+    "compare_output",
+    "get_comparisons",
+    "get_golden_example",
+    // Tier 4
+    "check_time",
+    "run_regression_tests",
+    "check_constraints",
+]);
+// Tool handler
+export async function handlePatternTool(client, name, args) {
+    switch (name) {
+        case "list_patterns": {
+            const result = await client.listPatterns(args.type);
+            return {
+                success: true,
+                count: result.length,
+                patterns: result.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    type: p.patternType,
+                    usageCount: p.usageCount,
+                    description: getPatternDescription(p.patternType),
+                })),
+                hint: result.length === 0
+                    ? "No patterns found. Create one using the API or ask the space owner to set up patterns."
+                    : `Use start_pattern with a pattern_id to start a new instance.`,
+            };
+        }
+        case "start_pattern": {
+            const patternId = args.pattern_id;
+            if (!patternId) {
+                throw new Error("pattern_id is required");
+            }
+            const result = await client.startPattern(patternId, args.root_task_id, args.initial_state, args.deadline_at);
+            return {
+                success: true,
+                instanceId: result.instanceId,
+                status: result.status,
+                currentStage: result.currentStage,
+                patternTopic: result.patternTopic,
+                tasks: result.tasks,
+                message: `Pattern instance started. ${result.tasks.length} task(s) created.`,
+                hint: `Use 'listen' with topic '${result.patternTopic}' to follow progress updates.`,
+            };
+        }
+        case "pattern_context": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const result = await client.getPatternContext(instanceId);
+            return {
+                success: true,
+                instanceId,
+                patternTopic: result.patternTopic,
+                currentStage: result.currentStage,
+                deadlineAt: result.deadlineAt,
+                stageContext: {
+                    completedStages: result.stageContext.completedStages,
+                    keyDecisions: result.stageContext.keyDecisions,
+                    artifacts: result.stageContext.artifacts,
+                    warnings: result.stageContext.warnings,
+                },
+                hint: result.stageContext.completedStages.length > 0
+                    ? `${result.stageContext.completedStages.length} stage(s) completed. Review the summaries and decisions before starting your work.`
+                    : "No stages completed yet. You're working on the first stage.",
+            };
+        }
+        case "pattern_status": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const result = await client.getPatternStatus(instanceId);
+            return {
+                success: true,
+                instance: {
+                    id: result.instance.id,
+                    status: result.instance.status,
+                    currentStage: result.instance.currentStage,
+                    currentStageIndex: result.instance.currentStageIndex,
+                    startedAt: result.instance.startedAt,
+                    completedAt: result.instance.completedAt,
+                },
+                pattern: {
+                    id: result.pattern.id,
+                    name: result.pattern.name,
+                    type: result.pattern.patternType,
+                },
+                stages: result.stages?.map((s) => ({
+                    name: s.name,
+                    index: s.stageIndex,
+                    description: s.description,
+                    requiresApproval: s.requiresApproval,
+                })),
+                participants: result.participants,
+                subtasks: result.subtasks?.map((s) => ({
+                    taskId: s.taskId,
+                    type: s.subtaskType,
+                    status: s.status,
+                })),
+                handoffs: result.handoffs.map((h) => ({
+                    id: h.id,
+                    fromStage: h.fromStage,
+                    toStage: h.toStage,
+                    summary: h.content.summary,
+                    status: h.content.status,
+                })),
+            };
+        }
+        case "join_pattern": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const agentId = await client.getAgentId();
+            const autoAssign = args.auto_assign !== false; // Default to true
+            const result = await client.joinPattern(instanceId, {
+                participantId: agentId,
+                participantType: "agent",
+                role: args.role,
+                assignedStage: args.assigned_stage,
+                autoAssign,
+            });
+            if (result.assignedStage) {
+                return {
+                    success: true,
+                    message: `Joined and claimed stage: ${result.assignedStage}`,
+                    participantId: result.participantId,
+                    assignedStage: result.assignedStage,
+                    claimExpiresAt: result.claimExpiresAt,
+                    capabilitiesMatched: result.capabilitiesMatched,
+                    hint: `Stage claimed until ${result.claimExpiresAt ? new Date(result.claimExpiresAt * 1000).toISOString() : "unknown"}. Complete your work and use advance_pattern.`,
+                };
+            }
+            return {
+                success: true,
+                message: "Joined pattern instance",
+                participantId: result.participantId,
+                hint: "Use available_stages to see what you can work on, or claim_stage to claim a specific stage.",
+            };
+        }
+        case "declare_capabilities": {
+            const capabilities = args.capabilities;
+            if (!capabilities || !Array.isArray(capabilities)) {
+                throw new Error("capabilities array is required");
+            }
+            const agentId = await client.getAgentId();
+            await client.declareCapabilities(agentId, capabilities);
+            return {
+                success: true,
+                message: "Capabilities declared",
+                capabilities,
+                hint: "You can now join patterns that require these capabilities.",
+            };
+        }
+        case "claim_stage": {
+            const instanceId = args.instance_id;
+            const stageName = args.stage_name;
+            if (!instanceId || !stageName) {
+                throw new Error("instance_id and stage_name are required");
+            }
+            const agentId = await client.getAgentId();
+            const result = await client.claimStage(instanceId, agentId, stageName);
+            return {
+                success: true,
+                message: `Claimed stage: ${stageName}`,
+                stageName: result.stageName,
+                claimExpiresAt: result.claimExpiresAt,
+                hint: `Claim expires at ${new Date(result.claimExpiresAt * 1000).toISOString()}. Complete your work before then.`,
+            };
+        }
+        case "available_stages": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const agentId = await client.getAgentId();
+            const result = await client.getAvailableStages(instanceId, agentId);
+            const claimableStages = result.stages.filter((s) => s.canClaim);
+            return {
+                success: true,
+                currentStage: result.currentStage,
+                stages: result.stages.map((s) => ({
+                    name: s.stageName,
+                    index: s.stageIndex,
+                    isCurrent: s.isCurrent,
+                    canClaim: s.canClaim,
+                    missingCapabilities: s.missingCapabilities,
+                })),
+                hint: claimableStages.length > 0
+                    ? `You can claim: ${claimableStages.map((s) => s.stageName).join(", ")}`
+                    : "No stages available to claim. Check if you have the required capabilities.",
+            };
+        }
+        case "verify_stage": {
+            const instanceId = args.instance_id;
+            const stageName = args.stage_name;
+            if (!instanceId || !stageName) {
+                throw new Error("instance_id and stage_name are required");
+            }
+            const result = await client.verifyStage(instanceId, stageName, {
+                testOutput: args.test_output,
+                comparisonOutput: args.comparison_output,
+            });
+            return {
+                success: true,
+                passed: result.passed,
+                verificationType: result.verificationType,
+                details: result.details,
+                failureReason: result.failureReason,
+                hint: result.passed
+                    ? "Verification passed. You can now advance the pattern."
+                    : `Verification failed: ${result.failureReason}`,
+            };
+        }
+        case "advance_pattern": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const handoffInput = args.handoff;
+            if (!handoffInput) {
+                throw new Error("handoff is required");
+            }
+            const agentId = await client.getAgentId();
+            const result = await client.advancePattern(instanceId, {
+                agentId,
+                taskId: args.task_id,
+                handoff: {
+                    summary: handoffInput.summary,
+                    status: handoffInput.status,
+                    completed: handoffInput.completed,
+                    nextSteps: handoffInput.next_steps,
+                    blockers: handoffInput.blockers,
+                    artifacts: handoffInput.artifacts,
+                    contextLinks: handoffInput.context_links,
+                    relevantFiles: handoffInput.relevant_files,
+                    priorDecisions: handoffInput.prior_decisions,
+                    changeImpactScope: handoffInput.change_impact_scope,
+                },
+            });
+            if (result.completed) {
+                return {
+                    success: true,
+                    message: "Pattern completed!",
+                    completed: true,
+                };
+            }
+            if (result.requiresApproval) {
+                return {
+                    success: true,
+                    message: "Stage completed, awaiting approval from space owner/admin before advancing.",
+                    requiresApproval: true,
+                };
+            }
+            return {
+                success: true,
+                message: `Advanced to next stage: ${result.nextStage}`,
+                nextStage: result.nextStage,
+                advanced: true,
+            };
+        }
+        case "handoff": {
+            const taskId = args.task_id;
+            if (!taskId) {
+                throw new Error("task_id is required");
+            }
+            const agentId = await client.getAgentId();
+            const result = await client.submitHandoff({
+                taskId,
+                instanceId: args.instance_id,
+                fromStage: args.from_stage,
+                toStage: args.to_stage,
+                agentId,
+                content: {
+                    summary: args.summary,
+                    status: args.status,
+                    completed: args.completed,
+                    nextSteps: args.next_steps,
+                    blockers: args.blockers,
+                },
+            });
+            return {
+                success: true,
+                handoffId: result.id,
+                message: "Handoff submitted successfully",
+                hint: "The next agent can see this handoff when they claim the task.",
+            };
+        }
+        // Tier 3: Parallel Work Quality
+        case "compare_output": {
+            const subtaskId = args.subtask_id;
+            const output = args.output;
+            if (!subtaskId || !output) {
+                throw new Error("subtask_id and output are required");
+            }
+            const result = await client.compareSubtaskOutput(subtaskId, output);
+            return {
+                success: true,
+                matches: result.matches,
+                comparisonMode: result.comparisonMode,
+                discrepancies: result.discrepancies,
+                similarity: result.similarity,
+                hint: result.matches
+                    ? "Output matches reference. You can complete this subtask."
+                    : `Output does not match: ${result.discrepancies?.join(", ")}`,
+            };
+        }
+        case "get_comparisons": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const result = await client.getSubtaskComparisons(instanceId);
+            const passedCount = result.comparisons.filter((c) => !c.comparisonResult || c.comparisonResult.matches).length;
+            return {
+                success: true,
+                allPassed: result.allPassed,
+                comparisons: result.comparisons.map((c) => ({
+                    subtaskId: c.subtaskId,
+                    status: c.status,
+                    matches: c.comparisonResult?.matches,
+                    discrepancies: c.comparisonResult?.discrepancies,
+                })),
+                boundaryWarnings: result.boundaryWarnings,
+                summary: `${passedCount}/${result.comparisons.length} subtasks passed comparison`,
+            };
+        }
+        case "get_golden_example": {
+            const patternId = args.pattern_id;
+            if (!patternId) {
+                throw new Error("pattern_id is required");
+            }
+            const result = await client.getGoldenExample(patternId);
+            if (!result.goldenExample) {
+                return {
+                    success: true,
+                    message: "No golden example defined for this pattern",
+                    decompositionGuidance: result.decompositionGuidance,
+                };
+            }
+            return {
+                success: true,
+                goldenExample: result.goldenExample,
+                decompositionGuidance: result.decompositionGuidance,
+                hint: "Use this as a reference for expected input/output format and success criteria.",
+            };
+        }
+        // Tier 4: Context & Regression Management
+        case "check_time": {
+            const instanceId = args.instance_id;
+            if (!instanceId) {
+                throw new Error("instance_id is required");
+            }
+            const result = await client.getTimeAwareness(instanceId);
+            const formatTime = (seconds) => {
+                if (seconds < 60)
+                    return `${seconds}s`;
+                if (seconds < 3600)
+                    return `${Math.floor(seconds / 60)}m`;
+                return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+            };
+            return {
+                success: true,
+                elapsed: formatTime(result.elapsedSeconds),
+                remaining: result.remainingSeconds
+                    ? formatTime(result.remainingSeconds)
+                    : undefined,
+                isOverdue: result.isOverdue,
+                isStageTimedOut: result.isStageTimedOut,
+                warnings: result.warnings,
+                hint: result.warnings.length > 0
+                    ? `Time warnings: ${result.warnings.join("; ")}`
+                    : "No time constraints exceeded.",
+            };
+        }
+        case "run_regression_tests": {
+            const instanceId = args.instance_id;
+            const stageName = args.stage_name;
+            if (!instanceId || !stageName) {
+                throw new Error("instance_id and stage_name are required");
+            }
+            const result = await client.runRegressionTests(instanceId, stageName, args.test_outputs);
+            return {
+                success: true,
+                passed: result.passed,
+                testsRun: result.testsRun,
+                testsPassed: result.testsPassed,
+                testsFailed: result.testsFailed,
+                results: result.results,
+                hint: result.passed
+                    ? result.testsRun > 0
+                        ? `All ${result.testsRun} tests passed. You can advance.`
+                        : "No regression tests defined for this stage."
+                    : `${result.testsFailed} test(s) failed. Fix issues before advancing.`,
+            };
+        }
+        case "check_constraints": {
+            const instanceId = args.instance_id;
+            const stageName = args.stage_name;
+            if (!instanceId || !stageName) {
+                throw new Error("instance_id and stage_name are required");
+            }
+            const result = await client.checkAdvancementConstraints(instanceId, stageName, args.test_outputs);
+            return {
+                success: true,
+                canAdvance: result.canAdvance,
+                blockedBy: result.blockedBy,
+                timeWarnings: result.timeAwareness.warnings,
+                regressionTests: result.regressionTests
+                    ? {
+                        passed: result.regressionTests.passed,
+                        summary: `${result.regressionTests.testsPassed}/${result.regressionTests.testsRun} passed`,
+                    }
+                    : undefined,
+                hint: result.canAdvance
+                    ? "All constraints passed. You can use advance_pattern."
+                    : `Blocked: ${result.blockedBy.join("; ")}`,
+            };
+        }
+        default:
+            throw new Error(`Unknown pattern tool: ${name}`);
+    }
+}
+// Helper function for pattern descriptions
+function getPatternDescription(type) {
+    switch (type) {
+        case "pipeline":
+            return "Sequential stages: each stage completes before the next begins";
+        case "parallel":
+            return "Concurrent subtasks: multiple tasks run simultaneously, then aggregate";
+        case "swarm":
+            return "Open collaboration: agents freely claim and contribute";
+        case "supervisor":
+            return "Delegated work: a lead agent distributes and reviews work";
+        case "consensus":
+            return "Group decision: multiple agents must agree before proceeding";
+        default:
+            return "Multi-agent coordination pattern";
+    }
+}
+//# sourceMappingURL=patterns.js.map