@intentius/chant 0.1.6 → 0.1.8

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) {

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

@@ -6,8 +6,6 @@ import { build } from "../../build";
 import { computeBuildDigest, diffDigests } from "../../state/digest";
 import { takeSnapshot } from "../../state/snapshot";
 import type { StateSnapshot } from "../../state/types";
-import { discoverSpells } from "../../spell/discovery";
-
 export interface ToolRegistration {
   definition: ToolDefinition;
   handler: ToolHandler;
@@ -87,52 +85,3 @@ export function createDiffTool(plugins: LexiconPlugin[]): ToolRegistration {
   };
 }
 
-/**
- * Create spell-done tool definition and handler
- */
-export function createSpellDoneTool(): ToolRegistration {
-  return {
-    definition: {
-      name: "spell-done",
-      description: "Mark a spell task as done",
-      inputSchema: {
-        type: "object",
-        properties: {
-          name: { type: "string", description: "Spell name" },
-          taskNumber: { type: "number", description: "Task number (1-based)" },
-        },
-        required: ["name", "taskNumber"],
-      },
-    },
-    handler: async (params) => {
-      const { readFileSync, writeFileSync } = await import("node:fs");
-      const { spells } = await discoverSpells();
-      const name = params.name as string;
-      const taskNumber = params.taskNumber as number;
-      const spell = spells.get(name);
-      if (!spell) return `Spell "${name}" not found`;
-      if (taskNumber < 1 || taskNumber > spell.definition.tasks.length) {
-        return `Invalid task number ${taskNumber}`;
-      }
-      const task = spell.definition.tasks[taskNumber - 1];
-      if (task.done) return `Task ${taskNumber} is already done`;
-
-      const content = readFileSync(spell.filePath, "utf-8");
-      let count = 0;
-      const rewritten = content.replace(
-        /task\(("[^"]*"|'[^']*'|`[^`]*`)((?:\s*,\s*\{[^}]*\})?)\)/g,
-        (match, desc, opts) => {
-          count++;
-          if (count !== taskNumber) return match;
-          if (opts && opts.includes("done:")) {
-            return match.replace(/done:\s*false/, "done: true");
-          }
-          return `task(${desc}, { done: true })`;
-        },
-      );
-      if (rewritten === content) return `Could not rewrite task ${taskNumber}`;
-      writeFileSync(spell.filePath, rewritten);
-      return `Task ${taskNumber} marked done: "${task.description}"`;
-    },
-  };
-}

package/src/cli/mcp/tools/search.ts

@@ -52,7 +52,12 @@ export function createSearchHandler(
 
     for (const plugin of candidates) {
       const resources = plugin.mcpResources?.() ?? [];
-      const catalog = resources.find((r) => r.uri === "resource-catalog");
+      // Catalog URIs were unscoped ("resource-catalog") before lexicon
+      // namespacing landed; new lexicons emit "<lexicon>:resource-catalog"
+      // to avoid cross-lexicon collision. Support both.
+      const catalog = resources.find(
+        (r) => r.uri === "resource-catalog" || r.uri.endsWith(":resource-catalog"),
+      );
       if (!catalog) continue;
 
       let entries: CatalogEntry[];

package/src/cli/registry.ts

@@ -18,6 +18,9 @@ export interface ParsedArgs {
   watch: boolean;
   verbose: boolean;
   help: boolean;
+  profile?: string;
+  report?: boolean;
+  live: boolean;
 }
 
 /**

package/src/composite.ts

@@ -95,11 +95,16 @@ export function Composite<P, M extends CompositeMembers = CompositeMembers>(
       }
     }
 
-    const instance: CompositeInstance<M> = {
-      [COMPOSITE_MARKER]: true,
-      members,
-      _definition: definition,
-    };
+    // Define `members` and `_definition` as non-enumerable so spreading a
+    // composite instance (`...someComposite`) only exposes the actual member
+    // resources, not the framework's bookkeeping properties. Without this, a
+    // parent composite that does `...childResult` ends up with a `members` key
+    // pointing at the child's CompositeMembers record — not a Declarable —
+    // which then trips the parent's own member validation.
+    const instance = {} as CompositeInstance<M>;
+    Object.defineProperty(instance, COMPOSITE_MARKER, { value: true, enumerable: false });
+    Object.defineProperty(instance, "members", { value: members, enumerable: false });
+    Object.defineProperty(instance, "_definition", { value: definition, enumerable: false });
 
     return Object.assign(instance, members) as CompositeInstance<M> & M;
   }) as CompositeDefinition<P, M>;

package/src/index.ts

@@ -60,8 +60,7 @@ export * from "./lsp/types";
 export * from "./lsp/lexicon-providers";
 export * from "./mcp/types";
 export * from "./state/index";
-export * from "./spell/index";
 // Op builders — use explicit exports to avoid collision with the core `build` function
 export { Op, phase, activity, gate, kubectlApply, helmInstall, waitForStack,
          gitlabPipeline, stateSnapshot, shell, teardown, OpResource } from "./op/index";
-export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep, RetryPolicy } from "./op/index";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep } from "./op/index";

package/src/lexicon-plugin-helpers.ts

@@ -61,15 +61,18 @@ export function createSkillsLoader(
 /**
  * Create an MCP diff tool contribution for a lexicon.
  *
- * All lexicons (except Azure) expose an identical "diff" tool that compares
- * current build output against previous output using the lexicon's serializer.
+ * All lexicons (except Azure) expose an identical-shape "diff" tool that
+ * compares current build output against previous output using the lexicon's
+ * serializer. The tool name is namespaced by `lexiconName` (e.g. `gcp:diff`)
+ * so multiple lexicons loaded together don't collide on the same tool key.
  */
 export function createDiffTool(
   serializer: Serializer,
   description: string,
+  lexiconName: string,
 ): McpToolContribution {
   return {
-    name: "diff",
+    name: `${lexiconName}:diff`,
     description,
     inputSchema: {
       type: "object" as const,
@@ -96,21 +99,26 @@ export function createDiffTool(
 /**
  * Create an MCP resource that serves the lexicon's meta.json as a catalog.
  *
- * Most lexicons expose a "resource-catalog" resource with identical structure.
+ * Most lexicons expose a "resource-catalog" resource with identical
+ * structure. The URI is namespaced by `lexiconName` (e.g.
+ * `gcp:resource-catalog`) so multiple lexicons loaded together don't
+ * collide on the same resource key.
  *
  * @param importMetaUrl — The plugin's import.meta.url (used to locate generated JSON)
  * @param name — Display name (e.g. "AWS Resource Catalog")
  * @param description — Resource description
  * @param lexiconJsonFile — Filename of the generated lexicon JSON (e.g. "lexicon-aws.json")
+ * @param lexiconName — Short lexicon name (e.g. "aws", "gcp"). Becomes the URI prefix.
  */
 export function createCatalogResource(
   importMetaUrl: string,
   name: string,
   description: string,
   lexiconJsonFile: string,
+  lexiconName: string,
 ): McpResourceContribution {
   return {
-    uri: "resource-catalog",
+    uri: `${lexiconName}:resource-catalog`,
     name,
     description,
     mimeType: "application/json",

package/src/lexicon.ts

@@ -195,12 +195,48 @@ export interface LexiconPlugin {
   mcpResources?(): McpResourceContribution[];
 
   // State
-  /** Query deployed resources and return API metadata. Opt-in. */
+  /**
+   * Query deployed resources and return API metadata. Opt-in.
+   *
+   * Use this when each chant entity has a 1:1 cloud equivalent — e.g. an
+   * AWS CFN resource, a K8s object, an ARM resource, a Temporal namespace.
+   *
+   * `entities` carries the chant-side entity declarations for this lexicon,
+   * keyed by chant entity name (e.g. the export name from a `*.ts` file).
+   * Implementations that need to map cloud-side names back to chant entity
+   * names (e.g. Temporal — server-side namespace `prod` ↔ chant entity `ns`
+   * declared with `name: "prod"`) read this; implementations that already
+   * have name parity (e.g. AWS CloudFormation logical IDs == chant entity
+   * names) can ignore it.
+   *
+   * `entityNames` is preserved as a convenience for the simple case.
+   */
   describeResources?(options: {
     environment: string;
     buildOutput: string;
     entityNames: string[];
+    entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
   }): Promise<Record<string, ResourceMetadata>>;
+
+  /**
+   * List runtime artifacts in the given environment. Opt-in.
+   *
+   * Use this for lexicons whose chant entities describe *authoring*
+   * primitives rather than 1:1 cloud resources — e.g. Helm (charts vs
+   * releases), Docker (Compose vs running containers), Flyway (migration
+   * scripts vs applied migrations). The contract is context-keyed: given an
+   * environment, list all artifacts visible there. There is no `declared`
+   * comparison axis — `state diff --live` reports added/removed/changed
+   * between snapshots, not vs. declared.
+   *
+   * `entities` is passed for cases where the lexicon needs to know what
+   * was declared in order to enumerate (e.g. Flyway needs the declared
+   * `Flyway::Environment` entities to know which DBs to query).
+   */
+  listArtifacts?(options: {
+    environment: string;
+    entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
+  }): Promise<Record<string, ArtifactMetadata>>;
 }
 
 /**
@@ -219,6 +255,26 @@ export interface ResourceMetadata {
   attributes?: Record<string, unknown>;
 }
 
+/**
+ * Metadata about a runtime artifact, returned by listArtifacts. Same shape
+ * as ResourceMetadata; the conceptual distinction is whether the lexicon's
+ * chant entities have 1:1 runtime equivalents (resources) or whether the
+ * runtime artifacts are created by tooling outside chant's entity model
+ * (artifacts — e.g. Helm releases, Docker containers, Flyway migrations).
+ */
+export interface ArtifactMetadata {
+  /** Artifact type (e.g. Helm::Release, Docker::Container) */
+  type: string;
+  /** Server-side identifier */
+  physicalId?: string;
+  /** Provider-specific status string */
+  status: string;
+  /** ISO timestamp of last update */
+  lastUpdated?: string;
+  /** Provider-specific properties */
+  attributes?: Record<string, unknown>;
+}
+
 /**
  * Type guard to check if a value is a LexiconPlugin.
  * Checks for required lifecycle methods in addition to name/serializer.

package/src/lint/config.test.ts

@@ -641,4 +641,25 @@ describe("loadConfig", () => {
     const config = loadConfig(subDir);
     expect(config).toEqual(DEFAULT_CONFIG);
   });
+
+  test("accepts ChantConfig-shape nested lint key in chant.config.json", () => {
+    const configPath = join(TEST_DIR, "chant.config.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        lexicons: ["aws"],
+        lint: {
+          rules: {
+            "test-rule": "error",
+            "noisy-rule": "off",
+          },
+        },
+      }),
+    );
+
+    const config = loadConfig(TEST_DIR);
+
+    expect(config.rules?.["test-rule"]).toBe("error");
+    expect(config.rules?.["noisy-rule"]).toBe("off");
+  });
 });

package/src/lint/config.ts

@@ -223,18 +223,34 @@ function loadConfigFile(configPath: string, visited: Set<string> = new Set()): L
     throw new Error(`Failed to read config file ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
   }
 
-  let config: LintConfig;
+  let raw: unknown;
   try {
-    config = JSON.parse(content);
+    raw = JSON.parse(content);
   } catch (err) {
     throw new Error(`Failed to parse config file ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   // Validate config structure
-  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new Error(`Invalid config file ${configPath}: must be an object`);
   }
 
+  // Accept both shapes: lint fields at top level (legacy) OR nested under a
+  // "lint" key (matches chant.config.ts ChantConfig shape). When the JSON has
+  // both a top-level "rules"/"extends"/etc AND a "lint": {...}, prefer the
+  // nested one — that matches the explicit ChantConfig contract.
+  const rawObj = raw as Record<string, unknown>;
+  let config: LintConfig;
+  if (
+    rawObj.lint &&
+    typeof rawObj.lint === "object" &&
+    !Array.isArray(rawObj.lint)
+  ) {
+    config = rawObj.lint as LintConfig;
+  } else {
+    config = rawObj as LintConfig;
+  }
+
   // Validate with Zod schema
   const parseResult = LintConfigSchema.safeParse(config);
   if (!parseResult.success) {

package/src/op/discover.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import { discoverOps } from "./discover";
+
+// Mock getRuntime to return git root pointing at the repo root
+vi.mock("../runtime-adapter", () => ({
+  getRuntime: () => ({
+    spawn: async (cmd: string[]) => {
+      if (cmd[0] === "git" && cmd[1] === "rev-parse") {
+        // Return the actual repo root so the test can find the example op file
+        const { execFile } = await import("node:child_process");
+        const { promisify } = await import("node:util");
+        const execFileAsync = promisify(execFile);
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+        return { stdout: stdout.trim(), stderr: "", exitCode: 0 };
+      }
+      return { stdout: "", stderr: "", exitCode: 0 };
+    },
+  }),
+}));
+
+describe("discoverOps", () => {
+  test("discovers alb-deploy.op.ts from examples/", async () => {
+    const { ops, errors } = await discoverOps();
+    expect(errors).toHaveLength(0);
+    expect(ops.has("alb-deploy")).toBe(true);
+  });
+
+  test("discovered Op has correct config shape", async () => {
+    const { ops } = await discoverOps();
+    const op = ops.get("alb-deploy");
+    expect(op).toBeDefined();
+    expect(op!.config.name).toBe("alb-deploy");
+    expect(Array.isArray(op!.config.phases)).toBe(true);
+    expect(op!.config.phases.length).toBeGreaterThan(0);
+    expect(typeof op!.config.overview).toBe("string");
+  });
+
+  test("filePath points to the .op.ts source file", async () => {
+    const { ops } = await discoverOps();
+    const op = ops.get("alb-deploy");
+    expect(op!.filePath).toMatch(/alb-deploy\.op\.ts$/);
+  });
+});