@intentius/chant 0.1.5 → 0.1.7

package/src/cli/mcp/op-tools.ts

@@ -0,0 +1,204 @@
+import { resolve } from "node:path";
+import { discoverOps } from "../../op/discover";
+import { makeTemporalClient } from "../handlers/run";
+import { resolveWorkflowId } from "../handlers/run-client";
+import { generateReport } from "../handlers/run-report";
+import type { ToolRegistration } from "./state-tools";
+
+function workflowFnName(opName: string): string {
+  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
+}
+
+export function createOpListTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-list",
+      description: "List all Op definitions discovered from *.op.ts files with their current run status",
+      inputSchema: {
+        type: "object",
+        properties: {
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+      },
+    },
+    handler: async (params) => {
+      const { ops, errors } = await discoverOps();
+      const profile = params.profile as string | undefined;
+
+      let client: Awaited<ReturnType<typeof makeTemporalClient>>["client"] | undefined;
+      try {
+        ({ client } = await makeTemporalClient(profile, resolve(".")));
+      } catch {
+        // Temporal not available — degrade gracefully
+      }
+
+      const result = [];
+      for (const [name, { config }] of ops) {
+        let runStatus = "—";
+        if (client) {
+          try {
+            const desc = await client.workflow.getHandle(resolveWorkflowId(name)).describe();
+            runStatus = desc.status.name;
+          } catch {
+            // workflow not found or Temporal error
+          }
+        }
+        result.push({
+          name,
+          overview: config.overview,
+          phases: config.phases.length,
+          taskQueue: config.taskQueue ?? config.name,
+          depends: config.depends ?? [],
+          runStatus,
+        });
+      }
+
+      return { ops: result, errors };
+    },
+  };
+}
+
+export function createOpRunTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-run",
+      description:
+        "Submit an Op workflow to Temporal. The worker must already be running — start it first with `chant run <name>`.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { ops } = await discoverOps();
+      if (!ops.has(name)) {
+        const available = [...ops.keys()];
+        return `Op "${name}" not found. Available: ${available.join(", ") || "none"}`;
+      }
+
+      const { config } = ops.get(name)!;
+      const { client, profile: resolvedProfile } = await makeTemporalClient(profile, resolve("."));
+      const workflowId = resolveWorkflowId(name);
+      const taskQueue = resolvedProfile.taskQueue ?? config.taskQueue ?? name;
+
+      await client.workflow.start(workflowFnName(name), {
+        taskQueue,
+        workflowId,
+        workflowIdConflictPolicy: "FAIL",
+      });
+
+      return { workflowId, message: `Workflow "${workflowId}" submitted to task queue "${taskQueue}"` };
+    },
+  };
+}
+
+export function createOpStatusTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-status",
+      description: "Return the current run state of an Op workflow",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+
+      const events = history.events ?? [];
+      const activitiesCompleted = events.filter((e) => e.eventType === "ActivityTaskCompleted").length;
+      const activitiesScheduled = events.filter((e) => e.eventType === "ActivityTaskScheduled").length;
+
+      return {
+        workflowId: desc.workflowId,
+        runId: desc.runId,
+        status: desc.status.name,
+        startTime: desc.startTime,
+        closeTime: desc.closeTime ?? null,
+        taskQueue: desc.taskQueue,
+        activitiesCompleted,
+        activitiesScheduled,
+      };
+    },
+  };
+}
+
+export function createOpSignalTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-signal",
+      description: "Send a named signal to an Op workflow (e.g. to unblock a gate step)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          signal: { type: "string", description: "Signal name (e.g. gate-dns-delegation)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name", "signal"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const signal = params.signal as string;
+      const profile = params.profile as string | undefined;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      await handle.signal(signal);
+
+      return `Signal "${signal}" sent to Op "${name}"`;
+    },
+  };
+}
+
+export function createOpReportTool(): ToolRegistration {
+  return {
+    definition: {
+      name: "op-report",
+      description: "Return a markdown deployment report for the latest run of an Op",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+        },
+        required: ["name"],
+      },
+    },
+    handler: async (params) => {
+      const name = params.name as string;
+      const profile = params.profile as string | undefined;
+
+      const { ops } = await discoverOps();
+      if (!ops.has(name)) {
+        return `Op "${name}" not found`;
+      }
+      const { config } = ops.get(name)!;
+
+      const { client } = await makeTemporalClient(profile, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+
+      return generateReport(name, config, desc, history);
+    },
+  };
+}

package/src/cli/mcp/resource-handlers.ts

@@ -1,9 +1,10 @@
+import { resolve } from "node:path";
 import type { ResourceDefinition } from "./types";
 import { getContext } from "./resources/context";
 import { readSnapshot, readEnvironmentSnapshots } from "../../state/git";
-import { discoverSpells } from "../../spell/discovery";
-import { generatePrompt } from "../../spell/prompt";
-import { getRuntime } from "../../runtime-adapter";
+import { discoverOps } from "../../op/discover";
+import { makeTemporalClient } from "../handlers/run";
+import { resolveWorkflowId } from "../handlers/run-client";
 
 type PluginResourceEntry = { definition: ResourceDefinition; handler: () => Promise<string> };
 
@@ -24,22 +25,22 @@ export const coreResourceDefinitions: ResourceDefinition[] = [
     mimeType: "application/json",
   },
   {
-    uri: "chant://spells",
-    name: "Spells",
-    description: "List all spells with status, tasks, and lexicon",
+    uri: "chant://ops",
+    name: "Ops",
+    description: "All Op definitions discovered from *.op.ts files",
     mimeType: "application/json",
   },
   {
-    uri: "chant://spell/{name}",
-    name: "Spell details",
-    description: "Show spell definition and status",
+    uri: "chant://ops/{name}/runs",
+    name: "Op run history",
+    description: "Workflow run history for a named Op",
     mimeType: "application/json",
   },
   {
-    uri: "chant://spell/{name}/prompt",
-    name: "Spell bootstrap prompt",
-    description: "Bootstrap prompt for agent consumption",
-    mimeType: "text/markdown",
+    uri: "chant://ops/{name}/runs/latest",
+    name: "Op latest run",
+    description: "Latest run state for a named Op",
+    mimeType: "application/json",
   },
   {
     uri: "chant://state/{environment}",
@@ -84,6 +85,10 @@ export function collectExamples(
   return examples;
 }
 
+function opWorkflowFnName(opName: string): string {
+  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
+}
+
 /**
  * Handle resources/read request — checks plugin resources after core
  */
@@ -117,51 +122,65 @@ export async function handleResourcesRead(
     };
   }
 
-  // Spell resources
-  if (uri === "chant://spells") {
-    const { spells } = await discoverSpells();
-    const list = Array.from(spells.entries()).map(([name, s]) => ({
-      name,
-      status: s.status,
-      tasks: `${s.definition.tasks.filter((t) => t.done).length}/${s.definition.tasks.length}`,
-      lexicon: s.definition.lexicon ?? null,
-      overview: s.definition.overview,
+  // Op resources
+  if (uri === "chant://ops") {
+    const { ops } = await discoverOps();
+    const list = Array.from(ops.values()).map(({ config }) => ({
+      name: config.name,
+      overview: config.overview,
+      phases: config.phases.length,
+      taskQueue: config.taskQueue ?? config.name,
+      depends: config.depends ?? [],
     }));
     return {
       contents: [{ uri, mimeType: "application/json", text: JSON.stringify(list, null, 2) }],
     };
   }
 
-  if (uri.startsWith("chant://spell/") && uri.endsWith("/prompt")) {
-    const name = uri.replace("chant://spell/", "").replace("/prompt", "");
-    const { spells } = await discoverSpells();
-    const spell = spells.get(name);
-    if (!spell) throw new Error(`Spell "${name}" not found`);
-    const rt = getRuntime();
-    const gitRootResult = await rt.spawn(["git", "rev-parse", "--show-toplevel"]);
-    const gitRoot = gitRootResult.stdout.trim();
-    const prompt = await generatePrompt(spell.definition, { gitRoot });
-    return {
-      contents: [{ uri, mimeType: "text/markdown", text: prompt }],
-    };
+  if (uri.startsWith("chant://ops/") && uri.endsWith("/runs/latest")) {
+    const name = uri.replace("chant://ops/", "").replace("/runs/latest", "");
+    try {
+      const { client } = await makeTemporalClient(undefined, resolve("."));
+      const handle = client.workflow.getHandle(resolveWorkflowId(name));
+      const desc = await handle.describe();
+      const history = await handle.fetchHistory();
+      const events = history.events ?? [];
+      const result = {
+        workflowId: desc.workflowId,
+        runId: desc.runId,
+        status: desc.status.name,
+        startTime: desc.startTime,
+        closeTime: desc.closeTime ?? null,
+        taskQueue: desc.taskQueue,
+        activitiesCompleted: events.filter((e) => e.eventType === "ActivityTaskCompleted").length,
+        activitiesScheduled: events.filter((e) => e.eventType === "ActivityTaskScheduled").length,
+      };
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }],
+      };
+    }
   }
 
-  if (uri.startsWith("chant://spell/")) {
-    const name = uri.replace("chant://spell/", "");
-    const { spells } = await discoverSpells();
-    const spell = spells.get(name);
-    if (!spell) throw new Error(`Spell "${name}" not found`);
-    return {
-      contents: [{
-        uri,
-        mimeType: "application/json",
-        text: JSON.stringify({
-          ...spell.definition,
-          status: spell.status,
-          filePath: spell.filePath,
-        }, null, 2),
-      }],
-    };
+  if (uri.startsWith("chant://ops/") && uri.endsWith("/runs")) {
+    const name = uri.replace("chant://ops/", "").replace("/runs", "");
+    try {
+      const { client } = await makeTemporalClient(undefined, resolve("."));
+      const runs: unknown[] = [];
+      for await (const run of client.workflow.list({ query: `WorkflowType = "${opWorkflowFnName(name)}"` })) {
+        runs.push({ runId: run.runId, status: run.status.name, startTime: run.startTime, closeTime: run.closeTime ?? null });
+      }
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(runs, null, 2) }],
+      };
+    } catch (err) {
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }],
+      };
+    }
   }
 
   // State resources: chant://state/{environment} and chant://state/{environment}/{lexicon}

package/src/cli/mcp/resources/context.ts

@@ -49,6 +49,33 @@ chant import template.json    # Convert external template
 chant import template.json -o ./src/  # Custom output dir
 \`\`\`
 
+## Ops (Temporal Workflows)
+
+Ops are durable workflow definitions backed by Temporal. Each \`*.op.ts\` file declares an Op with named phases and activity steps.
+
+### Op MCP Tools
+
+| Tool | Description |
+|---|---|
+| \`op-list\` | List all discovered Ops with current run status. Optional \`profile\` param. |
+| \`op-run\` | Submit an Op workflow. Requires \`name\`. Worker must already be running via \`chant run <name>\`. |
+| \`op-status\` | Get current run state (status, activity counts, times). Requires \`name\`. |
+| \`op-signal\` | Send a signal to unblock a gate step. Requires \`name\` and \`signal\`. |
+| \`op-report\` | Return a markdown deployment report for the latest run. Requires \`name\`. |
+
+All Op tools accept an optional \`profile\` parameter matching a profile name in \`chant.config.ts\` \`temporal.profiles\`.
+
+### Op MCP Resources
+
+| URI | Description |
+|---|---|
+| \`chant://ops\` | JSON array of all Op definitions (name, overview, phases, taskQueue, depends) |
+| \`chant://ops/{name}/runs\` | Workflow run history for a named Op |
+| \`chant://ops/{name}/runs/latest\` | Latest run state for a named Op |
+
+### Workflow IDs
+Ops use deterministic workflow IDs: \`chant-op-<opName>\` (e.g. \`chant-op-alb-deploy\`).
+
 ## Best Practices
 
 1. **Flat Declarations**: Keep declarations at module level, avoid deep nesting

package/src/cli/mcp/server.test.ts

@@ -195,6 +195,62 @@ describe("McpServer", () => {
       expect(props.lexicon).toBeDefined();
       expect(props.limit).toBeDefined();
     });
+
+    describe("Op tools schema", () => {
+      async function getToolProps(name: string): Promise<Record<string, unknown>> {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+        const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
+        const tool = result.tools.find((t) => t.name === name)!;
+        return tool.inputSchema.properties as Record<string, unknown>;
+      }
+
+      test("op-list has profile property", async () => {
+        const props = await getToolProps("op-list");
+        expect(props.profile).toBeDefined();
+      });
+
+      test("op-run has name (required) and profile", async () => {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+        const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
+        const tool = result.tools.find((t) => t.name === "op-run")!;
+        const props = tool.inputSchema.properties as Record<string, unknown>;
+        expect(props.name).toBeDefined();
+        expect(props.profile).toBeDefined();
+        expect(tool.inputSchema.required).toContain("name");
+      });
+
+      test("op-status has name (required) and profile", async () => {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+        const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
+        const tool = result.tools.find((t) => t.name === "op-status")!;
+        const props = tool.inputSchema.properties as Record<string, unknown>;
+        expect(props.name).toBeDefined();
+        expect(props.profile).toBeDefined();
+        expect(tool.inputSchema.required).toContain("name");
+      });
+
+      test("op-signal has name and signal (both required) and profile", async () => {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+        const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
+        const tool = result.tools.find((t) => t.name === "op-signal")!;
+        const props = tool.inputSchema.properties as Record<string, unknown>;
+        expect(props.name).toBeDefined();
+        expect(props.signal).toBeDefined();
+        expect(props.profile).toBeDefined();
+        expect(tool.inputSchema.required).toContain("name");
+        expect(tool.inputSchema.required).toContain("signal");
+      });
+
+      test("op-report has name (required) and profile", async () => {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
+        const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
+        const tool = result.tools.find((t) => t.name === "op-report")!;
+        const props = tool.inputSchema.properties as Record<string, unknown>;
+        expect(props.name).toBeDefined();
+        expect(props.profile).toBeDefined();
+        expect(tool.inputSchema.required).toContain("name");
+      });
+    });
   });
 
   describe("tools/call", () => {
@@ -302,6 +358,74 @@ describe("McpServer", () => {
       expect(parsed.total).toBe(0);
       expect(parsed.results).toEqual([]);
     });
+
+    describe("Op tool handlers", () => {
+      test("op-list returns list without throwing when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: { name: "op-list", arguments: {} },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { content: Array<{ type: string; text: string }>; isError?: boolean };
+        expect(result.content[0].type).toBe("text");
+        // May be empty list or error-degraded — but no thrown error
+        expect(result.isError).toBeUndefined();
+      });
+
+      test("op-run returns isError when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: { name: "op-run", arguments: { name: "nonexistent-op" } },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { content: Array<{ text: string }>; isError?: boolean };
+        // Either "not found" or Temporal error — either way should not be a protocol error
+        expect(result.content[0].text.length).toBeGreaterThan(0);
+      });
+
+      test("op-status returns isError when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: { name: "op-status", arguments: { name: "nonexistent-op" } },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { content: Array<{ text: string }>; isError: boolean };
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Error:");
+      });
+
+      test("op-signal returns isError when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: { name: "op-signal", arguments: { name: "nonexistent-op", signal: "gate" } },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { content: Array<{ text: string }>; isError: boolean };
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Error:");
+      });
+
+      test("op-report returns content without throwing when op not found", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: { name: "op-report", arguments: { name: "nonexistent-op" } },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { content: Array<{ text: string }>; isError?: boolean };
+        // Op not found → returns a "not found" message or Temporal error, not a protocol error
+        expect(result.content[0].text.length).toBeGreaterThan(0);
+      });
+    });
   });
 
   // -----------------------------------------------------------------------
@@ -446,6 +570,9 @@ describe("McpServer", () => {
       const uris = result.resources.map((r) => r.uri);
       expect(uris).toContain("chant://context");
       expect(uris).toContain("chant://examples/list");
+      expect(uris).toContain("chant://ops");
+      expect(uris).toContain("chant://ops/{name}/runs");
+      expect(uris).toContain("chant://ops/{name}/runs/latest");
 
       // Each resource has required fields
       for (const resource of result.resources) {
@@ -549,6 +676,48 @@ describe("McpServer", () => {
       expect(response.error).toBeDefined();
       expect(response.error?.message).toContain("Unknown resource");
     });
+
+    describe("Op resources", () => {
+      test("chant://ops returns an array", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "resources/read",
+          params: { uri: "chant://ops" },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { contents: Array<{ text: string; mimeType: string }> };
+        expect(result.contents[0].mimeType).toBe("application/json");
+        const ops = JSON.parse(result.contents[0].text);
+        expect(Array.isArray(ops)).toBe(true);
+      });
+
+      test("chant://ops/{name}/runs degrades gracefully when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "resources/read",
+          params: { uri: "chant://ops/nonexistent/runs" },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { contents: Array<{ text: string }> };
+        const data = JSON.parse(result.contents[0].text);
+        expect(data.error).toBeDefined();
+      });
+
+      test("chant://ops/{name}/runs/latest degrades gracefully when Temporal unavailable", async () => {
+        const response = await server.handleRequest({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "resources/read",
+          params: { uri: "chant://ops/nonexistent/runs/latest" },
+        });
+        expect(response.error).toBeUndefined();
+        const result = response.result as { contents: Array<{ text: string }> };
+        const data = JSON.parse(result.contents[0].text);
+        expect(data.error).toBeDefined();
+      });
+    });
   });
 
   // -----------------------------------------------------------------------
@@ -962,8 +1131,12 @@ describe("McpServer", () => {
 
       const toolsRes = await s.handleRequest({ jsonrpc: "2.0", id: 2, method: "tools/list" });
       const tools = (toolsRes.result as { tools: Array<{ name: string }> }).tools;
-      expect(tools).toHaveLength(9);
-      expect(tools.map((t) => t.name).sort()).toEqual(["build", "explain", "import", "lint", "scaffold", "search", "spell-done", "state-diff", "state-snapshot"]);
+      expect(tools).toHaveLength(13);
+      expect(tools.map((t) => t.name).sort()).toEqual([
+        "build", "explain", "import", "lint",
+        "op-list", "op-report", "op-run", "op-signal", "op-status",
+        "scaffold", "search", "state-diff", "state-snapshot",
+      ]);
 
       const resourcesRes = await s.handleRequest({ jsonrpc: "2.0", id: 3, method: "resources/list" });
       const resources = (resourcesRes.result as { resources: Array<{ uri: string }> }).resources;
@@ -974,7 +1147,7 @@ describe("McpServer", () => {
       const s = new McpServer([]);
       const toolsRes = await s.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
       const tools = (toolsRes.result as { tools: Array<{ name: string }> }).tools;
-      expect(tools).toHaveLength(9);
+      expect(tools).toHaveLength(13);
     });
   });
 });

package/src/cli/mcp/server.ts

@@ -8,7 +8,8 @@ import { scaffoldTool, createScaffoldHandler } from "./tools/scaffold";
 import { searchTool, createSearchHandler } from "./tools/search";
 import type { LexiconPlugin } from "../../lexicon";
 import type { McpRequest, McpResponse, ToolDefinition, ToolHandler, ResourceDefinition } from "./types";
-import { createSnapshotTool, createDiffTool, createSpellDoneTool } from "./state-tools";
+import { createSnapshotTool, createDiffTool } from "./state-tools";
+import { createOpListTool, createOpRunTool, createOpStatusTool, createOpSignalTool, createOpReportTool } from "./op-tools";
 import { buildResourcesList, handleResourcesRead } from "./resource-handlers";
 
 /**
@@ -35,8 +36,11 @@ export class McpServer {
     const diff = createDiffTool(plugins ?? []);
     this.registerTool(diff.definition, diff.handler);
 
-    const spellDone = createSpellDoneTool();
-    this.registerTool(spellDone.definition, spellDone.handler);
+    // Register Op tools
+    for (const factory of [createOpListTool, createOpRunTool, createOpStatusTool, createOpSignalTool, createOpReportTool]) {
+      const t = factory();
+      this.registerTool(t.definition, t.handler);
+    }
 
     // Register plugin contributions
     if (plugins) {