@studio-foundation/engine 0.3.0-beta.1

package/tests/unit/engine.test.ts

@@ -0,0 +1,770 @@
+import { describe, it, expect, vi } from 'vitest';
+import { join } from 'node:path';
+import { PipelineEngine, type EngineConfig, type RunInput } from '../../src/engine.js';
+import { InMemoryRunStore } from '../../src/state/run-store.js';
+import type { EngineEvents } from '../../src/events.js';
+import { ToolRegistry } from '@studio-foundation/runner';
+
+// Provider mock that hangs forever unless the abort signal fires.
+// Using a never-resolving inner promise means the abort is the ONLY way
+// the test completes — no timing race possible.
+function createHangingProvider() {
+  return {
+    name: 'anthropic',
+    call: vi.fn().mockImplementation(
+      (_req: unknown, _onToken: unknown, signal?: AbortSignal) => {
+        if (signal?.aborted) {
+          return Promise.reject(new DOMException('Aborted', 'AbortError'));
+        }
+        return new Promise<never>((_, reject) => {
+          if (!signal) return; // never resolves (only reached if no signal)
+          signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')), { once: true });
+        });
+      }
+    ),
+  };
+}
+
+// Minimal mock for ProviderRegistry
+function createMockProviderRegistry() {
+  const mockProvider = {
+    name: 'anthropic',
+    call: vi.fn().mockResolvedValue({
+      content: JSON.stringify({
+        summary: 'Test summary',
+        requirements: ['req1'],
+        acceptance_criteria: ['ac1'],
+        steps: ['step1'],
+        files_to_modify: ['file.ts'],
+        risks: ['none'],
+        files_changed: ['file.ts'],
+        status: 'pass',
+        issues: [],
+      }),
+      tool_calls: [],
+      finish_reason: 'stop',
+      usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+    }),
+  };
+
+  return {
+    get: vi.fn().mockReturnValue(mockProvider),
+    register: vi.fn(),
+  };
+}
+
+// Minimal mock for ToolRegistry
+function createMockToolRegistry() {
+  return {
+    register: vi.fn(),
+    get: vi.fn(),
+    has: vi.fn().mockReturnValue(false),
+    list: vi.fn().mockReturnValue([]),
+    toToolDefinitions: vi.fn().mockReturnValue([]),
+    filter: vi.fn().mockReturnThis(),
+    getActiveSnippets: vi.fn().mockReturnValue([]),
+  };
+}
+
+const FIXTURES_DIR = join(import.meta.dirname, '..', 'fixtures');
+const PROJECT_DIR = join(FIXTURES_DIR, 'test-project');
+const PIPELINES_DIR = join(PROJECT_DIR, 'pipelines');
+const AGENTS_DIR = join(PROJECT_DIR, 'agents');
+const CONTRACTS_DIR = join(PROJECT_DIR, 'contracts');
+
+// Create minimal test fixtures
+import { mkdirSync, writeFileSync } from 'node:fs';
+
+function setupTestFixtures() {
+  mkdirSync(PIPELINES_DIR, { recursive: true });
+  mkdirSync(AGENTS_DIR, { recursive: true });
+  mkdirSync(CONTRACTS_DIR, { recursive: true });
+
+  writeFileSync(join(PIPELINES_DIR, 'simple.pipeline.yaml'), `
+name: simple
+description: Simple test pipeline
+version: 1
+stages:
+  - name: analysis
+    kind: analysis
+    agent: test-agent
+    contract: test-contract
+    ralph:
+      max_attempts: 2
+      retry_strategy: none
+    context:
+      include:
+        - input
+`);
+
+  writeFileSync(join(PIPELINES_DIR, 'two-stage.pipeline.yaml'), `
+name: two-stage
+description: Two stage pipeline
+version: 1
+stages:
+  - name: stage-1
+    kind: analysis
+    agent: test-agent
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+  - name: stage-2
+    kind: planning
+    agent: test-agent
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+        - previous_stage_output
+`);
+
+  writeFileSync(join(AGENTS_DIR, 'test-agent.agent.yaml'), `
+name: test-agent
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.3
+`);
+
+  writeFileSync(join(CONTRACTS_DIR, 'test-contract.contract.yaml'), `
+name: test-contract
+version: 1
+schema:
+  required_fields:
+    - summary
+`);
+  writeFileSync(join(PIPELINES_DIR, 'hook-output-template.pipeline.yaml'), `
+name: hook-output-template
+description: Pipeline that verifies on_stage_complete hook receives stage output as template context
+version: 1
+stages:
+  - name: analysis
+    kind: analysis
+    agent: test-agent
+    contract: test-contract
+    hooks:
+      on_stage_complete:
+        - command: "sh -c 'echo {{output.files_changed}} | grep -qx file.ts'"
+          on_failure: reject
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+`);
+  writeFileSync(join(PIPELINES_DIR, 'hook-reject-on-failure.pipeline.yaml'), `
+name: hook-reject-on-failure
+description: Pipeline where on_stage_complete hook fails and rejects the stage
+version: 1
+stages:
+  - name: analysis
+    kind: analysis
+    agent: test-agent
+    contract: test-contract
+    hooks:
+      on_stage_complete:
+        - command: "sh -c 'echo hook-error-output >&2; exit 1'"
+          on_failure: reject
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+`);
+
+  // Fixtures for maximum-only tool_calls contract
+  writeFileSync(join(CONTRACTS_DIR, 'maximum-only.contract.yaml'), `
+name: maximum-only
+version: 1
+schema:
+  required_fields:
+    - summary
+tool_calls:
+  maximum: 2
+`);
+  writeFileSync(join(PIPELINES_DIR, 'maximum-only.pipeline.yaml'), `
+name: maximum-only
+description: Pipeline with a contract that only sets maximum tool_calls
+version: 1
+stages:
+  - name: analysis
+    kind: analysis
+    agent: test-agent
+    contract: maximum-only
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+`);
+
+  // Fixture for on_pipeline_start integration test
+  writeFileSync(join(PIPELINES_DIR, 'with-startup.pipeline.yaml'), `
+name: with-startup
+description: Pipeline that exercises on_pipeline_start context injection
+version: 1
+on_pipeline_start:
+  - command: "echo git-status-output"
+    inject_as: git_status
+stages:
+  - name: analysis
+    kind: analysis
+    agent: test-agent
+    contract: test-contract
+    ralph:
+      max_attempts: 1
+      retry_strategy: none
+    context:
+      include:
+        - input
+        - pipeline_start_context
+`);
+
+  writeFileSync(join(PIPELINES_DIR, 'group-simple.pipeline.yaml'), `
+name: group-simple
+description: Pipeline with a simple group for cancellation testing
+version: 1
+stages:
+  - group: review-loop
+    max_iterations: 2
+    stages:
+      - name: review-stage-1
+        kind: analysis
+        agent: test-agent
+        ralph:
+          max_attempts: 1
+          retry_strategy: none
+        context:
+          include:
+            - input
+      - name: review-stage-2
+        kind: analysis
+        agent: test-agent
+        ralph:
+          max_attempts: 1
+          retry_strategy: none
+        context:
+          include:
+            - input
+`);
+}
+
+// Setup fixtures before all tests
+setupTestFixtures();
+
+function createTestEngine(overrides: Partial<EngineConfig> = {}): PipelineEngine {
+  return new PipelineEngine({
+    configsDir: PROJECT_DIR,
+    providerRegistry: createMockProviderRegistry() as any,
+    toolRegistry: createMockToolRegistry() as any,
+    db: new InMemoryRunStore(),
+    ...overrides,
+  });
+}
+
+describe('PipelineEngine', () => {
+  it('runs a simple single-stage pipeline', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'Add a FAQ section',
+    });
+
+    expect(result.status).toBe('success');
+    expect(result.pipeline_name).toBe('simple');
+    expect(result.stages).toHaveLength(1);
+    expect(result.stages[0].stage_name).toBe('analysis');
+    expect(result.stages[0].status).toBe('success');
+  });
+
+  it('runs a multi-stage pipeline', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'two-stage',
+      input: 'Build feature X',
+    });
+
+    expect(result.status).toBe('success');
+    expect(result.stages).toHaveLength(2);
+    expect(result.stages[0].stage_name).toBe('stage-1');
+    expect(result.stages[1].stage_name).toBe('stage-2');
+  });
+
+  it('persists run to store', async () => {
+    const store = new InMemoryRunStore();
+    const engine = createTestEngine({ db: store });
+
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'Test persist',
+    });
+
+    const stored = store.getPipelineRun(result.id);
+    expect(stored).not.toBeNull();
+    expect(stored!.id).toBe(result.id);
+    expect(stored!.status).toBe('success');
+  });
+
+  it('emits lifecycle events', async () => {
+    const events: string[] = [];
+    const engineEvents: EngineEvents = {
+      onPipelineStart: () => events.push('pipeline_start'),
+      onPipelineComplete: () => events.push('pipeline_complete'),
+      onStageStart: () => events.push('stage_start'),
+      onStageComplete: () => events.push('stage_complete'),
+    };
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: createMockProviderRegistry() as any,
+        toolRegistry: createMockToolRegistry() as any,
+      },
+      engineEvents
+    );
+
+    await engine.run({ pipeline: 'simple', input: 'test events' });
+
+    expect(events).toEqual([
+      'pipeline_start',
+      'stage_start',
+      'stage_complete',
+      'pipeline_complete',
+    ]);
+  });
+
+  it('stops pipeline on stage failure (validation fails)', async () => {
+    // Provider returns output missing required 'summary' field
+    const badProvider = {
+      name: 'anthropic',
+      call: vi.fn().mockResolvedValue({
+        content: JSON.stringify({ no_summary: true }),
+        tool_calls: [],
+        finish_reason: 'stop',
+      }),
+    };
+
+    const engine = createTestEngine({
+      providerRegistry: { get: vi.fn().mockReturnValue(badProvider), register: vi.fn() } as any,
+    });
+
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'This should fail validation',
+    });
+
+    expect(result.status).toBe('failed');
+    expect(result.stages[0].status).toBe('failed');
+  });
+
+  it('sets completed_at on pipeline run', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'test timestamps',
+    });
+
+    expect(result.started_at).toBeDefined();
+    expect(result.completed_at).toBeDefined();
+  });
+
+  it('creates proper stage run with tasks and agent runs', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'test structure',
+    });
+
+    const stage = result.stages[0];
+    expect(stage.tasks).toHaveLength(1);
+
+    const task = stage.tasks[0];
+    expect(task.task_name).toBe('analysis');
+    expect(task.agent_runs.length).toBeGreaterThanOrEqual(1);
+
+    const agentRun = task.agent_runs[0];
+    expect(agentRun.agent_name).toBe('test-agent');
+    expect(agentRun.attempt).toBe(1);
+  });
+
+  it('throws for non-existent pipeline', async () => {
+    const engine = createTestEngine();
+    await expect(
+      engine.run({ pipeline: 'nonexistent', input: 'test' })
+    ).rejects.toThrow('Failed to load pipeline');
+  });
+
+  it('emits enriched stage complete events with summary and tokens', async () => {
+    const stageEvents: any[] = [];
+    const engineEvents: EngineEvents = {
+      onPipelineStart: () => {},
+      onPipelineComplete: () => {},
+      onStageStart: () => {},
+      onStageComplete: (e) => stageEvents.push(e),
+    };
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: createMockProviderRegistry() as any,
+        toolRegistry: createMockToolRegistry() as any,
+      },
+      engineEvents
+    );
+
+    await engine.run({ pipeline: 'simple', input: 'test enriched events' });
+
+    expect(stageEvents).toHaveLength(1);
+    const e = stageEvents[0];
+    expect(e.stage_name).toBe('analysis');
+    expect(e.stage_index).toBe(0);
+    expect(e.total_stages).toBe(1);
+    expect(e.status).toBe('success');
+    expect(e.attempts).toBe(1);
+    expect(e.duration_ms).toBeGreaterThanOrEqual(0);
+    expect(e.output_summary).toBeDefined();
+    expect(typeof e.output_summary).toBe('string');
+  });
+
+  it('emits pipeline complete with totals', async () => {
+    const pipelineEvents: any[] = [];
+    const engineEvents: EngineEvents = {
+      onPipelineComplete: (e) => pipelineEvents.push(e),
+    };
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: createMockProviderRegistry() as any,
+        toolRegistry: createMockToolRegistry() as any,
+      },
+      engineEvents
+    );
+
+    await engine.run({ pipeline: 'simple', input: 'test totals' });
+
+    expect(pipelineEvents).toHaveLength(1);
+    const e = pipelineEvents[0];
+    expect(e.status).toBe('success');
+    expect(typeof e.total_tokens).toBe('number');
+    expect(typeof e.total_tool_calls).toBe('number');
+    expect(typeof e.duration_ms).toBe('number');
+  });
+
+  it('emits pipeline_complete with status failed when stage fails', async () => {
+    const pipelineEvents: any[] = [];
+    const badProvider = {
+      name: 'anthropic',
+      call: vi.fn().mockResolvedValue({
+        content: JSON.stringify({ no_summary: true }),
+        tool_calls: [],
+        finish_reason: 'stop',
+      }),
+    };
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: { get: vi.fn().mockReturnValue(badProvider), register: vi.fn() } as any,
+        toolRegistry: createMockToolRegistry() as any,
+      },
+      { onPipelineComplete: (e) => pipelineEvents.push(e) }
+    );
+
+    const result = await engine.run({ pipeline: 'simple', input: 'will fail' });
+
+    expect(result.status).toBe('failed');
+    expect(pipelineEvents).toHaveLength(1);
+    expect(pipelineEvents[0].status).toBe('failed');
+    expect(typeof pipelineEvents[0].duration_ms).toBe('number');
+    expect(typeof pipelineEvents[0].total_tokens).toBe('number');
+    expect(typeof pipelineEvents[0].total_tool_calls).toBe('number');
+  });
+
+  it('emits pipeline_complete with status rejected when stage is rejected', async () => {
+    const pipelineEvents: any[] = [];
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: createMockProviderRegistry() as any,
+        toolRegistry: createMockToolRegistry() as any,
+      },
+      { onPipelineComplete: (e) => pipelineEvents.push(e) }
+    );
+
+    const result = await engine.run({ pipeline: 'hook-reject-on-failure', input: 'will reject' });
+
+    expect(result.status).toBe('rejected');
+    expect(pipelineEvents).toHaveLength(1);
+    expect(pipelineEvents[0].status).toBe('rejected');
+    expect(typeof pipelineEvents[0].duration_ms).toBe('number');
+  });
+
+  it('on_stage_complete hook receives stage output as template context', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'hook-output-template',
+      input: 'test',
+    });
+
+    // The hook checks {{output.files_changed}} == 'file.ts'
+    // The mock provider returns files_changed: ['file.ts'] → renders as 'file.ts'
+    // Without the fix: template not resolved → hook fails → stage rejected
+    // With the fix: template resolves correctly → hook passes → stage succeeds
+    expect(result.status).toBe('success');
+    expect(result.stages[0].status).toBe('success');
+  });
+
+  it('on_stage_complete hook failure with on_failure:reject causes stage rejection', async () => {
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'hook-reject-on-failure',
+      input: 'test',
+    });
+
+    expect(result.status).toBe('rejected');
+    expect(result.stages[0].status).toBe('rejected');
+    expect(result.stages[0]).toMatchObject({
+      status: 'rejected',
+    });
+  });
+
+  it('returns cancelled when signal is aborted before stages run', async () => {
+    const controller = new AbortController();
+    controller.abort(); // Pre-aborted
+
+    const engine = createTestEngine();
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'test input',
+      signal: controller.signal,
+    });
+
+    expect(result.status).toBe('cancelled');
+    expect(result.stages).toHaveLength(0);
+  });
+
+  it('cancels cleanly when signal is aborted while a stage is executing', async () => {
+    const controller = new AbortController();
+
+    const engine = createTestEngine({
+      providerRegistry: { get: vi.fn().mockReturnValue(createHangingProvider()), register: vi.fn() } as any,
+    });
+
+    // Abort after the engine has started (next microtask), before the hanging provider resolves
+    queueMicrotask(() => controller.abort());
+
+    const result = await engine.run({
+      pipeline: 'simple',
+      input: 'test input',
+      signal: controller.signal,
+    });
+
+    expect(result.status).toBe('cancelled');
+  });
+
+  it('cancels between stages when signal is aborted after first stage completes', async () => {
+    const controller = new AbortController();
+    let stage1Completed = false;
+
+    const events: EngineEvents = {
+      onStageComplete: (e) => {
+        if (e.stage_name === 'stage-1') {
+          stage1Completed = true;
+          controller.abort(); // abort after stage 1 finishes
+        }
+      },
+    };
+
+    const engine = new PipelineEngine(
+      {
+        configsDir: PROJECT_DIR,
+        providerRegistry: createMockProviderRegistry() as any,
+        toolRegistry: createMockToolRegistry() as any,
+        db: new InMemoryRunStore(),
+      },
+      events
+    );
+
+    const result = await engine.run({
+      pipeline: 'two-stage',
+      input: 'test input',
+      signal: controller.signal,
+    });
+
+    expect(result.status).toBe('cancelled');
+    expect(stage1Completed).toBe(true);
+    expect(result.stages).toHaveLength(1);
+    expect(result.stages[0].stage_name).toBe('stage-1');
+    expect(result.stages[0].status).toBe('success');
+  });
+
+  it('cancels cleanly when signal is aborted during a group stage', async () => {
+    const controller = new AbortController();
+
+    const engine = createTestEngine({
+      providerRegistry: { get: vi.fn().mockReturnValue(createHangingProvider()), register: vi.fn() } as any,
+    });
+
+    // Abort after the engine has started (next microtask), before the hanging provider resolves
+    queueMicrotask(() => controller.abort());
+
+    const result = await engine.run({
+      pipeline: 'group-simple',
+      input: 'test input',
+      signal: controller.signal,
+    });
+
+    expect(result.status).toBe('cancelled');
+  });
+
+  it('on_pipeline_start output is injected into stage context', async () => {
+    // The 'with-startup' pipeline runs `echo git-status-output` and injects it
+    // as 'git_status'. The stage includes 'pipeline_start_context'.
+    // The prompt-builder formats startup_context as:
+    //   ## Pipeline Startup Context
+    //   ### git_status
+    //   ```
+    //   git-status-output
+    //   ```
+    // So we assert that the provider received a user message containing that value.
+    const capturedRequests: any[] = [];
+    const provider = {
+      name: 'anthropic',
+      call: vi.fn().mockImplementation(async (req: any) => {
+        capturedRequests.push(req);
+        return {
+          content: JSON.stringify({ summary: 'done', requirements: [], acceptance_criteria: [] }),
+          tool_calls: [],
+          finish_reason: 'stop',
+          usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+        };
+      }),
+    };
+
+    const engine = createTestEngine({
+      providerRegistry: { get: vi.fn().mockReturnValue(provider), register: vi.fn() } as any,
+    });
+
+    const result = await engine.run({ pipeline: 'with-startup', input: 'test startup' });
+
+    expect(result.status).toBe('success');
+    expect(capturedRequests).toHaveLength(1);
+
+    const userMessage = capturedRequests[0].messages.find((m: any) => m.role === 'user');
+    expect(userMessage).toBeDefined();
+    expect(userMessage.content).toContain('git-status-output');
+  });
+
+  it('fails stage when tool_calls maximum is exceeded (maximum-only contract)', async () => {
+    // A contract with only `maximum: 2` and no `minimum`.
+    // Before the guard fix, this validator was silently skipped.
+    // After the fix it must be activated and fail when 3 successful tool calls are made.
+
+    // Create a real ToolRegistry with a succeeding test tool
+    const toolRegistry = new ToolRegistry();
+    toolRegistry.register({
+      name: 'test-tool',
+      description: 'A simple test tool',
+      parameters: { type: 'object', properties: {}, required: [] },
+      execute: async () => ({ success: true, output: 'ok' }),
+    });
+
+    // Mock provider: returns 3 tool calls on the first call, then valid output
+    let callCount = 0;
+    const provider = {
+      name: 'anthropic',
+      call: vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 1) {
+          // First turn: 3 tool calls (exceeds maximum of 2)
+          return {
+            content: '',
+            tool_calls: [
+              { id: 'tc-1', name: 'test-tool', arguments: {} },
+              { id: 'tc-2', name: 'test-tool', arguments: {} },
+              { id: 'tc-3', name: 'test-tool', arguments: {} },
+            ],
+            finish_reason: 'tool_calls',
+          };
+        }
+        // Second turn: final response with valid output
+        return {
+          content: JSON.stringify({ summary: 'done' }),
+          tool_calls: [],
+          finish_reason: 'stop',
+          usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
+        };
+      }),
+    };
+
+    const engine = new PipelineEngine({
+      configsDir: PROJECT_DIR,
+      providerRegistry: { get: vi.fn().mockReturnValue(provider), register: vi.fn() } as any,
+      toolRegistry: toolRegistry as any,
+      db: new InMemoryRunStore(),
+    });
+
+    const result = await engine.run({ pipeline: 'maximum-only', input: 'test maximum' });
+
+    expect(result.status).toBe('failed');
+    expect(result.stages[0].status).toBe('failed');
+  });
+
+  it('succeeds stage when tool_calls count is within maximum (maximum-only contract)', async () => {
+    // Same contract (maximum: 2), but only 1 tool call made — should pass.
+
+    const toolRegistry = new ToolRegistry();
+    toolRegistry.register({
+      name: 'test-tool',
+      description: 'A simple test tool',
+      parameters: { type: 'object', properties: {}, required: [] },
+      execute: async () => ({ success: true, output: 'ok' }),
+    });
+
+    let callCount = 0;
+    const provider = {
+      name: 'anthropic',
+      call: vi.fn().mockImplementation(async () => {
+        callCount++;
+        if (callCount === 1) {
+          // First turn: 1 tool call (within maximum of 2)
+          return {
+            content: '',
+            tool_calls: [
+              { id: 'tc-1', name: 'test-tool', arguments: {} },
+            ],
+            finish_reason: 'tool_calls',
+          };
+        }
+        // Second turn: final response with valid output
+        return {
+          content: JSON.stringify({ summary: 'done' }),
+          tool_calls: [],
+          finish_reason: 'stop',
+          usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
+        };
+      }),
+    };
+
+    const engine = new PipelineEngine({
+      configsDir: PROJECT_DIR,
+      providerRegistry: { get: vi.fn().mockReturnValue(provider), register: vi.fn() } as any,
+      toolRegistry: toolRegistry as any,
+      db: new InMemoryRunStore(),
+    });
+
+    const result = await engine.run({ pipeline: 'maximum-only', input: 'test maximum within bounds' });
+
+    expect(result.status).toBe('success');
+    expect(result.stages[0].status).toBe('success');
+  });
+});