@multiplier-labs/stepflow 0.3.1 → 0.3.3

package/src/planning/planning.test.ts

@@ -1,13 +1,9 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  MemoryRecipeRegistry,
-  MemoryStepHandlerRegistry,
-  createRegistry,
-} from "./registry";
-import { RuleBasedPlanner } from "./planner";
-import type { Recipe, RecipeCondition, PlanningContext } from "./types";
-
-describe("MemoryRecipeRegistry", () => {
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryRecipeRegistry, MemoryStepHandlerRegistry, createRegistry } from './registry';
+import { RuleBasedPlanner } from './planner';
+import type { Recipe, RecipeCondition, PlanningContext } from './types';
+
+describe('MemoryRecipeRegistry', () => {
   let registry: MemoryRecipeRegistry;
 
   beforeEach(() => {
@@ -15,225 +11,195 @@ describe("MemoryRecipeRegistry", () => {
   });
 
   const createTestRecipe = (overrides: Partial<Recipe> = {}): Recipe => ({
-    id: "test.recipe",
-    name: "Test Recipe",
-    workflowKind: "test.workflow",
-    variant: "default",
-    steps: [{ key: "step1", name: "Step 1", handlerRef: "handlers.step1" }],
+    id: 'test.recipe',
+    name: 'Test Recipe',
+    workflowKind: 'test.workflow',
+    variant: 'default',
+    steps: [
+      { key: 'step1', name: 'Step 1', handlerRef: 'handlers.step1' },
+    ],
     ...overrides,
   });
 
-  describe("register", () => {
-    it("should register a recipe", () => {
+  describe('register', () => {
+    it('should register a recipe', () => {
       const recipe = createTestRecipe();
       registry.register(recipe);
 
-      expect(registry.has("test.recipe")).toBe(true);
-      expect(registry.get("test.recipe")).toEqual(recipe);
+      expect(registry.has('test.recipe')).toBe(true);
+      expect(registry.get('test.recipe')).toEqual(recipe);
     });
 
-    it("should throw if recipe already registered", () => {
+    it('should throw if recipe already registered', () => {
       const recipe = createTestRecipe();
       registry.register(recipe);
 
       expect(() => registry.register(recipe)).toThrow(
-        "Recipe 'test.recipe' is already registered",
+        "Recipe 'test.recipe' is already registered"
       );
     });
 
-    it("should throw if variant already exists for workflow kind", () => {
-      const recipe1 = createTestRecipe({ id: "recipe1" });
-      const recipe2 = createTestRecipe({ id: "recipe2" });
+    it('should throw if variant already exists for workflow kind', () => {
+      const recipe1 = createTestRecipe({ id: 'recipe1' });
+      const recipe2 = createTestRecipe({ id: 'recipe2' });
 
       registry.register(recipe1);
 
       expect(() => registry.register(recipe2)).toThrow(
-        "Recipe variant 'default' for 'test.workflow' is already registered",
+        "Recipe variant 'default' for 'test.workflow' is already registered"
       );
     });
   });
 
-  describe("getByKind", () => {
-    it("should return all recipes for a workflow kind", () => {
-      registry.register(
-        createTestRecipe({ id: "recipe1", variant: "default" }),
-      );
-      registry.register(createTestRecipe({ id: "recipe2", variant: "fast" }));
-      registry.register(
-        createTestRecipe({
-          id: "recipe3",
-          workflowKind: "other.workflow",
-          variant: "default",
-        }),
-      );
+  describe('getByKind', () => {
+    it('should return all recipes for a workflow kind', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'fast' }));
+      registry.register(createTestRecipe({
+        id: 'recipe3',
+        workflowKind: 'other.workflow',
+        variant: 'default',
+      }));
 
-      const recipes = registry.getByKind("test.workflow");
+      const recipes = registry.getByKind('test.workflow');
       expect(recipes).toHaveLength(2);
-      expect(recipes.map((r) => r.id)).toContain("recipe1");
-      expect(recipes.map((r) => r.id)).toContain("recipe2");
+      expect(recipes.map(r => r.id)).toContain('recipe1');
+      expect(recipes.map(r => r.id)).toContain('recipe2');
     });
 
-    it("should return empty array if no recipes found", () => {
-      expect(registry.getByKind("nonexistent")).toEqual([]);
+    it('should return empty array if no recipes found', () => {
+      expect(registry.getByKind('nonexistent')).toEqual([]);
     });
   });
 
-  describe("getVariant", () => {
-    it("should return specific variant", () => {
-      registry.register(
-        createTestRecipe({ id: "recipe1", variant: "default" }),
-      );
-      registry.register(createTestRecipe({ id: "recipe2", variant: "fast" }));
+  describe('getVariant', () => {
+    it('should return specific variant', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'fast' }));
 
-      const recipe = registry.getVariant("test.workflow", "fast");
-      expect(recipe?.id).toBe("recipe2");
+      const recipe = registry.getVariant('test.workflow', 'fast');
+      expect(recipe?.id).toBe('recipe2');
     });
 
-    it("should return undefined if variant not found", () => {
+    it('should return undefined if variant not found', () => {
       registry.register(createTestRecipe());
 
-      expect(
-        registry.getVariant("test.workflow", "nonexistent"),
-      ).toBeUndefined();
+      expect(registry.getVariant('test.workflow', 'nonexistent')).toBeUndefined();
     });
   });
 
-  describe("getDefault", () => {
-    it("should return default variant if exists", () => {
-      registry.register(
-        createTestRecipe({ id: "recipe1", variant: "default" }),
-      );
-      registry.register(createTestRecipe({ id: "recipe2", variant: "fast" }));
+  describe('getDefault', () => {
+    it('should return default variant if exists', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'fast' }));
 
-      const recipe = registry.getDefault("test.workflow");
-      expect(recipe?.variant).toBe("default");
+      const recipe = registry.getDefault('test.workflow');
+      expect(recipe?.variant).toBe('default');
     });
 
-    it("should return lowest priority recipe if no default variant", () => {
-      registry.register(
-        createTestRecipe({ id: "recipe1", variant: "fast", priority: 10 }),
-      );
-      registry.register(
-        createTestRecipe({ id: "recipe2", variant: "slow", priority: 5 }),
-      );
+    it('should return lowest priority recipe if no default variant', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'fast', priority: 10 }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'slow', priority: 5 }));
 
-      const recipe = registry.getDefault("test.workflow");
-      expect(recipe?.id).toBe("recipe2");
+      const recipe = registry.getDefault('test.workflow');
+      expect(recipe?.id).toBe('recipe2');
     });
   });
 
-  describe("listVariants", () => {
-    it("should list all variants for a workflow kind", () => {
-      registry.register(
-        createTestRecipe({ id: "recipe1", variant: "default" }),
-      );
-      registry.register(createTestRecipe({ id: "recipe2", variant: "fast" }));
-      registry.register(
-        createTestRecipe({ id: "recipe3", variant: "thorough" }),
-      );
+  describe('listVariants', () => {
+    it('should list all variants for a workflow kind', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'fast' }));
+      registry.register(createTestRecipe({ id: 'recipe3', variant: 'thorough' }));
 
-      const variants = registry.listVariants("test.workflow");
+      const variants = registry.listVariants('test.workflow');
       expect(variants).toHaveLength(3);
-      expect(variants).toContain("default");
-      expect(variants).toContain("fast");
-      expect(variants).toContain("thorough");
+      expect(variants).toContain('default');
+      expect(variants).toContain('fast');
+      expect(variants).toContain('thorough');
     });
   });
 
-  describe("query", () => {
-    it("should filter by workflow kind", () => {
-      registry.register(createTestRecipe({ id: "recipe1", variant: "v1" }));
-      registry.register(
-        createTestRecipe({
-          id: "recipe2",
-          workflowKind: "other",
-          variant: "v1",
-        }),
-      );
+  describe('query', () => {
+    it('should filter by workflow kind', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'v1' }));
+      registry.register(createTestRecipe({
+        id: 'recipe2',
+        workflowKind: 'other',
+        variant: 'v1',
+      }));
 
-      const results = registry.query({ workflowKind: "test.workflow" });
+      const results = registry.query({ workflowKind: 'test.workflow' });
       expect(results).toHaveLength(1);
-      expect(results[0].id).toBe("recipe1");
+      expect(results[0].id).toBe('recipe1');
     });
 
-    it("should filter by tags", () => {
-      registry.register(
-        createTestRecipe({
-          id: "recipe1",
-          variant: "v1",
-          tags: ["fast", "simple"],
-        }),
-      );
-      registry.register(
-        createTestRecipe({
-          id: "recipe2",
-          variant: "v2",
-          tags: ["slow", "complex"],
-        }),
-      );
+    it('should filter by tags', () => {
+      registry.register(createTestRecipe({ id: 'recipe1', variant: 'v1', tags: ['fast', 'simple'] }));
+      registry.register(createTestRecipe({ id: 'recipe2', variant: 'v2', tags: ['slow', 'complex'] }));
 
-      const results = registry.query({ tags: ["fast"] });
+      const results = registry.query({ tags: ['fast'] });
       expect(results).toHaveLength(1);
-      expect(results[0].id).toBe("recipe1");
+      expect(results[0].id).toBe('recipe1');
     });
   });
 });
 
-describe("MemoryStepHandlerRegistry", () => {
+describe('MemoryStepHandlerRegistry', () => {
   let registry: MemoryStepHandlerRegistry;
 
   beforeEach(() => {
     registry = new MemoryStepHandlerRegistry();
   });
 
-  it("should register and retrieve handlers", () => {
+  it('should register and retrieve handlers', () => {
     const handler = {
-      id: "test.handler",
-      description: "Test handler",
-      handler: async () => ({ result: "test" }),
+      id: 'test.handler',
+      description: 'Test handler',
+      handler: async () => ({ result: 'test' }),
     };
 
     registry.register(handler);
 
-    expect(registry.has("test.handler")).toBe(true);
-    expect(registry.get("test.handler")).toEqual(handler);
+    expect(registry.has('test.handler')).toBe(true);
+    expect(registry.get('test.handler')).toEqual(handler);
   });
 
-  it("should throw if handler already registered", () => {
+  it('should throw if handler already registered', () => {
     const handler = {
-      id: "test.handler",
+      id: 'test.handler',
       handler: async () => ({}),
     };
 
     registry.register(handler);
 
     expect(() => registry.register(handler)).toThrow(
-      "Step handler 'test.handler' is already registered",
+      "Step handler 'test.handler' is already registered"
     );
   });
 
-  it("should list handlers by tag", () => {
+  it('should list handlers by tag', () => {
     registry.register({
-      id: "handler1",
+      id: 'handler1',
       handler: async () => ({}),
-      tags: ["llm", "text"],
+      tags: ['llm', 'text'],
     });
     registry.register({
-      id: "handler2",
+      id: 'handler2',
       handler: async () => ({}),
-      tags: ["data", "text"],
+      tags: ['data', 'text'],
     });
 
-    const llmHandlers = registry.listByTag("llm");
+    const llmHandlers = registry.listByTag('llm');
     expect(llmHandlers).toHaveLength(1);
-    expect(llmHandlers[0].id).toBe("handler1");
+    expect(llmHandlers[0].id).toBe('handler1');
 
-    const textHandlers = registry.listByTag("text");
+    const textHandlers = registry.listByTag('text');
     expect(textHandlers).toHaveLength(2);
   });
 });
 
-describe("RuleBasedPlanner", () => {
+describe('RuleBasedPlanner', () => {
   let registry: MemoryRecipeRegistry;
   let planner: RuleBasedPlanner;
 
@@ -243,156 +209,132 @@ describe("RuleBasedPlanner", () => {
   });
 
   const createTestRecipe = (overrides: Partial<Recipe> = {}): Recipe => ({
-    id: "test.recipe",
-    name: "Test Recipe",
-    workflowKind: "test.workflow",
-    variant: "default",
+    id: 'test.recipe',
+    name: 'Test Recipe',
+    workflowKind: 'test.workflow',
+    variant: 'default',
     steps: [
-      { key: "step1", name: "Step 1", handlerRef: "handlers.step1" },
-      { key: "step2", name: "Step 2", handlerRef: "handlers.step2" },
+      { key: 'step1', name: 'Step 1', handlerRef: 'handlers.step1' },
+      { key: 'step2', name: 'Step 2', handlerRef: 'handlers.step2' },
     ],
     ...overrides,
   });
 
-  describe("selectRecipe", () => {
-    it("should select recipe with matching conditions", async () => {
+  describe('selectRecipe', () => {
+    it('should select recipe with matching conditions', async () => {
       const conditions: RecipeCondition[] = [
-        { field: "priority", operator: "eq", value: "speed" },
+        { field: 'priority', operator: 'eq', value: 'speed' },
       ];
 
-      registry.register(
-        createTestRecipe({ id: "default", variant: "default" }),
-      );
-      registry.register(
-        createTestRecipe({
-          id: "fast",
-          variant: "fast",
-          conditions,
-          priority: 10,
-        }),
-      );
+      registry.register(createTestRecipe({ id: 'default', variant: 'default' }));
+      registry.register(createTestRecipe({
+        id: 'fast',
+        variant: 'fast',
+        conditions,
+        priority: 10,
+      }));
 
-      const result = await planner.selectRecipe("test.workflow", {
-        priority: "speed",
-      });
+      const result = await planner.selectRecipe('test.workflow', { priority: 'speed' });
 
-      expect(result.recipe.id).toBe("fast");
+      expect(result.recipe.id).toBe('fast');
       expect(result.score).toBeGreaterThan(0);
     });
 
-    it("should fall back to default if no conditions match", async () => {
-      registry.register(
-        createTestRecipe({ id: "default", variant: "default" }),
-      );
-      registry.register(
-        createTestRecipe({
-          id: "fast",
-          variant: "fast",
-          conditions: [{ field: "priority", operator: "eq", value: "speed" }],
-        }),
-      );
+    it('should fall back to default if no conditions match', async () => {
+      registry.register(createTestRecipe({ id: 'default', variant: 'default' }));
+      registry.register(createTestRecipe({
+        id: 'fast',
+        variant: 'fast',
+        conditions: [{ field: 'priority', operator: 'eq', value: 'speed' }],
+      }));
 
-      const result = await planner.selectRecipe("test.workflow", {
-        priority: "quality",
-      });
+      const result = await planner.selectRecipe('test.workflow', { priority: 'quality' });
 
-      expect(result.recipe.id).toBe("default");
+      expect(result.recipe.id).toBe('default');
     });
 
-    it("should use forced recipe from hints", async () => {
-      registry.register(
-        createTestRecipe({ id: "default", variant: "default" }),
-      );
-      registry.register(
-        createTestRecipe({ id: "specific", variant: "specific" }),
-      );
+    it('should use forced recipe from hints', async () => {
+      registry.register(createTestRecipe({ id: 'default', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'specific', variant: 'specific' }));
 
       const context: PlanningContext = {
-        hints: { forceRecipeId: "specific" },
+        hints: { forceRecipeId: 'specific' },
       };
 
-      const result = await planner.selectRecipe("test.workflow", {}, context);
+      const result = await planner.selectRecipe('test.workflow', {}, context);
 
-      expect(result.recipe.id).toBe("specific");
+      expect(result.recipe.id).toBe('specific');
       expect(result.score).toBe(100);
     });
 
-    it("should use preferred variant from hints", async () => {
-      registry.register(
-        createTestRecipe({ id: "default", variant: "default" }),
-      );
-      registry.register(createTestRecipe({ id: "fast", variant: "fast" }));
+    it('should use preferred variant from hints', async () => {
+      registry.register(createTestRecipe({ id: 'default', variant: 'default' }));
+      registry.register(createTestRecipe({ id: 'fast', variant: 'fast' }));
 
       const context: PlanningContext = {
-        hints: { preferredVariant: "fast" },
+        hints: { preferredVariant: 'fast' },
       };
 
-      const result = await planner.selectRecipe("test.workflow", {}, context);
+      const result = await planner.selectRecipe('test.workflow', {}, context);
 
-      expect(result.recipe.id).toBe("fast");
+      expect(result.recipe.id).toBe('fast');
     });
 
-    it("should throw if no recipes found", async () => {
-      await expect(planner.selectRecipe("nonexistent", {})).rejects.toThrow(
-        "No recipes found for workflow kind: nonexistent",
-      );
+    it('should throw if no recipes found', async () => {
+      await expect(
+        planner.selectRecipe('nonexistent', {})
+      ).rejects.toThrow('No recipes found for workflow kind: nonexistent');
     });
   });
 
-  describe("generatePlan", () => {
-    it("should generate a plan from a recipe", async () => {
+  describe('generatePlan', () => {
+    it('should generate a plan from a recipe', async () => {
       const recipe = createTestRecipe();
 
       const plan = await planner.generatePlan(recipe, {});
 
-      expect(plan.recipeId).toBe("test.recipe");
-      expect(plan.variant).toBe("default");
+      expect(plan.recipeId).toBe('test.recipe');
+      expect(plan.variant).toBe('default');
       expect(plan.steps).toHaveLength(2);
-      expect(plan.steps[0].key).toBe("step1");
-      expect(plan.steps[1].key).toBe("step2");
+      expect(plan.steps[0].key).toBe('step1');
+      expect(plan.steps[1].key).toBe('step2');
     });
 
-    it("should apply skip hints", async () => {
+    it('should apply skip hints', async () => {
       const recipe = createTestRecipe();
       const context: PlanningContext = {
-        hints: { skipSteps: ["step1"] },
+        hints: { skipSteps: ['step1'] },
       };
 
       const plan = await planner.generatePlan(recipe, {}, context);
 
       expect(plan.steps).toHaveLength(1);
-      expect(plan.steps[0].key).toBe("step2");
+      expect(plan.steps[0].key).toBe('step2');
       expect(plan.modifications).toContainEqual(
-        expect.objectContaining({ type: "remove_step", stepKey: "step1" }),
+        expect.objectContaining({ type: 'remove_step', stepKey: 'step1' })
       );
     });
 
-    it("should apply additional config from hints", async () => {
+    it('should apply additional config from hints', async () => {
       const recipe = createTestRecipe();
       const context: PlanningContext = {
-        hints: { additionalConfig: { depth: "comprehensive" } },
+        hints: { additionalConfig: { depth: 'comprehensive' } },
       };
 
       const plan = await planner.generatePlan(recipe, {}, context);
 
-      expect(plan.steps[0].config).toEqual({ depth: "comprehensive" });
-      expect(plan.steps[1].config).toEqual({ depth: "comprehensive" });
+      expect(plan.steps[0].config).toEqual({ depth: 'comprehensive' });
+      expect(plan.steps[1].config).toEqual({ depth: 'comprehensive' });
     });
 
-    it("should apply speed constraints", async () => {
+    it('should apply speed constraints', async () => {
       const recipe = createTestRecipe({
         steps: [
-          {
-            key: "step1",
-            name: "Step 1",
-            handlerRef: "h1",
-            timeout: 60000,
-            maxRetries: 5,
-          },
+          { key: 'step1', name: 'Step 1', handlerRef: 'h1', timeout: 60000, maxRetries: 5 },
         ],
       });
       const context: PlanningContext = {
-        constraints: { priority: "speed" },
+        constraints: { priority: 'speed' },
       };
 
       const plan = await planner.generatePlan(recipe, {}, context);
@@ -401,7 +343,7 @@ describe("RuleBasedPlanner", () => {
       expect(plan.steps[0].maxRetries).toBeLessThanOrEqual(1);
     });
 
-    it("should apply duration constraints", async () => {
+    it('should apply duration constraints', async () => {
       const recipe = createTestRecipe();
       const context: PlanningContext = {
         constraints: { maxDuration: 10000 },
@@ -414,15 +356,15 @@ describe("RuleBasedPlanner", () => {
       expect(plan.steps[1].timeout).toBeLessThanOrEqual(5000);
     });
 
-    it("should apply cost constraints (maxRetries=0)", async () => {
+    it('should apply cost constraints (maxRetries=0)', async () => {
       const recipe = createTestRecipe({
         steps: [
-          { key: "step1", name: "Step 1", handlerRef: "h1", maxRetries: 5 },
-          { key: "step2", name: "Step 2", handlerRef: "h2", maxRetries: 3 },
+          { key: 'step1', name: 'Step 1', handlerRef: 'h1', maxRetries: 5 },
+          { key: 'step2', name: 'Step 2', handlerRef: 'h2', maxRetries: 3 },
         ],
       });
       const context: PlanningContext = {
-        constraints: { priority: "cost" },
+        constraints: { priority: 'cost' },
       };
 
       const plan = await planner.generatePlan(recipe, {}, context);
@@ -431,19 +373,19 @@ describe("RuleBasedPlanner", () => {
       expect(plan.steps[1].maxRetries).toBe(0);
       expect(plan.modifications).toContainEqual(
         expect.objectContaining({
-          type: "set_default",
-          value: { priority: "cost" },
-        }),
+          type: 'set_default',
+          value: { priority: 'cost' },
+        })
       );
     });
 
-    it("should apply maxDuration to per-step timeouts evenly", async () => {
+    it('should apply maxDuration to per-step timeouts evenly', async () => {
       const recipe = createTestRecipe({
         steps: [
-          { key: "step1", name: "Step 1", handlerRef: "h1" },
-          { key: "step2", name: "Step 2", handlerRef: "h2" },
-          { key: "step3", name: "Step 3", handlerRef: "h3" },
-          { key: "step4", name: "Step 4", handlerRef: "h4" },
+          { key: 'step1', name: 'Step 1', handlerRef: 'h1' },
+          { key: 'step2', name: 'Step 2', handlerRef: 'h2' },
+          { key: 'step3', name: 'Step 3', handlerRef: 'h3' },
+          { key: 'step4', name: 'Step 4', handlerRef: 'h4' },
         ],
       });
       const context: PlanningContext = {
@@ -458,17 +400,17 @@ describe("RuleBasedPlanner", () => {
       }
       expect(plan.modifications).toContainEqual(
         expect.objectContaining({
-          type: "set_default",
+          type: 'set_default',
           value: { maxDuration: 20000 },
-        }),
+        })
       );
     });
 
-    it("should cap existing step timeout to per-step budget when maxDuration is set", async () => {
+    it('should cap existing step timeout to per-step budget when maxDuration is set', async () => {
       const recipe = createTestRecipe({
         steps: [
-          { key: "step1", name: "Step 1", handlerRef: "h1", timeout: 30000 },
-          { key: "step2", name: "Step 2", handlerRef: "h2", timeout: 2000 },
+          { key: 'step1', name: 'Step 1', handlerRef: 'h1', timeout: 30000 },
+          { key: 'step2', name: 'Step 2', handlerRef: 'h2', timeout: 2000 },
         ],
       });
       const context: PlanningContext = {
@@ -483,22 +425,22 @@ describe("RuleBasedPlanner", () => {
     });
   });
 
-  describe("plan", () => {
-    it("should select recipe and generate plan in one call", async () => {
+  describe('plan', () => {
+    it('should select recipe and generate plan in one call', async () => {
       registry.register(createTestRecipe());
 
-      const plan = await planner.plan("test.workflow", {});
+      const plan = await planner.plan('test.workflow', {});
 
-      expect(plan.recipeId).toBe("test.recipe");
+      expect(plan.recipeId).toBe('test.recipe');
       expect(plan.steps).toHaveLength(2);
-      expect(plan.reasoning).toContain("test.recipe");
+      expect(plan.reasoning).toContain('test.recipe');
     });
   });
 
-  describe("validatePlan", () => {
-    it("should validate a correct plan", async () => {
+  describe('validatePlan', () => {
+    it('should validate a correct plan', async () => {
       registry.register(createTestRecipe());
-      const plan = await planner.plan("test.workflow", {});
+      const plan = await planner.plan('test.workflow', {});
 
       const result = planner.validatePlan(plan);
 
@@ -506,11 +448,11 @@ describe("RuleBasedPlanner", () => {
       expect(result.errors).toHaveLength(0);
     });
 
-    it("should detect missing steps", () => {
+    it('should detect missing steps', () => {
       const result = planner.validatePlan({
-        id: "plan-1",
-        recipeId: "test",
-        variant: "default",
+        id: 'plan-1',
+        recipeId: 'test',
+        variant: 'default',
         modifications: [],
         steps: [],
         defaults: {},
@@ -518,37 +460,32 @@ describe("RuleBasedPlanner", () => {
       });
 
       expect(result.valid).toBe(false);
-      expect(result.errors).toContain("Plan has no steps");
+      expect(result.errors).toContain('Plan has no steps');
     });
 
-    it("should detect duplicate step keys", () => {
+    it('should detect duplicate step keys', () => {
       const result = planner.validatePlan({
-        id: "plan-1",
-        recipeId: "test",
-        variant: "default",
+        id: 'plan-1',
+        recipeId: 'test',
+        variant: 'default',
         modifications: [],
         steps: [
-          { key: "step1", name: "Step 1", handlerRef: "h1", config: {} },
-          {
-            key: "step1",
-            name: "Step 1 Duplicate",
-            handlerRef: "h2",
-            config: {},
-          },
+          { key: 'step1', name: 'Step 1', handlerRef: 'h1', config: {} },
+          { key: 'step1', name: 'Step 1 Duplicate', handlerRef: 'h2', config: {} },
         ],
         defaults: {},
         createdAt: new Date(),
       });
 
       expect(result.valid).toBe(false);
-      expect(result.errors).toContain("Duplicate step key: step1");
+      expect(result.errors).toContain('Duplicate step key: step1');
     });
   });
 
-  describe("estimateResources", () => {
-    it("should estimate resources for a plan", async () => {
+  describe('estimateResources', () => {
+    it('should estimate resources for a plan', async () => {
       registry.register(createTestRecipe());
-      const plan = await planner.plan("test.workflow", {});
+      const plan = await planner.plan('test.workflow', {});
 
       const estimate = planner.estimateResources(plan);
 
@@ -559,8 +496,8 @@ describe("RuleBasedPlanner", () => {
   });
 });
 
-describe("createRegistry", () => {
-  it("should create a combined registry", () => {
+describe('createRegistry', () => {
+  it('should create a combined registry', () => {
     const { recipes, handlers } = createRegistry();
 
     expect(recipes).toBeInstanceOf(MemoryRecipeRegistry);
@@ -568,7 +505,7 @@ describe("createRegistry", () => {
   });
 });
 
-describe("Condition Evaluation", () => {
+describe('Condition Evaluation', () => {
   let registry: MemoryRecipeRegistry;
   let planner: RuleBasedPlanner;
 
@@ -580,211 +517,211 @@ describe("Condition Evaluation", () => {
   const testConditions = async (
     conditions: RecipeCondition[],
     input: Record<string, unknown>,
-    shouldMatch: boolean,
+    shouldMatch: boolean
   ) => {
     registry.clear();
     registry.register({
-      id: "conditional",
-      name: "Conditional Recipe",
-      workflowKind: "test.workflow",
-      variant: "conditional",
-      steps: [{ key: "s1", name: "S1", handlerRef: "h1" }],
+      id: 'conditional',
+      name: 'Conditional Recipe',
+      workflowKind: 'test.workflow',
+      variant: 'conditional',
+      steps: [{ key: 's1', name: 'S1', handlerRef: 'h1' }],
       conditions,
       priority: 10,
     });
     registry.register({
-      id: "default",
-      name: "Default Recipe",
-      workflowKind: "test.workflow",
-      variant: "default",
-      steps: [{ key: "s1", name: "S1", handlerRef: "h1" }],
+      id: 'default',
+      name: 'Default Recipe',
+      workflowKind: 'test.workflow',
+      variant: 'default',
+      steps: [{ key: 's1', name: 'S1', handlerRef: 'h1' }],
     });
 
-    const result = await planner.selectRecipe("test.workflow", input);
+    const result = await planner.selectRecipe('test.workflow', input);
     if (shouldMatch) {
-      expect(result.recipe.id).toBe("conditional");
+      expect(result.recipe.id).toBe('conditional');
     } else {
-      expect(result.recipe.id).toBe("default");
+      expect(result.recipe.id).toBe('default');
     }
   };
 
-  it("should evaluate eq operator", async () => {
+  it('should evaluate eq operator', async () => {
     await testConditions(
-      [{ field: "type", operator: "eq", value: "fast" }],
-      { type: "fast" },
-      true,
+      [{ field: 'type', operator: 'eq', value: 'fast' }],
+      { type: 'fast' },
+      true
     );
     await testConditions(
-      [{ field: "type", operator: "eq", value: "fast" }],
-      { type: "slow" },
-      false,
+      [{ field: 'type', operator: 'eq', value: 'fast' }],
+      { type: 'slow' },
+      false
     );
   });
 
-  it("should evaluate neq operator", async () => {
+  it('should evaluate neq operator', async () => {
     await testConditions(
-      [{ field: "type", operator: "neq", value: "slow" }],
-      { type: "fast" },
-      true,
+      [{ field: 'type', operator: 'neq', value: 'slow' }],
+      { type: 'fast' },
+      true
     );
     await testConditions(
-      [{ field: "type", operator: "neq", value: "slow" }],
-      { type: "slow" },
-      false,
+      [{ field: 'type', operator: 'neq', value: 'slow' }],
+      { type: 'slow' },
+      false
     );
   });
 
-  it("should evaluate gt operator", async () => {
+  it('should evaluate gt operator', async () => {
     await testConditions(
-      [{ field: "count", operator: "gt", value: 10 }],
+      [{ field: 'count', operator: 'gt', value: 10 }],
       { count: 15 },
-      true,
+      true
     );
     await testConditions(
-      [{ field: "count", operator: "gt", value: 10 }],
+      [{ field: 'count', operator: 'gt', value: 10 }],
       { count: 5 },
-      false,
+      false
     );
   });
 
-  it("should evaluate gte operator", async () => {
+  it('should evaluate gte operator', async () => {
     await testConditions(
-      [{ field: "count", operator: "gte", value: 10 }],
+      [{ field: 'count', operator: 'gte', value: 10 }],
       { count: 10 },
-      true,
+      true
     );
     await testConditions(
-      [{ field: "count", operator: "gte", value: 10 }],
+      [{ field: 'count', operator: 'gte', value: 10 }],
       { count: 9 },
-      false,
+      false
     );
   });
 
-  it("should evaluate lt operator", async () => {
+  it('should evaluate lt operator', async () => {
     await testConditions(
-      [{ field: "count", operator: "lt", value: 10 }],
+      [{ field: 'count', operator: 'lt', value: 10 }],
       { count: 5 },
-      true,
+      true
     );
     await testConditions(
-      [{ field: "count", operator: "lt", value: 10 }],
+      [{ field: 'count', operator: 'lt', value: 10 }],
       { count: 15 },
-      false,
+      false
     );
   });
 
-  it("should evaluate lte operator", async () => {
+  it('should evaluate lte operator', async () => {
     await testConditions(
-      [{ field: "count", operator: "lte", value: 10 }],
+      [{ field: 'count', operator: 'lte', value: 10 }],
       { count: 10 },
-      true,
+      true
     );
     await testConditions(
-      [{ field: "count", operator: "lte", value: 10 }],
+      [{ field: 'count', operator: 'lte', value: 10 }],
       { count: 11 },
-      false,
+      false
     );
   });
 
-  it("should evaluate contains operator for strings", async () => {
+  it('should evaluate contains operator for strings', async () => {
     await testConditions(
-      [{ field: "name", operator: "contains", value: "test" }],
-      { name: "my-test-file" },
-      true,
+      [{ field: 'name', operator: 'contains', value: 'test' }],
+      { name: 'my-test-file' },
+      true
     );
     await testConditions(
-      [{ field: "name", operator: "contains", value: "test" }],
-      { name: "my-file" },
-      false,
+      [{ field: 'name', operator: 'contains', value: 'test' }],
+      { name: 'my-file' },
+      false
     );
   });
 
-  it("should evaluate contains operator for arrays", async () => {
+  it('should evaluate contains operator for arrays', async () => {
     await testConditions(
-      [{ field: "tags", operator: "contains", value: "urgent" }],
-      { tags: ["urgent", "review"] },
-      true,
+      [{ field: 'tags', operator: 'contains', value: 'urgent' }],
+      { tags: ['urgent', 'review'] },
+      true
     );
     await testConditions(
-      [{ field: "tags", operator: "contains", value: "urgent" }],
-      { tags: ["normal"] },
-      false,
+      [{ field: 'tags', operator: 'contains', value: 'urgent' }],
+      { tags: ['normal'] },
+      false
     );
   });
 
-  it("should evaluate matches operator", async () => {
+  it('should evaluate matches operator', async () => {
     await testConditions(
-      [{ field: "email", operator: "matches", value: "^test@" }],
-      { email: "test@example.com" },
-      true,
+      [{ field: 'email', operator: 'matches', value: '^test@' }],
+      { email: 'test@example.com' },
+      true
     );
     await testConditions(
-      [{ field: "email", operator: "matches", value: "^test@" }],
-      { email: "user@example.com" },
-      false,
+      [{ field: 'email', operator: 'matches', value: '^test@' }],
+      { email: 'user@example.com' },
+      false
     );
   });
 
-  it("should evaluate exists operator", async () => {
+  it('should evaluate exists operator', async () => {
     await testConditions(
-      [{ field: "optional", operator: "exists" }],
-      { optional: "value" },
-      true,
+      [{ field: 'optional', operator: 'exists' }],
+      { optional: 'value' },
+      true
     );
     await testConditions(
-      [{ field: "optional", operator: "exists" }],
-      { other: "value" },
-      false,
+      [{ field: 'optional', operator: 'exists' }],
+      { other: 'value' },
+      false
     );
     await testConditions(
-      [{ field: "optional", operator: "exists" }],
-      { optional: "" },
-      false,
+      [{ field: 'optional', operator: 'exists' }],
+      { optional: '' },
+      false
     );
   });
 
-  it("should evaluate notExists operator", async () => {
+  it('should evaluate notExists operator', async () => {
     await testConditions(
-      [{ field: "optional", operator: "notExists" }],
-      { other: "value" },
-      true,
+      [{ field: 'optional', operator: 'notExists' }],
+      { other: 'value' },
+      true
     );
     await testConditions(
-      [{ field: "optional", operator: "notExists" }],
-      { optional: "value" },
-      false,
+      [{ field: 'optional', operator: 'notExists' }],
+      { optional: 'value' },
+      false
     );
   });
 
-  it("should evaluate nested fields", async () => {
+  it('should evaluate nested fields', async () => {
     await testConditions(
-      [{ field: "config.settings.enabled", operator: "eq", value: true }],
+      [{ field: 'config.settings.enabled', operator: 'eq', value: true }],
       { config: { settings: { enabled: true } } },
-      true,
+      true
     );
     await testConditions(
-      [{ field: "config.settings.enabled", operator: "eq", value: true }],
+      [{ field: 'config.settings.enabled', operator: 'eq', value: true }],
       { config: { settings: { enabled: false } } },
-      false,
+      false
     );
   });
 
-  it("should require all conditions to match", async () => {
+  it('should require all conditions to match', async () => {
     await testConditions(
       [
-        { field: "type", operator: "eq", value: "fast" },
-        { field: "count", operator: "gt", value: 5 },
+        { field: 'type', operator: 'eq', value: 'fast' },
+        { field: 'count', operator: 'gt', value: 5 },
       ],
-      { type: "fast", count: 10 },
-      true,
+      { type: 'fast', count: 10 },
+      true
     );
     await testConditions(
       [
-        { field: "type", operator: "eq", value: "fast" },
-        { field: "count", operator: "gt", value: 5 },
+        { field: 'type', operator: 'eq', value: 'fast' },
+        { field: 'count', operator: 'gt', value: 5 },
       ],
-      { type: "fast", count: 3 },
-      false,
+      { type: 'fast', count: 3 },
+      false
     );
   });
 });