@intentius/chant 0.57.0 → 0.58.0

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

@@ -1,56 +1,94 @@
+/**
+ * MCP tools over Ops — on the runtime seam (#2121), not on any one runtime's
+ * own client.
+ *
+ * Every tool here goes through an {@link OpRuntimeProvider} — the built-in
+ * `local` one by default, or the `runtime` argument's lexicon `opRuntime` when
+ * an agent names one. One provider is built per call, so a long-lived server
+ * picks up a project's config as it is now rather than as it was at boot; the
+ * local provider's in-process run history is the exception and is held for the
+ * life of the module, so `op-status` can answer for a run `op-run` started.
+ *
+ * #2118 owns the ledger-backed record shape; when it lands, `status`/`log`
+ * read the ledger and this file stops depending on the process outliving the
+ * run.
+ */
+
 import { resolve } from "node:path";
 import { discoverOps } from "../../op/discover";
-import { makeTemporalClient } from "../handlers/run";
-import { resolveWorkflowId, fetchNormalizedHistory } from "../handlers/run-client";
-import { generateReport } from "../handlers/run-report";
-import { extractStepRecords, countActivities, queryGateState } from "../handlers/op-progress";
+import { createLocalOpRuntime } from "../../op/runtimes/local";
+import type { OpRuntimeProvider } from "../../op/runtime";
+import { loadChantConfig } from "../../config";
+import { loadPlugins } from "../plugins";
+import { recordGateApproval } from "../handlers/operator";
 import type { ToolRegistration } from "./lifecycle-tools";
 
-function workflowFnName(opName: string): string {
-  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
+/** The `local` provider, shared so an `op-run` is visible to a later `op-status`. */
+let localRuntime: OpRuntimeProvider | undefined;
+
+/**
+ * Resolve the runtime a tool call addresses. `runtime` names a configured
+ * lexicon's `opRuntime`; omitted (or `local`) it is core's built-in provider.
+ * Throws with an actionable message — the MCP layer turns that into `isError`.
+ */
+async function runtimeFor(name: unknown): Promise<OpRuntimeProvider> {
+  const wanted = typeof name === "string" && name.length > 0 ? name : "local";
+  if (wanted === "local") {
+    localRuntime ??= createLocalOpRuntime({ projectPath: resolve(".") });
+    return localRuntime;
+  }
+
+  const configured = await loadChantConfig(resolve("."))
+    .then(({ config }) => config.lexicons ?? [])
+    .catch(() => [] as string[]);
+  if (!configured.includes(wanted)) {
+    throw new Error(
+      `runtime "${wanted}" is not a configured lexicon` +
+        (configured.length > 0 ? ` (configured: ${configured.join(", ")})` : ""),
+    );
+  }
+  const plugin = (await loadPlugins([wanted]))[0];
+  if (!plugin?.opRuntime) throw new Error(`lexicon "${wanted}" does not host Op runs`);
+  return plugin.opRuntime;
 }
 
+const RUNTIME_PARAM = {
+  type: "string",
+  description: 'Runtime to address: a lexicon name with an opRuntime, or "local" (the default)',
+} as const;
+
 export function createOpListTool(): ToolRegistration {
   return {
     definition: {
       name: "op-list",
-      description: "List all Op definitions discovered from *.op.ts files with their current run status",
+      description: "List all Op definitions discovered from *.op.ts files with their current run state",
       inputSchema: {
         type: "object",
         properties: {
-          profile: { type: "string", description: "Temporal profile name from chant.config.ts (optional)" },
+          runtime: RUNTIME_PARAM,
         },
       },
     },
     handler: async (params) => {
       const { ops, errors } = await discoverOps();
-      const profile = params.profile as string | undefined;
 
-      let client: Awaited<ReturnType<typeof makeTemporalClient>>["client"] | undefined;
+      let states: Map<string, { state: string } | undefined> = new Map();
       try {
-        ({ client } = await makeTemporalClient(profile, resolve(".")));
+        const runtime = await runtimeFor(params.runtime);
+        states = await runtime.list([...ops.values()].map((d) => d.config));
       } catch {
-        // Temporal not available — degrade gracefully
+        // Runtime unavailable — the definitions are still worth listing.
       }
 
       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,
+          labels: config.labels ?? {},
           depends: config.depends ?? [],
-          runStatus,
+          runState: states.get(name)?.state ?? "—",
         });
       }
 
@@ -64,19 +102,18 @@ export function createOpRunTool(): ToolRegistration {
     definition: {
       name: "op-run",
       description:
-        "Submit an Op workflow to Temporal (Temporal mode). A Temporal worker must already be running — start it with `chant run <name> --temporal`.",
+        "Run an Op on a runtime and return its result. Defaults to the built-in local runtime, which executes the Op in this process.",
       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)" },
+          runtime: RUNTIME_PARAM,
         },
         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)) {
@@ -84,18 +121,19 @@ export function createOpRunTool(): ToolRegistration {
         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",
-      });
+      const runtime = await runtimeFor(params.runtime);
+      const handle = await runtime.start(ops.get(name)!.config, {});
+      const status = await handle.result();
 
-      return { workflowId, message: `Workflow "${workflowId}" submitted to task queue "${taskQueue}"` };
+      return {
+        op: status.op,
+        runId: status.runId,
+        state: status.state,
+        startedAt: status.startedAt,
+        endedAt: status.endedAt ?? null,
+        ...(status.records ? { records: status.records } : {}),
+        ...(status.gate ? { gate: status.gate } : {}),
+      };
     },
   };
 }
@@ -104,78 +142,81 @@ export function createOpStatusTool(): ToolRegistration {
   return {
     definition: {
       name: "op-status",
-      description: "Return the current run state of an Op workflow",
+      description: "Return the current run state of an Op on a runtime",
       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)" },
+          runtime: RUNTIME_PARAM,
         },
         required: ["name"],
       },
     },
     handler: async (params) => {
       const name = params.name as string;
-      const profile = params.profile as string | undefined;
 
       const { ops } = await discoverOps();
-      const config = ops.get(name)?.config;
-
-      const { client } = await makeTemporalClient(profile, resolve("."));
-      const handle = client.workflow.getHandle(resolveWorkflowId(name));
-      const desc = await handle.describe();
-      const history = await fetchNormalizedHistory(handle);
-
-      const { completed: activitiesCompleted, scheduled: activitiesScheduled } = countActivities(history);
-      // Per-phase progress (#1676) — the same StepRecord shape `chant run
-      // <name> --json` uses locally, so a consumer renders one way
-      // regardless of executor. Only buildable when the Op's config was
-      // discoverable (a *.op.ts file on disk); absent otherwise rather than
-      // guessed at.
-      const progress = config ? extractStepRecords(config, history, { final: Boolean(desc.closeTime) }) : undefined;
-      const gate = await queryGateState(handle);
+      if (!ops.has(name)) throw new Error(`Op "${name}" not found`);
+
+      const runtime = await runtimeFor(params.runtime);
+      const status = await runtime.status(name);
+      if (!status) return { op: name, runtime: runtime.name, state: null, message: "no run recorded" };
 
       return {
-        workflowId: desc.workflowId,
-        runId: desc.runId,
-        status: desc.status.name,
-        startTime: desc.startTime,
-        closeTime: desc.closeTime ?? null,
-        taskQueue: desc.taskQueue,
-        activitiesCompleted,
-        activitiesScheduled,
-        ...(progress ? { progress } : {}),
-        gate: gate ?? null,
+        op: status.op,
+        runtime: runtime.name,
+        runId: status.runId,
+        state: status.state,
+        startedAt: status.startedAt,
+        endedAt: status.endedAt ?? null,
+        ...(status.records ? { records: status.records } : {}),
+        gate: status.gate ?? null,
       };
     },
   };
 }
 
-export function createOpSignalTool(): ToolRegistration {
+export function createOpApproveTool(): ToolRegistration {
   return {
     definition: {
-      name: "op-signal",
-      description: "Send a named signal to an Op workflow (e.g. to unblock a gate step)",
+      name: "op-approve",
+      description:
+        "Record a gate's resolution on the gate ledger and wake the runtime hosting the gated run. The rename of op-signal: a gate is resolved by recording the fact, not by sending a message.",
       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)" },
+          gate: { type: "string", description: "Gate name (e.g. gate-dns-delegation)" },
+          approver: { type: "string", description: "Who approved; defaults to the CI or shell identity" },
+          note: { type: "string", description: "Free-text context recorded on the resolution" },
+          url: { type: "string", description: "Absolute http/https URL this resolution happened at" },
+          runtime: RUNTIME_PARAM,
         },
-        required: ["name", "signal"],
+        required: ["name", "gate"],
       },
     },
     handler: async (params) => {
       const name = params.name as string;
-      const signal = params.signal as string;
-      const profile = params.profile as string | undefined;
+      const gate = params.gate as string;
+      if (!name || !gate) throw new Error("op-approve needs both an Op name and a gate name");
 
-      const { client } = await makeTemporalClient(profile, resolve("."));
-      const handle = client.workflow.getHandle(resolveWorkflowId(name));
-      await handle.signal(signal);
+      const runtime = await runtimeFor(params.runtime);
+      const outcome = await recordGateApproval(name, gate, {
+        actor: params.approver as string | undefined,
+        note: params.note as string | undefined,
+        url: params.url as string | undefined,
+      });
+      if (!outcome.ok) throw new Error(`Gate "${gate}" on "${name}" was not recorded`);
+
+      if (runtime.resolveGate) await runtime.resolveGate(name, gate, outcome.record);
 
-      return `Signal "${signal}" sent to Op "${name}"`;
+      return {
+        op: name,
+        gate,
+        resolvedBy: outcome.record.resolvedBy,
+        timestamp: outcome.record.timestamp,
+        runtimeNotified: Boolean(runtime.resolveGate),
+      };
     },
   };
 }
@@ -184,32 +225,50 @@ export function createOpReportTool(): ToolRegistration {
   return {
     definition: {
       name: "op-report",
-      description: "Return a markdown deployment report for the latest run of an Op",
+      description: "Return a markdown report for the latest run of an Op on a runtime",
       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)" },
+          runtime: RUNTIME_PARAM,
         },
         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`;
-      }
+      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 fetchNormalizedHistory(handle);
+      const runtime = await runtimeFor(params.runtime);
+      const status = await runtime.status(name);
+      if (!status) return `# ${name}\n\n${config.overview}\n\nNo run is recorded on the "${runtime.name}" runtime.\n`;
+
+      const lines = [
+        `# ${name}`,
+        "",
+        config.overview,
+        "",
+        `- Runtime: ${runtime.name}`,
+        `- Run: ${status.runId}`,
+        `- State: ${status.state}`,
+        `- Started: ${status.startedAt}`,
+        ...(status.endedAt ? [`- Ended: ${status.endedAt}`] : []),
+        ...(status.gate ? [`- Gate: ${status.gate.name} (pending since ${status.gate.since})`] : []),
+        "",
+      ];
+
+      if (status.records?.length) {
+        lines.push("| Phase | Step | Status | Duration |", "|---|---|---|---|");
+        for (const record of status.records) {
+          lines.push(`| ${record.phase} | ${record.fn} | ${record.status} | ${record.durationMs}ms |`);
+        }
+        lines.push("");
+      }
 
-      return generateReport(name, config, desc, history);
+      return lines.join("\n");
     },
   };
 }

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

@@ -4,9 +4,7 @@ import type { ResourceDefinition } from "./types";
 import { getContext } from "./resources/context";
 import { readSnapshot, readEnvironmentSnapshots } from "../../lifecycle/git";
 import { discoverOps } from "../../op/discover";
-import { makeTemporalClient } from "../handlers/run";
-import { resolveWorkflowId, fetchNormalizedHistory } from "../handlers/run-client";
-import { extractStepRecords, countActivities, queryGateState } from "../handlers/op-progress";
+import { createLocalOpRuntime } from "../../op/runtimes/local";
 import { loadOkfBundle } from "../../okf-read";
 import { loadChantConfigUpward, resolveKnowledgeDir } from "../../config";
 
@@ -37,7 +35,7 @@ export const coreResourceDefinitions: ResourceDefinition[] = [
   {
     uri: "chant://ops/{name}/runs",
     name: "Op run history",
-    description: "Workflow run history for a named Op",
+    description: "Run history for a named Op, newest first",
     mimeType: "application/json",
   },
   {
@@ -95,10 +93,6 @@ 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
  */
@@ -167,7 +161,7 @@ export async function handleResourcesRead(
       name: config.name,
       overview: config.overview,
       phases: config.phases.length,
-      taskQueue: config.taskQueue ?? config.name,
+      labels: config.labels ?? {},
       depends: config.depends ?? [],
     }));
     return {
@@ -175,33 +169,16 @@ export async function handleResourcesRead(
     };
   }
 
+  // Both run resources read the built-in local runtime (#2121, #2116) — the
+  // one an MCP client can address without naming a lexicon. `status` and `log`
+  // answer from the run ledger (#2118), so a run that ended in an earlier
+  // process still reads back here.
   if (uri.startsWith("chant://ops/") && uri.endsWith("/runs/latest")) {
     const name = uri.replace("chant://ops/", "").replace("/runs/latest", "");
     try {
-      const { ops } = await discoverOps();
-      const config = ops.get(name)?.config;
-
-      const { client } = await makeTemporalClient(undefined, resolve("."));
-      const handle = client.workflow.getHandle(resolveWorkflowId(name));
-      const desc = await handle.describe();
-      const history = await fetchNormalizedHistory(handle);
-      const { completed: activitiesCompleted, scheduled: activitiesScheduled } = countActivities(history);
-      const progress = config ? extractStepRecords(config, history, { final: Boolean(desc.closeTime) }) : undefined;
-      const gate = await queryGateState(handle);
-      const result = {
-        workflowId: desc.workflowId,
-        runId: desc.runId,
-        status: desc.status.name,
-        startTime: desc.startTime,
-        closeTime: desc.closeTime ?? null,
-        taskQueue: desc.taskQueue,
-        activitiesCompleted,
-        activitiesScheduled,
-        ...(progress ? { progress } : {}),
-        gate: gate ?? null,
-      };
+      const status = await createLocalOpRuntime({ projectPath: resolve(".") }).status(name);
       return {
-        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }],
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(status ?? null, null, 2) }],
       };
     } catch (err) {
       return {
@@ -213,11 +190,7 @@ export async function handleResourcesRead(
   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 });
-      }
+      const runs = await createLocalOpRuntime({ projectPath: resolve(".") }).log(name);
       return {
         contents: [{ uri, mimeType: "application/json", text: JSON.stringify(runs, null, 2) }],
       };

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

@@ -49,32 +49,31 @@ chant import template.json    # Convert external template
 chant import template.json -o ./src/  # Custom output dir
 \`\`\`
 
-## Ops (Temporal Workflows)
+## Ops
 
-Ops are durable workflow definitions backed by Temporal. Each \`*.op.ts\` file declares an Op with named phases and activity steps.
+An Op is a convergent verb. Each \`*.op.ts\` file declares one with named phases and activity steps; \`--on <lexicon>\` picks the runtime that hosts the run, and the built-in local runtime runs it in-process otherwise.
 
 ### 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\`. |
+| \`op-list\` | List all discovered Ops with their current run state. |
+| \`op-run\` | Run an Op and return its result. Requires \`name\`. |
+| \`op-status\` | Get current run state (state, step records, times). Requires \`name\`. |
+| \`op-approve\` | Record a gate's resolution and wake the runtime hosting the run. Requires \`name\` and \`gate\`. |
+| \`op-report\` | Return a markdown 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\`.
+All Op tools accept an optional \`runtime\` parameter: a lexicon name whose \`opRuntime\` hosts the run, or \`local\` (the default) for the built-in in-process runtime.
 
 ### 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\` | JSON array of all Op definitions (name, overview, phase count, labels, depends) |
+| \`chant://ops/{name}/runs\` | Run ledger history for a named Op, newest first |
 | \`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\`).
+Both run resources read the built-in local runtime, the one an MCP client can address without naming a lexicon.
 
 ## Best Practices
 

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

@@ -467,50 +467,50 @@ describe("McpServer", () => {
         return tool.inputSchema.properties as Record<string, unknown>;
       }
 
-      test("op-list has profile property", async () => {
+      test("op-list has a runtime property", async () => {
         const props = await getToolProps("op-list");
-        expect(props.profile).toBeDefined();
+        expect(props.runtime).toBeDefined();
       });
 
-      test("op-run has name (required) and profile", async () => {
+      test("op-run has name (required) and runtime", 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(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
 
-      test("op-status has name (required) and profile", async () => {
+      test("op-status has name (required) and runtime", 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(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
 
-      test("op-signal has name and signal (both required) and profile", async () => {
+      test("op-approve has name and gate (both required), plus runtime (#2121)", 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 tool = result.tools.find((t) => t.name === "op-approve")!;
         const props = tool.inputSchema.properties as Record<string, unknown>;
         expect(props.name).toBeDefined();
-        expect(props.signal).toBeDefined();
-        expect(props.profile).toBeDefined();
+        expect(props.gate).toBeDefined();
+        expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
-        expect(tool.inputSchema.required).toContain("signal");
+        expect(tool.inputSchema.required).toContain("gate");
       });
 
-      test("op-report has name (required) and profile", async () => {
+      test("op-report has name (required) and runtime", 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(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
     });
@@ -640,7 +640,7 @@ describe("McpServer", () => {
     });
 
     describe("Op tool handlers", () => {
-      test("op-list returns list without throwing when Temporal unavailable", async () => {
+      test("op-list returns list without throwing when no runtime has a record", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -654,7 +654,7 @@ describe("McpServer", () => {
         expect(result.isError).toBeUndefined();
       });
 
-      test("op-run returns isError when Temporal unavailable", async () => {
+      test("op-run answers for an Op that does not exist", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -663,11 +663,11 @@ describe("McpServer", () => {
         });
         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
+        // Either "not found" or a runtime error — either way, not a protocol error
         expect(result.content[0].text.length).toBeGreaterThan(0);
       });
 
-      test("op-status returns isError when Temporal unavailable", async () => {
+      test("op-status returns isError for an Op that does not exist", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -680,12 +680,12 @@ describe("McpServer", () => {
         expect(result.content[0].text).toContain("Error:");
       });
 
-      test("op-signal returns isError when Temporal unavailable", async () => {
+      test("op-approve returns isError without a gate name (#2121)", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
           method: "tools/call",
-          params: { name: "op-signal", arguments: { name: "nonexistent-op", signal: "gate" } },
+          params: { name: "op-approve", arguments: { name: "nonexistent-op" } },
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { content: Array<{ text: string }>; isError: boolean };
@@ -702,7 +702,7 @@ describe("McpServer", () => {
         });
         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
+        // Op not found → returns a "not found" message or a runtime error, not a protocol error
         expect(result.content[0].text.length).toBeGreaterThan(0);
       });
     });
@@ -973,7 +973,7 @@ describe("McpServer", () => {
         expect(Array.isArray(ops)).toBe(true);
       });
 
-      test("chant://ops/{name}/runs degrades gracefully when Temporal unavailable", async () => {
+      test("chant://ops/{name}/runs is an empty list for an Op with no recorded run", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -982,11 +982,10 @@ describe("McpServer", () => {
         });
         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();
+        expect(JSON.parse(result.contents[0].text)).toEqual([]);
       });
 
-      test("chant://ops/{name}/runs/latest degrades gracefully when Temporal unavailable", async () => {
+      test("chant://ops/{name}/runs/latest is null for an Op with no recorded run", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -995,8 +994,7 @@ describe("McpServer", () => {
         });
         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();
+        expect(JSON.parse(result.contents[0].text)).toBeNull();
       });
     });
 
@@ -1471,7 +1469,7 @@ describe("McpServer", () => {
       expect(tools).toHaveLength(13);
       expect(tools.map((t) => t.name).sort()).toEqual([
         "build", "explain", "import", "lifecycle-diff", "lifecycle-snapshot", "lint",
-        "op-list", "op-report", "op-run", "op-signal", "op-status",
+        "op-approve", "op-list", "op-report", "op-run", "op-status",
         "scaffold", "search",
       ]);