@sureshdsk/devflow-mcp 3.0.0 → 3.0.1

package/.next/standalone/src/mcp/server.ts

@@ -1,26 +1,25 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { getDb, schema } from "../db/index.js";
-import { eq, desc, and } from "drizzle-orm";
-import { randomUUID } from "crypto";
-import { broadcastUpdate } from "./websocket.js";
-import path from "path";
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { getDb, schema } from '../db/index.js';
+import { eq, desc, and } from 'drizzle-orm';
+import { randomUUID } from 'crypto';
+import { broadcastUpdate } from './websocket.js';
+import path from 'path';
 
 function slugify(str: string): string {
   return str
     .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
 }
 
 function defaultProjectName(): string {
   return slugify(path.basename(process.cwd()));
 }
+import { listSchemas, createSchema } from '../lib/schema.js';
+import { getSpecsDir } from '../lib/specs-dir.js';
 import {
   listSpecs,
   getSpec,
@@ -36,18 +35,18 @@ import {
   getArtifactTemplate,
   fillTaskSummary,
   updateTaskBodyInSpec,
-} from "../lib/specs.js";
+} from '../lib/specs.js';
 
 const server = new Server(
   {
-    name: "devflow-mcp",
-    version: "2.0.0",
+    name: 'devflow-mcp',
+    version: '2.0.0',
   },
   {
     capabilities: {
       tools: {},
     },
-  }
+  },
 );
 
 // Tool definitions
@@ -56,411 +55,511 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       // Project Management
       {
-        name: "list_projects",
-        description: "List all projects",
+        name: 'list_projects',
+        description: 'List all projects',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
             status: {
-              type: "string",
-              enum: ["active", "archived", "completed"],
-              description: "Filter by project status (optional)",
+              type: 'string',
+              enum: ['active', 'archived', 'completed'],
+              description: 'Filter by project status (optional)',
             },
           },
         },
       },
       {
-        name: "create_project",
-        description: "Create a new project. If name is omitted, defaults to the current directory name (slugified).",
+        name: 'create_project',
+        description:
+          'Create a new project. If name is omitted, defaults to the current directory name (slugified).',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            name: { type: "string", description: "Project name (optional — defaults to current directory name)" },
-            description: { type: "string", description: "Project description" },
+            name: {
+              type: 'string',
+              description: 'Project name (optional — defaults to current directory name)',
+            },
+            description: { type: 'string', description: 'Project description' },
           },
         },
       },
       {
-        name: "get_project",
-        description: "Get project details with all tasks",
+        name: 'get_project',
+        description: 'Get project details with all tasks',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            projectId: { type: "string", description: "Project ID" },
+            projectId: { type: 'string', description: 'Project ID' },
           },
-          required: ["projectId"],
+          required: ['projectId'],
         },
       },
       {
-        name: "update_project",
-        description: "Update project details",
+        name: 'update_project',
+        description: 'Update project details',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            projectId: { type: "string", description: "Project ID" },
-            name: { type: "string", description: "New project name" },
-            description: { type: "string", description: "New description" },
+            projectId: { type: 'string', description: 'Project ID' },
+            name: { type: 'string', description: 'New project name' },
+            description: { type: 'string', description: 'New description' },
             status: {
-              type: "string",
-              enum: ["active", "archived", "completed"],
-              description: "New status",
+              type: 'string',
+              enum: ['active', 'archived', 'completed'],
+              description: 'New status',
             },
           },
-          required: ["projectId"],
+          required: ['projectId'],
         },
       },
       {
-        name: "get_or_create_project",
-        description: "Get an existing project by name or create it if it doesn't exist. If name is omitted, defaults to the current directory name (slugified). Use the project directory name as a default if no project name is specified.",
+        name: 'get_or_create_project',
+        description:
+          "Get an existing project by name or create it if it doesn't exist. If name is omitted, defaults to the current directory name (slugified). Use the project directory name as a default if no project name is specified.",
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            name: { type: "string", description: "Project name (optional — defaults to current directory name)" },
-            description: { type: "string", description: "Description (used only if creating)" },
+            name: {
+              type: 'string',
+              description: 'Project name (optional — defaults to current directory name)',
+            },
+            description: { type: 'string', description: 'Description (used only if creating)' },
           },
         },
       },
       // Task Management
       {
-        name: "list_tasks",
-        description: "List tasks with optional filters",
+        name: 'list_tasks',
+        description: 'List tasks with optional filters',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            projectId: { type: "string", description: "Filter by project ID" },
-            specName: { type: "string", description: "Filter by spec name" },
+            projectId: { type: 'string', description: 'Filter by project ID' },
+            specName: { type: 'string', description: 'Filter by spec name' },
             status: {
-              type: "string",
-              enum: ["backlog", "todo", "in_progress", "interrupted", "done"],
-              description: "Filter by status",
+              type: 'string',
+              enum: ['backlog', 'todo', 'in_progress', 'interrupted', 'done'],
+              description: 'Filter by status',
             },
-            assignedAgent: { type: "string", description: "Filter by assigned agent" },
+            assignedAgent: { type: 'string', description: 'Filter by assigned agent' },
           },
         },
       },
       {
-        name: "get_task",
-        description: "Get details of a specific task",
+        name: 'get_task',
+        description: 'Get details of a specific task',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID" },
+            taskId: { type: 'string', description: 'Task ID' },
           },
-          required: ["taskId"],
+          required: ['taskId'],
         },
       },
       {
-        name: "create_task",
-        description: "Create a new task. Can auto-create project if projectName is provided instead of projectId.",
+        name: 'create_task',
+        description:
+          'Create a new task. Can auto-create project if projectName is provided instead of projectId.',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            title: { type: "string", description: "Task title" },
-            body: { type: "string", description: "Task body (markdown)" },
-            description: { type: "string", description: "Task description (legacy — auto-composed into body if body not provided)" },
-            context: { type: "string", description: "Additional context (legacy — auto-composed into body if body not provided)" },
+            title: { type: 'string', description: 'Task title' },
+            body: { type: 'string', description: 'Task body (markdown)' },
+            description: {
+              type: 'string',
+              description:
+                'Task description (legacy — auto-composed into body if body not provided)',
+            },
+            context: {
+              type: 'string',
+              description:
+                'Additional context (legacy — auto-composed into body if body not provided)',
+            },
             priority: {
-              type: "string",
-              enum: ["low", "medium", "high", "urgent"],
-              description: "Task priority",
+              type: 'string',
+              enum: ['low', 'medium', 'high', 'urgent'],
+              description: 'Task priority',
             },
             status: {
-              type: "string",
-              enum: ["backlog", "todo", "in_progress", "done"],
-              description: "Initial status (defaults to backlog)",
+              type: 'string',
+              enum: ['backlog', 'todo', 'in_progress', 'done'],
+              description: 'Initial status (defaults to backlog)',
             },
-            projectId: { type: "string", description: "Project ID" },
+            projectId: { type: 'string', description: 'Project ID' },
             projectName: {
-              type: "string",
+              type: 'string',
               description: "Project name — auto-creates the project if it doesn't exist",
             },
-            specName: { type: "string", description: "Spec name to link this task to" },
+            specName: { type: 'string', description: 'Spec name to link this task to' },
           },
-          required: ["title"],
+          required: ['title'],
         },
       },
       {
-        name: "create_tasks_bulk",
-        description: "Create multiple tasks at once",
+        name: 'create_tasks_bulk',
+        description: 'Create multiple tasks at once',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            projectId: { type: "string", description: "Project ID for all tasks" },
-            projectName: { type: "string", description: "Project name (auto-creates if needed)" },
-            specName: { type: "string", description: "Spec name to link tasks to" },
+            projectId: { type: 'string', description: 'Project ID for all tasks' },
+            projectName: { type: 'string', description: 'Project name (auto-creates if needed)' },
+            specName: { type: 'string', description: 'Spec name to link tasks to' },
             tasks: {
-              type: "array",
-              description: "Array of task objects",
+              type: 'array',
+              description: 'Array of task objects',
               items: {
-                type: "object",
+                type: 'object',
                 properties: {
-                  title: { type: "string" },
-                  body: { type: "string", description: "Task body (markdown)" },
-                  description: { type: "string", description: "Legacy — auto-composed into body if body not provided" },
-                  context: { type: "string", description: "Legacy — auto-composed into body if body not provided" },
-                  priority: { type: "string", enum: ["low", "medium", "high", "urgent"] },
-                  status: { type: "string", enum: ["backlog", "todo", "in_progress", "done"] },
+                  title: { type: 'string' },
+                  body: { type: 'string', description: 'Task body (markdown)' },
+                  description: {
+                    type: 'string',
+                    description: 'Legacy — auto-composed into body if body not provided',
+                  },
+                  context: {
+                    type: 'string',
+                    description: 'Legacy — auto-composed into body if body not provided',
+                  },
+                  priority: { type: 'string', enum: ['low', 'medium', 'high', 'urgent'] },
+                  status: { type: 'string', enum: ['backlog', 'todo', 'in_progress', 'done'] },
                 },
-                required: ["title"],
+                required: ['title'],
               },
             },
           },
-          required: ["tasks"],
+          required: ['tasks'],
         },
       },
       {
-        name: "update_task",
+        name: 'update_task',
         description: "Update a task's details or status",
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID" },
-            title: { type: "string", description: "New title" },
-            body: { type: "string", description: "New task body (markdown)" },
+            taskId: { type: 'string', description: 'Task ID' },
+            title: { type: 'string', description: 'New title' },
+            body: { type: 'string', description: 'New task body (markdown)' },
             status: {
-              type: "string",
-              enum: ["backlog", "todo", "in_progress", "interrupted", "done"],
-              description: "New status",
+              type: 'string',
+              enum: ['backlog', 'todo', 'in_progress', 'interrupted', 'done'],
+              description: 'New status',
             },
             priority: {
-              type: "string",
-              enum: ["low", "medium", "high", "urgent"],
-              description: "New priority",
+              type: 'string',
+              enum: ['low', 'medium', 'high', 'urgent'],
+              description: 'New priority',
             },
-            specName: { type: "string", description: "Link or re-link to a spec" },
+            specName: { type: 'string', description: 'Link or re-link to a spec' },
           },
-          required: ["taskId"],
+          required: ['taskId'],
         },
       },
       // Agent Workflow
       {
-        name: "check_in",
-        description: "Agent checks in to a task (sets status to in_progress, assigns agent)",
+        name: 'check_in',
+        description: 'Agent checks in to a task (sets status to in_progress, assigns agent)',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID to check in to" },
-            agentName: { type: "string", description: "Name/identifier of the agent" },
-            executionPlan: { type: "string", description: "Agent's plan for completing the task" },
+            taskId: { type: 'string', description: 'Task ID to check in to' },
+            agentName: { type: 'string', description: 'Name/identifier of the agent' },
+            executionPlan: { type: 'string', description: "Agent's plan for completing the task" },
           },
-          required: ["taskId", "agentName"],
+          required: ['taskId', 'agentName'],
         },
       },
       {
-        name: "check_out",
-        description: "Agent checks out of a task (sets status to done)",
+        name: 'check_out',
+        description: 'Agent checks out of a task (sets status to done)',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID to check out of" },
-            agentName: { type: "string", description: "Name/identifier of the agent" },
+            taskId: { type: 'string', description: 'Task ID to check out of' },
+            agentName: { type: 'string', description: 'Name/identifier of the agent' },
             taskSummary: {
-              type: "object",
-              description: "Structured summary of what was accomplished",
+              type: 'object',
+              description: 'Structured summary of what was accomplished',
               properties: {
-                whatWasDone: { type: "string", description: "What was accomplished" },
-                filesChanged: { type: "string", description: "Files changed (optional)" },
-                issuesEncountered: { type: "string", description: "Issues encountered (optional)" },
-                followUps: { type: "string", description: "Follow-up items (optional)" },
+                whatWasDone: { type: 'string', description: 'What was accomplished' },
+                filesChanged: { type: 'string', description: 'Files changed (optional)' },
+                issuesEncountered: { type: 'string', description: 'Issues encountered (optional)' },
+                followUps: { type: 'string', description: 'Follow-up items (optional)' },
               },
-              required: ["whatWasDone"],
+              required: ['whatWasDone'],
             },
           },
-          required: ["taskId", "agentName"],
+          required: ['taskId', 'agentName'],
         },
       },
       {
-        name: "log_activity",
-        description: "Log an activity or comment on a task",
+        name: 'log_activity',
+        description: 'Log an activity or comment on a task',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID" },
-            agentName: { type: "string", description: "Name/identifier of the agent" },
+            taskId: { type: 'string', description: 'Task ID' },
+            agentName: { type: 'string', description: 'Name/identifier of the agent' },
             action: {
-              type: "string",
-              enum: ["check_in", "check_out", "update", "comment"],
-              description: "Type of action",
+              type: 'string',
+              enum: ['check_in', 'check_out', 'update', 'comment'],
+              description: 'Type of action',
             },
-            details: { type: "string", description: "Activity details or comment" },
+            details: { type: 'string', description: 'Activity details or comment' },
           },
-          required: ["taskId", "agentName", "action"],
+          required: ['taskId', 'agentName', 'action'],
         },
       },
       {
-        name: "get_activity_log",
-        description: "Get activity log for a task",
+        name: 'get_activity_log',
+        description: 'Get activity log for a task',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            taskId: { type: "string", description: "Task ID" },
-            limit: { type: "number", description: "Max number of entries (default 50)" },
+            taskId: { type: 'string', description: 'Task ID' },
+            limit: { type: 'number', description: 'Max number of entries (default 50)' },
           },
-          required: ["taskId"],
+          required: ['taskId'],
         },
       },
       // Spec Management
       {
-        name: "list_specs",
-        description: "List all specs in the devflow/specs directory",
+        name: 'list_specs',
+        description: 'List all specs in the devflow/specs directory',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            projectId: { type: "string", description: "Filter by project ID (optional)" },
+            projectId: { type: 'string', description: 'Filter by project ID (optional)' },
           },
         },
       },
       {
-        name: "create_spec",
-        description: "Create a new spec folder with meta and approvals files. Run list_projects or get_or_create_project first to get a projectId.",
+        name: 'create_spec',
+        description:
+          'Create a new spec folder with meta and approvals files. Run list_projects or get_or_create_project first to get a projectId.',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
             name: {
-              type: "string",
-              description: "Spec folder name (slug, e.g. add-oauth)",
+              type: 'string',
+              description: 'Spec folder name (slug, e.g. add-oauth)',
             },
-            title: { type: "string", description: "Human-readable title" },
-            projectId: { type: "string", description: "Project ID to link to — run list_projects or get_or_create_project first" },
-            description: { type: "string", description: "Optional description" },
+            title: { type: 'string', description: 'Human-readable title' },
+            projectId: {
+              type: 'string',
+              description:
+                'Project ID to link to — run list_projects or get_or_create_project first',
+            },
+            description: { type: 'string', description: 'Optional description' },
             schema: {
-              type: "string",
-              description: "Schema name (defaults to spec-driven)",
+              type: 'string',
+              description: 'Schema name (defaults to spec-driven)',
             },
           },
-          required: ["name", "title", "projectId"],
+          required: ['name', 'title', 'projectId'],
         },
       },
       {
-        name: "get_spec",
-        description: "Get full spec details including artifact contents and statuses",
+        name: 'get_spec',
+        description: 'Get full spec details including artifact contents and statuses',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
           },
-          required: ["specName"],
+          required: ['specName'],
         },
       },
       {
-        name: "get_spec_status",
-        description: "Get the DAG status of all artifacts in a spec",
+        name: 'get_spec_status',
+        description: 'Get the DAG status of all artifacts in a spec',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
           },
-          required: ["specName"],
+          required: ['specName'],
         },
       },
       {
-        name: "get_artifact",
-        description: "Get the content of a spec artifact",
+        name: 'get_artifact',
+        description: 'Get the content of a spec artifact',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
             artifactType: {
-              type: "string",
-              description: "Artifact type (e.g. proposal, specs, design, tasks)",
+              type: 'string',
+              description: 'Artifact type (e.g. proposal, specs, design, tasks)',
             },
           },
-          required: ["specName", "artifactType"],
+          required: ['specName', 'artifactType'],
         },
       },
       {
-        name: "get_artifact_template",
-        description: "Get the template for a spec artifact to use as a starting point",
+        name: 'get_artifact_template',
+        description: 'Get the template for a spec artifact to use as a starting point',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
             artifactType: {
-              type: "string",
-              description: "Artifact type (e.g. proposal, specs, design, tasks)",
+              type: 'string',
+              description: 'Artifact type (e.g. proposal, specs, design, tasks)',
             },
           },
-          required: ["specName", "artifactType"],
+          required: ['specName', 'artifactType'],
         },
       },
       {
-        name: "write_artifact",
-        description: "Write content to a spec artifact file. Blocked if required predecessors not approved.",
+        name: 'write_artifact',
+        description:
+          'Write content to a spec artifact file. Blocked if required predecessors not approved.',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
             artifactType: {
-              type: "string",
-              description: "Artifact type (e.g. proposal, specs, design, tasks)",
+              type: 'string',
+              description: 'Artifact type (e.g. proposal, specs, design, tasks)',
             },
-            content: { type: "string", description: "Markdown content to write" },
+            content: { type: 'string', description: 'Markdown content to write' },
           },
-          required: ["specName", "artifactType", "content"],
+          required: ['specName', 'artifactType', 'content'],
         },
       },
       {
-        name: "approve_artifact",
-        description: "Approve a spec artifact, allowing downstream artifacts to be written",
+        name: 'approve_artifact',
+        description: 'Approve a spec artifact, allowing downstream artifacts to be written',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
             artifactType: {
-              type: "string",
-              description: "Artifact type to approve",
+              type: 'string',
+              description: 'Artifact type to approve',
             },
             approvedBy: {
-              type: "string",
+              type: 'string',
               description: "Who is approving (agent name or 'human')",
             },
           },
-          required: ["specName", "artifactType"],
+          required: ['specName', 'artifactType'],
+        },
+      },
+      {
+        name: 'draft_artifact',
+        description: 'Reset an artifact approval back to draft state',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            specName: { type: 'string', description: 'Spec folder name' },
+            artifactType: { type: 'string', description: 'Artifact type to reset' },
+          },
+          required: ['specName', 'artifactType'],
         },
       },
       {
-        name: "draft_artifact",
-        description: "Reset an artifact approval back to draft state",
+        name: 'validate_spec',
+        description: 'Validate a spec for completeness and quality',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
-            artifactType: { type: "string", description: "Artifact type to reset" },
+            specName: { type: 'string', description: 'Spec folder name' },
           },
-          required: ["specName", "artifactType"],
+          required: ['specName'],
         },
       },
       {
-        name: "validate_spec",
-        description: "Validate a spec for completeness and quality",
+        name: 'promote_spec',
+        description:
+          "Promote approved tasks.md to Kanban tasks. The project is read from the spec's metadata — no need to supply projectId.",
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            specName: { type: 'string', description: 'Spec folder name' },
           },
-          required: ["specName"],
+          required: ['specName'],
+        },
+      },
+      // Schema Management
+      {
+        name: 'list_schemas',
+        description:
+          'List all available schemas (bundled and project-local) with their artifact DAGs',
+        inputSchema: {
+          type: 'object',
+          properties: {},
         },
       },
       {
-        name: "promote_spec",
-        description: "Promote approved tasks.md to Kanban tasks. The project is read from the spec's metadata — no need to supply projectId.",
+        name: 'create_schema',
+        description:
+          'Create a new project-local schema with schema.yaml and template files under devflow/schemas/<name>/',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name" },
+            name: {
+              type: 'string',
+              description: 'Schema name (kebab-case slug, e.g. "ml-pipeline")',
+            },
+            artifacts: {
+              type: 'array',
+              description: 'Array of artifact definitions',
+              items: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string', description: 'Artifact ID (e.g. "proposal")' },
+                  generates: {
+                    type: 'string',
+                    description: 'Output filename (e.g. "proposal.md")',
+                  },
+                  description: { type: 'string', description: 'What this artifact covers' },
+                  template: {
+                    type: 'string',
+                    description: 'Template filename (e.g. "proposal.md")',
+                  },
+                  requires: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'IDs of artifacts that must be approved first',
+                  },
+                },
+                required: ['id', 'generates', 'description', 'template', 'requires'],
+              },
+            },
+            qualityRules: {
+              type: 'object',
+              description: 'Optional quality rules',
+              properties: {
+                requireRfc2119: { type: 'boolean' },
+                minScenariosPerRequirement: { type: 'number' },
+              },
+            },
+            apply: {
+              type: 'object',
+              description: 'Which artifacts must be approved before promoting to tasks',
+              properties: {
+                requires: { type: 'array', items: { type: 'string' } },
+              },
+            },
+            templates: {
+              type: 'object',
+              description:
+                'Map of artifactId → markdown template content. Keys should match artifact IDs.',
+            },
           },
-          required: ["specName"],
+          required: ['name', 'artifacts', 'templates'],
         },
       },
       {
-        name: "archive_spec",
-        description: "Move a spec to the archive folder",
+        name: 'archive_spec',
+        description: 'Move a spec to the archive folder',
         inputSchema: {
-          type: "object",
+          type: 'object',
           properties: {
-            specName: { type: "string", description: "Spec folder name to archive" },
+            specName: { type: 'string', description: 'Spec folder name to archive' },
           },
-          required: ["specName"],
+          required: ['specName'],
         },
       },
     ],
@@ -474,7 +573,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     switch (name) {
       // ── Project tools ──────────────────────────────────────────────────────
-      case "list_projects": {
+      case 'list_projects': {
         const db = await getDb();
         let query = db.select().from(schema.projects);
         const projects = await query.orderBy(desc(schema.projects.createdAt));
@@ -484,11 +583,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           : projects;
 
         return {
-          content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(filtered, null, 2) }],
         };
       }
 
-      case "create_project": {
+      case 'create_project': {
         const { name: rawName, description } = args as {
           name?: string;
           description?: string;
@@ -499,16 +598,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           id: randomUUID(),
           name: projectName,
           description: description || null,
-          status: "active" as const,
+          status: 'active' as const,
         };
         await db.insert(schema.projects).values(newProject);
-        broadcastUpdate({ type: "project_created", project: newProject });
+        broadcastUpdate({ type: 'project_created', project: newProject });
         return {
-          content: [{ type: "text", text: JSON.stringify(newProject, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(newProject, null, 2) }],
         };
       }
 
-      case "get_project": {
+      case 'get_project': {
         const { projectId } = args as { projectId: string };
         const db = await getDb();
         const project = await db
@@ -518,7 +617,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .limit(1);
 
         if (project.length === 0) {
-          return { content: [{ type: "text", text: "Project not found" }], isError: true };
+          return { content: [{ type: 'text', text: 'Project not found' }], isError: true };
         }
 
         const tasks = await db
@@ -530,14 +629,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return {
           content: [
             {
-              type: "text",
+              type: 'text',
               text: JSON.stringify({ ...project[0], tasks }, null, 2),
             },
           ],
         };
       }
 
-      case "update_project": {
+      case 'update_project': {
         const { projectId, ...updates } = args as {
           projectId: string;
           name?: string;
@@ -556,13 +655,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .where(eq(schema.projects.id, projectId))
           .limit(1);
 
-        broadcastUpdate({ type: "project_updated", project: updated[0] });
+        broadcastUpdate({ type: 'project_updated', project: updated[0] });
         return {
-          content: [{ type: "text", text: JSON.stringify(updated[0], null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(updated[0], null, 2) }],
         };
       }
 
-      case "get_or_create_project": {
+      case 'get_or_create_project': {
         const { name: rawName, description } = args as {
           name?: string;
           description?: string;
@@ -577,7 +676,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         if (existing.length > 0) {
           return {
-            content: [{ type: "text", text: JSON.stringify({ ...existing[0], created: false }, null, 2) }],
+            content: [
+              { type: 'text', text: JSON.stringify({ ...existing[0], created: false }, null, 2) },
+            ],
           };
         }
 
@@ -585,17 +686,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           id: randomUUID(),
           name: projectName,
           description: description || null,
-          status: "active" as const,
+          status: 'active' as const,
         };
         await db.insert(schema.projects).values(newProject);
-        broadcastUpdate({ type: "project_created", project: newProject });
+        broadcastUpdate({ type: 'project_created', project: newProject });
         return {
-          content: [{ type: "text", text: JSON.stringify({ ...newProject, created: true }, null, 2) }],
+          content: [
+            { type: 'text', text: JSON.stringify({ ...newProject, created: true }, null, 2) },
+          ],
         };
       }
 
       // ── Task tools ─────────────────────────────────────────────────────────
-      case "list_tasks": {
+      case 'list_tasks': {
         const { projectId, specName, status, assignedAgent } = args as {
           projectId?: string;
           specName?: string;
@@ -603,10 +706,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           assignedAgent?: string;
         };
         const db = await getDb();
-        let tasks = await db
-          .select()
-          .from(schema.tasks)
-          .orderBy(schema.tasks.order);
+        let tasks = await db.select().from(schema.tasks).orderBy(schema.tasks.order);
 
         if (projectId) tasks = tasks.filter((t) => t.projectId === projectId);
         if (specName) tasks = tasks.filter((t) => t.specName === specName);
@@ -614,11 +714,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (assignedAgent) tasks = tasks.filter((t) => t.assignedAgent === assignedAgent);
 
         return {
-          content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }],
         };
       }
 
-      case "get_task": {
+      case 'get_task': {
         const { taskId } = args as { taskId: string };
         const db = await getDb();
         const task = await db
@@ -628,7 +728,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .limit(1);
 
         if (task.length === 0) {
-          return { content: [{ type: "text", text: "Task not found" }], isError: true };
+          return { content: [{ type: 'text', text: 'Task not found' }], isError: true };
         }
 
         const activity = await db
@@ -639,12 +739,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .limit(10);
 
         return {
-          content: [{ type: "text", text: JSON.stringify({ ...task[0], recentActivity: activity }, null, 2) }],
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ ...task[0], recentActivity: activity }, null, 2),
+            },
+          ],
         };
       }
 
-      case "create_task": {
-        const { title, body: bodyParam, description, priority, status, context, projectId, projectName, specName } = args as {
+      case 'create_task': {
+        const {
+          title,
+          body: bodyParam,
+          description,
+          priority,
+          status,
+          context,
+          projectId,
+          projectName,
+          specName,
+        } = args as {
           title: string;
           body?: string;
           description?: string;
@@ -674,11 +789,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               id: randomUUID(),
               name: sluggedName,
               description: null,
-              status: "active" as const,
+              status: 'active' as const,
             };
             await db.insert(schema.projects).values(newProject);
             targetProjectId = newProject.id;
-            broadcastUpdate({ type: "project_created", project: newProject });
+            broadcastUpdate({ type: 'project_created', project: newProject });
           }
         }
 
@@ -697,21 +812,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           specName: specName || null,
           title,
           body: resolvedBody,
-          status: (status || "backlog") as "backlog" | "todo" | "in_progress" | "done",
-          priority: (priority || "medium") as "low" | "medium" | "high" | "urgent",
+          status: (status || 'backlog') as 'backlog' | 'todo' | 'in_progress' | 'done',
+          priority: (priority || 'medium') as 'low' | 'medium' | 'high' | 'urgent',
           assignedAgent: null,
           order: 0,
         };
 
         await db.insert(schema.tasks).values(newTask);
-        broadcastUpdate({ type: "task_created", task: newTask });
+        broadcastUpdate({ type: 'task_created', task: newTask });
         return {
-          content: [{ type: "text", text: JSON.stringify(newTask, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(newTask, null, 2) }],
         };
       }
 
-      case "create_tasks_bulk": {
-        const { projectId, projectName, specName, tasks: taskList } = args as {
+      case 'create_tasks_bulk': {
+        const {
+          projectId,
+          projectName,
+          specName,
+          tasks: taskList,
+        } = args as {
           projectId?: string;
           projectName?: string;
           specName?: string;
@@ -743,11 +863,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               id: randomUUID(),
               name: sluggedName,
               description: null,
-              status: "active" as const,
+              status: 'active' as const,
             };
             await db.insert(schema.projects).values(newProject);
             targetProjectId = newProject.id;
-            broadcastUpdate({ type: "project_created", project: newProject });
+            broadcastUpdate({ type: 'project_created', project: newProject });
           }
         }
 
@@ -766,22 +886,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             specName: specName || null,
             title: task.title,
             body: resolvedBody,
-            status: (task.status || "backlog") as "backlog" | "todo" | "in_progress" | "done",
-            priority: (task.priority || "medium") as "low" | "medium" | "high" | "urgent",
+            status: (task.status || 'backlog') as 'backlog' | 'todo' | 'in_progress' | 'done',
+            priority: (task.priority || 'medium') as 'low' | 'medium' | 'high' | 'urgent',
             assignedAgent: null,
             order: index,
           };
         });
 
         await db.insert(schema.tasks).values(newTasks);
-        broadcastUpdate({ type: "tasks_created", count: newTasks.length });
+        broadcastUpdate({ type: 'tasks_created', count: newTasks.length });
         return {
-          content: [{ type: "text", text: JSON.stringify({ created: newTasks.length, tasks: newTasks }, null, 2) }],
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ created: newTasks.length, tasks: newTasks }, null, 2),
+            },
+          ],
         };
       }
 
-      case "update_task": {
-        const { taskId, title, body: bodyParam, status, priority, specName } = args as {
+      case 'update_task': {
+        const {
+          taskId,
+          title,
+          body: bodyParam,
+          status,
+          priority,
+          specName,
+        } = args as {
           taskId: string;
           title?: string;
           body?: string;
@@ -807,14 +939,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .where(eq(schema.tasks.id, taskId))
           .limit(1);
 
-        broadcastUpdate({ type: "task_updated", task: updated[0] });
+        broadcastUpdate({ type: 'task_updated', task: updated[0] });
         return {
-          content: [{ type: "text", text: JSON.stringify(updated[0], null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(updated[0], null, 2) }],
         };
       }
 
       // ── Agent workflow tools ───────────────────────────────────────────────
-      case "check_in": {
+      case 'check_in': {
         const { taskId, agentName, executionPlan } = args as {
           taskId: string;
           agentName: string;
@@ -824,7 +956,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         // If executionPlan provided, prepend it to the existing body
         const taskSet: Record<string, unknown> = {
-          status: "in_progress",
+          status: 'in_progress',
           assignedAgent: agentName,
           updatedAt: new Date(),
         };
@@ -835,22 +967,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             .from(schema.tasks)
             .where(eq(schema.tasks.id, taskId))
             .limit(1);
-          const existingBody = existingTask[0]?.body || "";
+          const existingBody = existingTask[0]?.body || '';
           const planSection = `**Execution Plan**\n\n${executionPlan}`;
           taskSet.body = existingBody ? `${planSection}\n\n${existingBody}` : planSection;
         }
 
-        await db
-          .update(schema.tasks)
-          .set(taskSet)
-          .where(eq(schema.tasks.id, taskId));
+        await db.update(schema.tasks).set(taskSet).where(eq(schema.tasks.id, taskId));
 
         await db.insert(schema.agentActivity).values({
           id: randomUUID(),
           taskId,
           agentName,
-          action: "check_in",
-          details: executionPlan ? `Plan: ${executionPlan}` : "Checked in",
+          action: 'check_in',
+          details: executionPlan ? `Plan: ${executionPlan}` : 'Checked in',
           timestamp: new Date(),
         });
 
@@ -860,13 +989,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .where(eq(schema.tasks.id, taskId))
           .limit(1);
 
-        broadcastUpdate({ type: "task_updated", task: task[0] });
+        broadcastUpdate({ type: 'task_updated', task: task[0] });
         return {
-          content: [{ type: "text", text: JSON.stringify(task[0], null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(task[0], null, 2) }],
         };
       }
 
-      case "check_out": {
+      case 'check_out': {
         const { taskId, agentName, taskSummary } = args as {
           taskId: string;
           agentName: string;
@@ -880,7 +1009,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const db = await getDb();
 
         const taskSet: Record<string, unknown> = {
-          status: "done",
+          status: 'done',
           updatedAt: new Date(),
         };
 
@@ -891,7 +1020,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             .from(schema.tasks)
             .where(eq(schema.tasks.id, taskId))
             .limit(1);
-          const existingBody = existingTask[0]?.body || "";
+          const existingBody = existingTask[0]?.body || '';
           const updatedBody = fillTaskSummary(existingBody, taskSummary);
           taskSet.body = updatedBody;
 
@@ -903,17 +1032,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }
         }
 
-        await db
-          .update(schema.tasks)
-          .set(taskSet)
-          .where(eq(schema.tasks.id, taskId));
+        await db.update(schema.tasks).set(taskSet).where(eq(schema.tasks.id, taskId));
 
         await db.insert(schema.agentActivity).values({
           id: randomUUID(),
           taskId,
           agentName,
-          action: "check_out",
-          details: taskSummary ? taskSummary.whatWasDone : "Checked out",
+          action: 'check_out',
+          details: taskSummary ? taskSummary.whatWasDone : 'Checked out',
           timestamp: new Date(),
         });
 
@@ -923,13 +1049,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .where(eq(schema.tasks.id, taskId))
           .limit(1);
 
-        broadcastUpdate({ type: "task_updated", task: task[0] });
+        broadcastUpdate({ type: 'task_updated', task: task[0] });
         return {
-          content: [{ type: "text", text: JSON.stringify(task[0], null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(task[0], null, 2) }],
         };
       }
 
-      case "log_activity": {
+      case 'log_activity': {
         const { taskId, agentName, action, details } = args as {
           taskId: string;
           agentName: string;
@@ -948,13 +1074,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
 
         await db.insert(schema.agentActivity).values(entry);
-        broadcastUpdate({ type: "activity_logged", taskId });
+        broadcastUpdate({ type: 'activity_logged', taskId });
         return {
-          content: [{ type: "text", text: JSON.stringify(entry, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(entry, null, 2) }],
         };
       }
 
-      case "get_activity_log": {
+      case 'get_activity_log': {
         const { taskId, limit } = args as { taskId: string; limit?: number };
         const db = await getDb();
 
@@ -966,12 +1092,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           .limit(limit || 50);
 
         return {
-          content: [{ type: "text", text: JSON.stringify(activity, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(activity, null, 2) }],
         };
       }
 
       // ── Spec tools ─────────────────────────────────────────────────────────
-      case "list_specs": {
+      case 'list_specs': {
         const { projectId: filterProjectId } = args as { projectId?: string };
         let specs;
         if (filterProjectId) {
@@ -985,12 +1111,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           specs = await listSpecs();
         }
         return {
-          content: [{ type: "text", text: JSON.stringify(specs, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(specs, null, 2) }],
         };
       }
 
-      case "create_spec": {
-        const { name: specName, title, projectId, description, schema: schemaName } = args as {
+      case 'create_spec': {
+        const {
+          name: specName,
+          title,
+          projectId,
+          description,
+          schema: schemaName,
+        } = args as {
           name: string;
           title: string;
           projectId: string;
@@ -998,48 +1130,58 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           schema?: string;
         };
         await createSpec(specName, title, projectId, description, schemaName);
-        broadcastUpdate({ type: "spec_created", specName });
+        broadcastUpdate({ type: 'spec_created', specName });
         return {
-          content: [{ type: "text", text: JSON.stringify({ name: specName, title, projectId, created: true }, null, 2) }],
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ name: specName, title, projectId, created: true }, null, 2),
+            },
+          ],
         };
       }
 
-      case "get_spec": {
+      case 'get_spec': {
         const { specName } = args as { specName: string };
         const spec = await getSpec(specName);
         return {
-          content: [{ type: "text", text: JSON.stringify(spec, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(spec, null, 2) }],
         };
       }
 
-      case "get_spec_status": {
+      case 'get_spec_status': {
         const { specName } = args as { specName: string };
         const statuses = await getSpecStatus(specName);
         return {
-          content: [{ type: "text", text: JSON.stringify(statuses, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(statuses, null, 2) }],
         };
       }
 
-      case "get_artifact": {
+      case 'get_artifact': {
         const { specName, artifactType } = args as { specName: string; artifactType: string };
         const content = await getArtifact(specName, artifactType);
         if (content === null) {
-          return { content: [{ type: "text", text: `Artifact "${artifactType}" not found in spec "${specName}"` }], isError: true };
+          return {
+            content: [
+              { type: 'text', text: `Artifact "${artifactType}" not found in spec "${specName}"` },
+            ],
+            isError: true,
+          };
         }
         return {
-          content: [{ type: "text", text: content }],
+          content: [{ type: 'text', text: content }],
         };
       }
 
-      case "get_artifact_template": {
+      case 'get_artifact_template': {
         const { specName, artifactType } = args as { specName: string; artifactType: string };
         const template = await getArtifactTemplate(specName, artifactType);
         return {
-          content: [{ type: "text", text: template }],
+          content: [{ type: 'text', text: template }],
         };
       }
 
-      case "write_artifact": {
+      case 'write_artifact': {
         const { specName, artifactType, content } = args as {
           specName: string;
           artifactType: string;
@@ -1049,65 +1191,76 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Check blocker gate
         const statuses = await getSpecStatus(specName);
         const status = statuses.find((s) => s.id === artifactType);
-        if (status?.state === "blocked") {
+        if (status?.state === 'blocked') {
           return {
-            content: [{ type: "text", text: `Cannot write "${artifactType}": required artifacts (${status.requires.join(", ")}) must be approved first` }],
+            content: [
+              {
+                type: 'text',
+                text: `Cannot write "${artifactType}": required artifacts (${status.requires.join(', ')}) must be approved first`,
+              },
+            ],
             isError: true,
           };
         }
 
         await writeArtifact(specName, artifactType, content);
-        broadcastUpdate({ type: "artifact_updated", specName, artifactType });
+        broadcastUpdate({ type: 'artifact_updated', specName, artifactType });
         return {
-          content: [{ type: "text", text: `Successfully wrote ${artifactType} for spec "${specName}"` }],
+          content: [
+            { type: 'text', text: `Successfully wrote ${artifactType} for spec "${specName}"` },
+          ],
         };
       }
 
-      case "approve_artifact": {
+      case 'approve_artifact': {
         const { specName, artifactType, approvedBy } = args as {
           specName: string;
           artifactType: string;
           approvedBy?: string;
         };
-        await approveArtifact(specName, artifactType, approvedBy || "agent");
-        broadcastUpdate({ type: "artifact_approved", specName, artifactType });
+        await approveArtifact(specName, artifactType, approvedBy || 'agent');
+        broadcastUpdate({ type: 'artifact_approved', specName, artifactType });
         return {
-          content: [{ type: "text", text: `Approved "${artifactType}" for spec "${specName}"` }],
+          content: [{ type: 'text', text: `Approved "${artifactType}" for spec "${specName}"` }],
         };
       }
 
-      case "draft_artifact": {
+      case 'draft_artifact': {
         const { specName, artifactType } = args as { specName: string; artifactType: string };
         await draftArtifact(specName, artifactType);
-        broadcastUpdate({ type: "artifact_drafted", specName, artifactType });
+        broadcastUpdate({ type: 'artifact_drafted', specName, artifactType });
         return {
-          content: [{ type: "text", text: `Reset "${artifactType}" to draft for spec "${specName}"` }],
+          content: [
+            { type: 'text', text: `Reset "${artifactType}" to draft for spec "${specName}"` },
+          ],
         };
       }
 
-      case "validate_spec": {
+      case 'validate_spec': {
         const { specName } = args as { specName: string };
         const report = await validateSpec(specName);
         return {
-          content: [{ type: "text", text: JSON.stringify(report, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(report, null, 2) }],
         };
       }
 
-      case "promote_spec": {
+      case 'promote_spec': {
         const { specName } = args as { specName: string };
 
         const specDetail = await getSpec(specName);
         const projectId = specDetail.projectId;
         if (!projectId) {
           return {
-            content: [{ type: "text", text: 'Spec has no project — re-create it with a projectId' }],
+            content: [
+              { type: 'text', text: 'Spec has no project — re-create it with a projectId' },
+            ],
             isError: true,
           };
         }
 
-        if (specDetail.approvals.artifacts["tasks"]?.state !== "approved") {
+        if (specDetail.approvals.artifacts['tasks']?.state !== 'approved') {
           return {
-            content: [{ type: "text", text: 'tasks artifact must be approved before promoting' }],
+            content: [{ type: 'text', text: 'tasks artifact must be approved before promoting' }],
             isError: true,
           };
         }
@@ -1115,7 +1268,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const parsedTasks = await parseTasksArtifact(specName);
         if (parsedTasks.length === 0) {
           return {
-            content: [{ type: "text", text: "No tasks found in tasks.md" }],
+            content: [{ type: 'text', text: 'No tasks found in tasks.md' }],
             isError: true,
           };
         }
@@ -1127,31 +1280,85 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           specName,
           title: task.title,
           body: task.body || null,
-          status: "backlog" as const,
-          priority: (task.priority || "medium") as "low" | "medium" | "high" | "urgent",
+          status: 'backlog' as const,
+          priority: (task.priority || 'medium') as 'low' | 'medium' | 'high' | 'urgent',
           assignedAgent: null,
           order: index,
         }));
 
         await db.insert(schema.tasks).values(newTasks);
-        broadcastUpdate({ type: "spec_promoted", specName, taskCount: newTasks.length });
+        broadcastUpdate({ type: 'spec_promoted', specName, taskCount: newTasks.length });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({ promoted: newTasks.length, tasks: newTasks }, null, 2),
+            },
+          ],
+        };
+      }
+
+      // ── Schema tools ───────────────────────────────────────────────────────
+      case 'list_schemas': {
+        const entries = await listSchemas(getSpecsDir());
+        const result = entries.map((e) => ({
+          id: e.id,
+          source: e.source,
+          artifacts: e.schema.artifacts.map((a) => ({
+            id: a.id,
+            generates: a.generates,
+            description: a.description,
+            requires: a.requires,
+          })),
+          qualityRules: e.schema.qualityRules,
+          apply: e.schema.apply,
+        }));
         return {
-          content: [{ type: "text", text: JSON.stringify({ promoted: newTasks.length, tasks: newTasks }, null, 2) }],
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case 'create_schema': {
+        const { name, artifacts, qualityRules, apply, templates } = args as {
+          name: string;
+          artifacts: Array<{
+            id: string;
+            generates: string;
+            description: string;
+            template: string;
+            requires: string[];
+          }>;
+          qualityRules?: { requireRfc2119?: boolean; minScenariosPerRequirement?: number };
+          apply?: { requires: string[] };
+          templates: Record<string, string>;
+        };
+        const schemaDir = await createSchema(
+          { name, artifacts, qualityRules, apply, templates },
+          getSpecsDir(),
+        );
+        broadcastUpdate({ type: 'schema_created', name });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Created schema "${name}" at ${schemaDir}\n\nArtifacts: ${artifacts.map((a) => a.id).join(' → ')}`,
+            },
+          ],
         };
       }
 
-      case "archive_spec": {
+      case 'archive_spec': {
         const { specName } = args as { specName: string };
         await archiveSpec(specName);
-        broadcastUpdate({ type: "spec_archived", specName });
+        broadcastUpdate({ type: 'spec_archived', specName });
         return {
-          content: [{ type: "text", text: `Archived spec "${specName}"` }],
+          content: [{ type: 'text', text: `Archived spec "${specName}"` }],
         };
       }
 
       default:
         return {
-          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          content: [{ type: 'text', text: `Unknown tool: ${name}` }],
           isError: true,
         };
     }
@@ -1159,7 +1366,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     return {
       content: [
         {
-          type: "text",
+          type: 'text',
           text: `Error: ${error instanceof Error ? error.message : String(error)}`,
         },
       ],
@@ -1170,34 +1377,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
 function resolveAgentName(): string {
   // 1. Env-based detection (set by agent host process)
-  if (process.env.CLAUDECODE || process.env.CLAUDE_CODE_ENTRYPOINT) return "Claude Code";
-  if (process.env.CODEX) return "Codex";
-  if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) return "Cursor";
-  if (process.env.WINDSURF_PLUGIN_VERSION) return "Windsurf";
+  if (process.env.CLAUDECODE || process.env.CLAUDE_CODE_ENTRYPOINT) return 'Claude Code';
+  if (process.env.CODEX) return 'Codex';
+  if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) return 'Cursor';
+  if (process.env.WINDSURF_PLUGIN_VERSION) return 'Windsurf';
   // 2. MCP clientInfo (available after initialize handshake)
   const clientInfo = server.getClientVersion();
   if (clientInfo?.name) {
     const n = clientInfo.name.toLowerCase();
-    if (n.includes("claude")) return "Claude Code";
-    if (n.includes("codex")) return "Codex";
-    if (n.includes("cursor")) return "Cursor";
-    if (n.includes("windsurf")) return "Windsurf";
-    if (n.includes("copilot")) return "Copilot";
+    if (n.includes('claude')) return 'Claude Code';
+    if (n.includes('codex')) return 'Codex';
+    if (n.includes('cursor')) return 'Cursor';
+    if (n.includes('windsurf')) return 'Windsurf';
+    if (n.includes('copilot')) return 'Copilot';
     return clientInfo.name; // use as-is if unrecognized
   }
-  return "Unknown Agent";
+  return 'Unknown Agent';
 }
 
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("DevFlow MCP server running on stdio");
+  console.error('DevFlow MCP server running on stdio');
 
   // Re-broadcast identify after initialize so clientInfo is available
   // The initial identify (sent on WS open) uses env-based detection;
   // this one fires ~1s later with the MCP clientInfo name as fallback.
   setTimeout(() => {
-    broadcastUpdate({ type: "identify", role: "mcp", agent: resolveAgentName() });
+    broadcastUpdate({ type: 'identify', role: 'mcp', agent: resolveAgentName() });
   }, 1000);
 }